1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 // This file is available under and governed by the GNU General Public
26 // License version 2 only, as published by the Free Software Foundation.
27 // However, the following notice accompanied the original version of this
28 // file:
29 //
30 //---------------------------------------------------------------------------------
31 //
32 // Little Color Management System
33 // Copyright (c) 1998-2020 Marti Maria Saguer
34 //
35 // Permission is hereby granted, free of charge, to any person obtaining
36 // a copy of this software and associated documentation files (the "Software"),
37 // to deal in the Software without restriction, including without limitation
38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
39 // and/or sell copies of the Software, and to permit persons to whom the Software
40 // is furnished to do so, subject to the following conditions:
41 //
42 // The above copyright notice and this permission notice shall be included in
43 // all copies or substantial portions of the Software.
44 //
45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
52 //
53 //---------------------------------------------------------------------------------
54 //
55
56 #include "lcms2_internal.h"
57
58 // This module handles all formats supported by lcms. There are two flavors, 16 bits and
59 // floating point. Floating point is supported only in a subset, those formats holding
60 // cmsFloat32Number (4 bytes per component) and double (marked as 0 bytes per component
61 // as special case)
62
63 // ---------------------------------------------------------------------------
64
65
66 // This macro return words stored as big endian
67 #define CHANGE_ENDIAN(w) (cmsUInt16Number) ((cmsUInt16Number) ((w)<<8)|((w)>>8))
68
69 // These macros handles reversing (negative)
70 #define REVERSE_FLAVOR_8(x) ((cmsUInt8Number) (0xff-(x)))
71 #define REVERSE_FLAVOR_16(x) ((cmsUInt16Number)(0xffff-(x)))
72
73 // * 0xffff / 0xff00 = (255 * 257) / (255 * 256) = 257 / 256
74 cmsINLINE cmsUInt16Number FomLabV2ToLabV4(cmsUInt16Number x)
75 {
76 int a = (x << 8 | x) >> 8; // * 257 / 256
77 if ( a > 0xffff) return 0xffff;
78 return (cmsUInt16Number) a;
79 }
80
81 // * 0xf00 / 0xffff = * 256 / 257
82 cmsINLINE cmsUInt16Number FomLabV4ToLabV2(cmsUInt16Number x)
83 {
84 return (cmsUInt16Number) (((x << 8) + 0x80) / 257);
85 }
86
87
88 typedef struct {
89 cmsUInt32Number Type;
90 cmsUInt32Number Mask;
91 cmsFormatter16 Frm;
92
93 } cmsFormatters16;
94
95 typedef struct {
96 cmsUInt32Number Type;
97 cmsUInt32Number Mask;
98 cmsFormatterFloat Frm;
99
100 } cmsFormattersFloat;
101
102
103 #define ANYSPACE COLORSPACE_SH(31)
104 #define ANYCHANNELS CHANNELS_SH(15)
105 #define ANYEXTRA EXTRA_SH(7)
106 #define ANYPLANAR PLANAR_SH(1)
107 #define ANYENDIAN ENDIAN16_SH(1)
108 #define ANYSWAP DOSWAP_SH(1)
109 #define ANYSWAPFIRST SWAPFIRST_SH(1)
110 #define ANYFLAVOR FLAVOR_SH(1)
111
112
113 // Suppress waning about info never being used
114
115 #ifdef _MSC_VER
116 #pragma warning(disable : 4100)
117 #endif
118
119 // Unpacking routines (16 bits) ----------------------------------------------------------------------------------------
120
121
122 // Does almost everything but is slow
123 static
124 cmsUInt8Number* UnrollChunkyBytes(CMSREGISTER _cmsTRANSFORM* info,
125 CMSREGISTER cmsUInt16Number wIn[],
126 CMSREGISTER cmsUInt8Number* accum,
127 CMSREGISTER cmsUInt32Number Stride)
128 {
129 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
130 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
131 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
132 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
133 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
134 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
135 cmsUInt16Number v;
136 cmsUInt32Number i;
137
138 if (ExtraFirst) {
139 accum += Extra;
140 }
141
142 for (i=0; i < nChan; i++) {
143 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
144
145 v = FROM_8_TO_16(*accum);
146 v = Reverse ? REVERSE_FLAVOR_16(v) : v;
147 wIn[index] = v;
148 accum++;
149 }
150
151 if (!ExtraFirst) {
152 accum += Extra;
153 }
154
155 if (Extra == 0 && SwapFirst) {
156 cmsUInt16Number tmp = wIn[0];
157
158 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
159 wIn[nChan-1] = tmp;
160 }
161
162 return accum;
163
164 cmsUNUSED_PARAMETER(info);
165 cmsUNUSED_PARAMETER(Stride);
166
167 }
168
169 // Extra channels are just ignored because come in the next planes
170 static
171 cmsUInt8Number* UnrollPlanarBytes(CMSREGISTER _cmsTRANSFORM* info,
172 CMSREGISTER cmsUInt16Number wIn[],
173 CMSREGISTER cmsUInt8Number* accum,
174 CMSREGISTER cmsUInt32Number Stride)
175 {
176 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
177 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
178 cmsUInt32Number SwapFirst = T_SWAPFIRST(info ->InputFormat);
179 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
180 cmsUInt32Number i;
181 cmsUInt8Number* Init = accum;
182
183 if (DoSwap ^ SwapFirst) {
184 accum += T_EXTRA(info -> InputFormat) * Stride;
185 }
186
187 for (i=0; i < nChan; i++) {
188
189 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
190 cmsUInt16Number v = FROM_8_TO_16(*accum);
191
192 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
193 accum += Stride;
194 }
195
196 return (Init + 1);
197 }
198
199 // Special cases, provided for performance
200 static
201 cmsUInt8Number* Unroll4Bytes(CMSREGISTER _cmsTRANSFORM* info,
202 CMSREGISTER cmsUInt16Number wIn[],
203 CMSREGISTER cmsUInt8Number* accum,
204 CMSREGISTER cmsUInt32Number Stride)
205 {
206 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
207 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
208 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
209 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
210
211 return accum;
212
213 cmsUNUSED_PARAMETER(info);
214 cmsUNUSED_PARAMETER(Stride);
215 }
216
217 static
218 cmsUInt8Number* Unroll4BytesReverse(CMSREGISTER _cmsTRANSFORM* info,
219 CMSREGISTER cmsUInt16Number wIn[],
220 CMSREGISTER cmsUInt8Number* accum,
221 CMSREGISTER cmsUInt32Number Stride)
222 {
223 wIn[0] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // C
224 wIn[1] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // M
225 wIn[2] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // Y
226 wIn[3] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K
227
228 return accum;
229
230 cmsUNUSED_PARAMETER(info);
231 cmsUNUSED_PARAMETER(Stride);
232 }
233
234 static
235 cmsUInt8Number* Unroll4BytesSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
236 CMSREGISTER cmsUInt16Number wIn[],
237 CMSREGISTER cmsUInt8Number* accum,
238 CMSREGISTER cmsUInt32Number Stride)
239 {
240 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
241 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
242 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
243 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
244
245 return accum;
246
247 cmsUNUSED_PARAMETER(info);
248 cmsUNUSED_PARAMETER(Stride);
249 }
250
251 // KYMC
252 static
253 cmsUInt8Number* Unroll4BytesSwap(CMSREGISTER _cmsTRANSFORM* info,
254 CMSREGISTER cmsUInt16Number wIn[],
255 CMSREGISTER cmsUInt8Number* accum,
256 CMSREGISTER cmsUInt32Number Stride)
257 {
258 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
259 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
260 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
261 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
262
263 return accum;
264
265 cmsUNUSED_PARAMETER(info);
266 cmsUNUSED_PARAMETER(Stride);
267 }
268
269 static
270 cmsUInt8Number* Unroll4BytesSwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
271 CMSREGISTER cmsUInt16Number wIn[],
272 CMSREGISTER cmsUInt8Number* accum,
273 CMSREGISTER cmsUInt32Number Stride)
274 {
275 wIn[2] = FROM_8_TO_16(*accum); accum++; // K
276 wIn[1] = FROM_8_TO_16(*accum); accum++; // Y
277 wIn[0] = FROM_8_TO_16(*accum); accum++; // M
278 wIn[3] = FROM_8_TO_16(*accum); accum++; // C
279
280 return accum;
281
282 cmsUNUSED_PARAMETER(info);
283 cmsUNUSED_PARAMETER(Stride);
284 }
285
286 static
287 cmsUInt8Number* Unroll3Bytes(CMSREGISTER _cmsTRANSFORM* info,
288 CMSREGISTER cmsUInt16Number wIn[],
289 CMSREGISTER cmsUInt8Number* accum,
290 CMSREGISTER cmsUInt32Number Stride)
291 {
292 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
293 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
294 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
295
296 return accum;
297
298 cmsUNUSED_PARAMETER(info);
299 cmsUNUSED_PARAMETER(Stride);
300 }
301
302 static
303 cmsUInt8Number* Unroll3BytesSkip1Swap(CMSREGISTER _cmsTRANSFORM* info,
304 CMSREGISTER cmsUInt16Number wIn[],
305 CMSREGISTER cmsUInt8Number* accum,
306 CMSREGISTER cmsUInt32Number Stride)
307 {
308 accum++; // A
309 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
310 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
311 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
312
313 return accum;
314
315 cmsUNUSED_PARAMETER(info);
316 cmsUNUSED_PARAMETER(Stride);
317 }
318
319 static
320 cmsUInt8Number* Unroll3BytesSkip1SwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
321 CMSREGISTER cmsUInt16Number wIn[],
322 CMSREGISTER cmsUInt8Number* accum,
323 CMSREGISTER cmsUInt32Number Stride)
324 {
325 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
326 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
327 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
328 accum++; // A
329
330 return accum;
331
332 cmsUNUSED_PARAMETER(info);
333 cmsUNUSED_PARAMETER(Stride);
334 }
335
336 static
337 cmsUInt8Number* Unroll3BytesSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
338 CMSREGISTER cmsUInt16Number wIn[],
339 CMSREGISTER cmsUInt8Number* accum,
340 CMSREGISTER cmsUInt32Number Stride)
341 {
342 accum++; // A
343 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
344 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
345 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
346
347 return accum;
348
349 cmsUNUSED_PARAMETER(info);
350 cmsUNUSED_PARAMETER(Stride);
351 }
352
353
354 // BRG
355 static
356 cmsUInt8Number* Unroll3BytesSwap(CMSREGISTER _cmsTRANSFORM* info,
357 CMSREGISTER cmsUInt16Number wIn[],
358 CMSREGISTER cmsUInt8Number* accum,
359 CMSREGISTER cmsUInt32Number Stride)
360 {
361 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
362 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
363 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
364
365 return accum;
366
367 cmsUNUSED_PARAMETER(info);
368 cmsUNUSED_PARAMETER(Stride);
369 }
370
371 static
372 cmsUInt8Number* UnrollLabV2_8(CMSREGISTER _cmsTRANSFORM* info,
373 CMSREGISTER cmsUInt16Number wIn[],
374 CMSREGISTER cmsUInt8Number* accum,
375 CMSREGISTER cmsUInt32Number Stride)
376 {
377 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L
378 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a
379 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
380
381 return accum;
382
383 cmsUNUSED_PARAMETER(info);
384 cmsUNUSED_PARAMETER(Stride);
385 }
386
387 static
388 cmsUInt8Number* UnrollALabV2_8(CMSREGISTER _cmsTRANSFORM* info,
389 CMSREGISTER cmsUInt16Number wIn[],
390 CMSREGISTER cmsUInt8Number* accum,
391 CMSREGISTER cmsUInt32Number Stride)
392 {
393 accum++; // A
394 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L
395 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a
396 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
397
398 return accum;
399
400 cmsUNUSED_PARAMETER(info);
401 cmsUNUSED_PARAMETER(Stride);
402 }
403
404 static
405 cmsUInt8Number* UnrollLabV2_16(CMSREGISTER _cmsTRANSFORM* info,
406 CMSREGISTER cmsUInt16Number wIn[],
407 CMSREGISTER cmsUInt8Number* accum,
408 CMSREGISTER cmsUInt32Number Stride)
409 {
410 wIn[0] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // L
411 wIn[1] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // a
412 wIn[2] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // b
413
414 return accum;
415
416 cmsUNUSED_PARAMETER(info);
417 cmsUNUSED_PARAMETER(Stride);
418 }
419
420 // for duplex
421 static
422 cmsUInt8Number* Unroll2Bytes(CMSREGISTER _cmsTRANSFORM* info,
423 CMSREGISTER cmsUInt16Number wIn[],
424 CMSREGISTER cmsUInt8Number* accum,
425 CMSREGISTER cmsUInt32Number Stride)
426 {
427 wIn[0] = FROM_8_TO_16(*accum); accum++; // ch1
428 wIn[1] = FROM_8_TO_16(*accum); accum++; // ch2
429
430 return accum;
431
432 cmsUNUSED_PARAMETER(info);
433 cmsUNUSED_PARAMETER(Stride);
434 }
435
436
437
438
439 // Monochrome duplicates L into RGB for null-transforms
440 static
441 cmsUInt8Number* Unroll1Byte(CMSREGISTER _cmsTRANSFORM* info,
442 CMSREGISTER cmsUInt16Number wIn[],
443 CMSREGISTER cmsUInt8Number* accum,
444 CMSREGISTER cmsUInt32Number Stride)
445 {
446 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
447
448 return accum;
449
450 cmsUNUSED_PARAMETER(info);
451 cmsUNUSED_PARAMETER(Stride);
452 }
453
454
455 static
456 cmsUInt8Number* Unroll1ByteSkip1(CMSREGISTER _cmsTRANSFORM* info,
457 CMSREGISTER cmsUInt16Number wIn[],
458 CMSREGISTER cmsUInt8Number* accum,
459 CMSREGISTER cmsUInt32Number Stride)
460 {
461 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
462 accum += 1;
463
464 return accum;
465
466 cmsUNUSED_PARAMETER(info);
467 cmsUNUSED_PARAMETER(Stride);
468 }
469
470 static
471 cmsUInt8Number* Unroll1ByteSkip2(CMSREGISTER _cmsTRANSFORM* info,
472 CMSREGISTER cmsUInt16Number wIn[],
473 CMSREGISTER cmsUInt8Number* accum,
474 CMSREGISTER cmsUInt32Number Stride)
475 {
476 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
477 accum += 2;
478
479 return accum;
480
481 cmsUNUSED_PARAMETER(info);
482 cmsUNUSED_PARAMETER(Stride);
483 }
484
485 static
486 cmsUInt8Number* Unroll1ByteReversed(CMSREGISTER _cmsTRANSFORM* info,
487 CMSREGISTER cmsUInt16Number wIn[],
488 CMSREGISTER cmsUInt8Number* accum,
489 CMSREGISTER cmsUInt32Number Stride)
490 {
491 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(FROM_8_TO_16(*accum)); accum++; // L
492
493 return accum;
494
495 cmsUNUSED_PARAMETER(info);
496 cmsUNUSED_PARAMETER(Stride);
497 }
498
499
500 static
501 cmsUInt8Number* UnrollAnyWords(CMSREGISTER _cmsTRANSFORM* info,
502 CMSREGISTER cmsUInt16Number wIn[],
503 CMSREGISTER cmsUInt8Number* accum,
504 CMSREGISTER cmsUInt32Number Stride)
505 {
506 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
507 cmsUInt32Number SwapEndian = T_ENDIAN16(info -> InputFormat);
508 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
509 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
510 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
511 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
512 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
513 cmsUInt32Number i;
514
515 if (ExtraFirst) {
516 accum += Extra * sizeof(cmsUInt16Number);
517 }
518
519 for (i=0; i < nChan; i++) {
520
521 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
522 cmsUInt16Number v = *(cmsUInt16Number*) accum;
523
524 if (SwapEndian)
525 v = CHANGE_ENDIAN(v);
526
527 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
528
529 accum += sizeof(cmsUInt16Number);
530 }
531
532 if (!ExtraFirst) {
533 accum += Extra * sizeof(cmsUInt16Number);
534 }
535
536 if (Extra == 0 && SwapFirst) {
537
538 cmsUInt16Number tmp = wIn[0];
539
540 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
541 wIn[nChan-1] = tmp;
542 }
543
544 return accum;
545
546 cmsUNUSED_PARAMETER(Stride);
547 }
548
549 static
550 cmsUInt8Number* UnrollPlanarWords(CMSREGISTER _cmsTRANSFORM* info,
551 CMSREGISTER cmsUInt16Number wIn[],
552 CMSREGISTER cmsUInt8Number* accum,
553 CMSREGISTER cmsUInt32Number Stride)
554 {
555 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
556 cmsUInt32Number DoSwap= T_DOSWAP(info ->InputFormat);
557 cmsUInt32Number Reverse= T_FLAVOR(info ->InputFormat);
558 cmsUInt32Number SwapEndian = T_ENDIAN16(info -> InputFormat);
559 cmsUInt32Number i;
560 cmsUInt8Number* Init = accum;
561
562 if (DoSwap) {
563 accum += T_EXTRA(info -> InputFormat) * Stride;
564 }
565
566 for (i=0; i < nChan; i++) {
567
568 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
569 cmsUInt16Number v = *(cmsUInt16Number*) accum;
570
571 if (SwapEndian)
572 v = CHANGE_ENDIAN(v);
573
574 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
575
576 accum += Stride;
577 }
578
579 return (Init + sizeof(cmsUInt16Number));
580 }
581
582
583 static
584 cmsUInt8Number* Unroll4Words(CMSREGISTER _cmsTRANSFORM* info,
585 CMSREGISTER cmsUInt16Number wIn[],
586 CMSREGISTER cmsUInt8Number* accum,
587 CMSREGISTER cmsUInt32Number Stride)
588 {
589 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
590 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
591 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
592 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
593
594 return accum;
595
596 cmsUNUSED_PARAMETER(info);
597 cmsUNUSED_PARAMETER(Stride);
598 }
599
600 static
601 cmsUInt8Number* Unroll4WordsReverse(CMSREGISTER _cmsTRANSFORM* info,
602 CMSREGISTER cmsUInt16Number wIn[],
603 CMSREGISTER cmsUInt8Number* accum,
604 CMSREGISTER cmsUInt32Number Stride)
605 {
606 wIn[0] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // C
607 wIn[1] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // M
608 wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // Y
609 wIn[3] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // K
610
611 return accum;
612
613 cmsUNUSED_PARAMETER(info);
614 cmsUNUSED_PARAMETER(Stride);
615 }
616
617 static
618 cmsUInt8Number* Unroll4WordsSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
619 CMSREGISTER cmsUInt16Number wIn[],
620 CMSREGISTER cmsUInt8Number* accum,
621 CMSREGISTER cmsUInt32Number Stride)
622 {
623 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
624 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
625 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
626 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
627
628 return accum;
629
630 cmsUNUSED_PARAMETER(info);
631 cmsUNUSED_PARAMETER(Stride);
632 }
633
634 // KYMC
635 static
636 cmsUInt8Number* Unroll4WordsSwap(CMSREGISTER _cmsTRANSFORM* info,
637 CMSREGISTER cmsUInt16Number wIn[],
638 CMSREGISTER cmsUInt8Number* accum,
639 CMSREGISTER cmsUInt32Number Stride)
640 {
641 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
642 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
643 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
644 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
645
646 return accum;
647
648 cmsUNUSED_PARAMETER(info);
649 cmsUNUSED_PARAMETER(Stride);
650 }
651
652 static
653 cmsUInt8Number* Unroll4WordsSwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
654 CMSREGISTER cmsUInt16Number wIn[],
655 CMSREGISTER cmsUInt8Number* accum,
656 CMSREGISTER cmsUInt32Number Stride)
657 {
658 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // K
659 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // Y
660 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // M
661 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // C
662
663 return accum;
664
665 cmsUNUSED_PARAMETER(info);
666 cmsUNUSED_PARAMETER(Stride);
667 }
668
669 static
670 cmsUInt8Number* Unroll3Words(CMSREGISTER _cmsTRANSFORM* info,
671 CMSREGISTER cmsUInt16Number wIn[],
672 CMSREGISTER cmsUInt8Number* accum,
673 CMSREGISTER cmsUInt32Number Stride)
674 {
675 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C R
676 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
677 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
678
679 return accum;
680
681 cmsUNUSED_PARAMETER(info);
682 cmsUNUSED_PARAMETER(Stride);
683 }
684
685 static
686 cmsUInt8Number* Unroll3WordsSwap(CMSREGISTER _cmsTRANSFORM* info,
687 CMSREGISTER cmsUInt16Number wIn[],
688 CMSREGISTER cmsUInt8Number* accum,
689 CMSREGISTER cmsUInt32Number Stride)
690 {
691 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // C R
692 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
693 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
694
695 return accum;
696
697 cmsUNUSED_PARAMETER(info);
698 cmsUNUSED_PARAMETER(Stride);
699 }
700
701 static
702 cmsUInt8Number* Unroll3WordsSkip1Swap(CMSREGISTER _cmsTRANSFORM* info,
703 CMSREGISTER cmsUInt16Number wIn[],
704 CMSREGISTER cmsUInt8Number* accum,
705 CMSREGISTER cmsUInt32Number Stride)
706 {
707 accum += 2; // A
708 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // R
709 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G
710 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // B
711
712 return accum;
713
714 cmsUNUSED_PARAMETER(info);
715 cmsUNUSED_PARAMETER(Stride);
716 }
717
718 static
719 cmsUInt8Number* Unroll3WordsSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
720 CMSREGISTER cmsUInt16Number wIn[],
721 CMSREGISTER cmsUInt8Number* accum,
722 CMSREGISTER cmsUInt32Number Stride)
723 {
724 accum += 2; // A
725 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // R
726 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G
727 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // B
728
729 return accum;
730
731 cmsUNUSED_PARAMETER(info);
732 cmsUNUSED_PARAMETER(Stride);
733 }
734
735 static
736 cmsUInt8Number* Unroll1Word(CMSREGISTER _cmsTRANSFORM* info,
737 CMSREGISTER cmsUInt16Number wIn[],
738 CMSREGISTER cmsUInt8Number* accum,
739 CMSREGISTER cmsUInt32Number Stride)
740 {
741 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // L
742
743 return accum;
744
745 cmsUNUSED_PARAMETER(info);
746 cmsUNUSED_PARAMETER(Stride);
747 }
748
749 static
750 cmsUInt8Number* Unroll1WordReversed(CMSREGISTER _cmsTRANSFORM* info,
751 CMSREGISTER cmsUInt16Number wIn[],
752 CMSREGISTER cmsUInt8Number* accum,
753 CMSREGISTER cmsUInt32Number Stride)
754 {
755 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2;
756
757 return accum;
758
759 cmsUNUSED_PARAMETER(info);
760 cmsUNUSED_PARAMETER(Stride);
761 }
762
763 static
764 cmsUInt8Number* Unroll1WordSkip3(CMSREGISTER _cmsTRANSFORM* info,
765 CMSREGISTER cmsUInt16Number wIn[],
766 CMSREGISTER cmsUInt8Number* accum,
767 CMSREGISTER cmsUInt32Number Stride)
768 {
769 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum;
770
771 accum += 8;
772
773 return accum;
774
775 cmsUNUSED_PARAMETER(info);
776 cmsUNUSED_PARAMETER(Stride);
777 }
778
779 static
780 cmsUInt8Number* Unroll2Words(CMSREGISTER _cmsTRANSFORM* info,
781 CMSREGISTER cmsUInt16Number wIn[],
782 CMSREGISTER cmsUInt8Number* accum,
783 CMSREGISTER cmsUInt32Number Stride)
784 {
785 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // ch1
786 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // ch2
787
788 return accum;
789
790 cmsUNUSED_PARAMETER(info);
791 cmsUNUSED_PARAMETER(Stride);
792 }
793
794
795 // This is a conversion of Lab double to 16 bits
796 static
797 cmsUInt8Number* UnrollLabDoubleTo16(CMSREGISTER _cmsTRANSFORM* info,
798 CMSREGISTER cmsUInt16Number wIn[],
799 CMSREGISTER cmsUInt8Number* accum,
800 CMSREGISTER cmsUInt32Number Stride)
801 {
802 if (T_PLANAR(info -> InputFormat)) {
803
804 cmsCIELab Lab;
805 cmsUInt8Number* pos_L;
806 cmsUInt8Number* pos_a;
807 cmsUInt8Number* pos_b;
808
809 pos_L = accum;
810 pos_a = accum + Stride;
811 pos_b = accum + Stride * 2;
812
813 Lab.L = *(cmsFloat64Number*) pos_L;
814 Lab.a = *(cmsFloat64Number*) pos_a;
815 Lab.b = *(cmsFloat64Number*) pos_b;
816
817 cmsFloat2LabEncoded(wIn, &Lab);
818 return accum + sizeof(cmsFloat64Number);
819 }
820 else {
821
822 cmsFloat2LabEncoded(wIn, (cmsCIELab*) accum);
823 accum += sizeof(cmsCIELab) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat64Number);
824 return accum;
825 }
826 }
827
828
829 // This is a conversion of Lab float to 16 bits
830 static
831 cmsUInt8Number* UnrollLabFloatTo16(CMSREGISTER _cmsTRANSFORM* info,
832 CMSREGISTER cmsUInt16Number wIn[],
833 CMSREGISTER cmsUInt8Number* accum,
834 CMSREGISTER cmsUInt32Number Stride)
835 {
836 cmsCIELab Lab;
837
838 if (T_PLANAR(info -> InputFormat)) {
839
840 cmsUInt8Number* pos_L;
841 cmsUInt8Number* pos_a;
842 cmsUInt8Number* pos_b;
843
844 pos_L = accum;
845 pos_a = accum + Stride;
846 pos_b = accum + Stride * 2;
847
848 Lab.L = *(cmsFloat32Number*)pos_L;
849 Lab.a = *(cmsFloat32Number*)pos_a;
850 Lab.b = *(cmsFloat32Number*)pos_b;
851
852 cmsFloat2LabEncoded(wIn, &Lab);
853 return accum + sizeof(cmsFloat32Number);
854 }
855 else {
856
857 Lab.L = ((cmsFloat32Number*) accum)[0];
858 Lab.a = ((cmsFloat32Number*) accum)[1];
859 Lab.b = ((cmsFloat32Number*) accum)[2];
860
861 cmsFloat2LabEncoded(wIn, &Lab);
862 accum += (3 + T_EXTRA(info ->InputFormat)) * sizeof(cmsFloat32Number);
863 return accum;
864 }
865 }
866
867 // This is a conversion of XYZ double to 16 bits
868 static
869 cmsUInt8Number* UnrollXYZDoubleTo16(CMSREGISTER _cmsTRANSFORM* info,
870 CMSREGISTER cmsUInt16Number wIn[],
871 CMSREGISTER cmsUInt8Number* accum,
872 CMSREGISTER cmsUInt32Number Stride)
873 {
874 if (T_PLANAR(info -> InputFormat)) {
875
876 cmsCIEXYZ XYZ;
877 cmsUInt8Number* pos_X;
878 cmsUInt8Number* pos_Y;
879 cmsUInt8Number* pos_Z;
880
881 pos_X = accum;
882 pos_Y = accum + Stride;
883 pos_Z = accum + Stride * 2;
884
885 XYZ.X = *(cmsFloat64Number*)pos_X;
886 XYZ.Y = *(cmsFloat64Number*)pos_Y;
887 XYZ.Z = *(cmsFloat64Number*)pos_Z;
888
889 cmsFloat2XYZEncoded(wIn, &XYZ);
890
891 return accum + sizeof(cmsFloat64Number);
892
893 }
894
895 else {
896 cmsFloat2XYZEncoded(wIn, (cmsCIEXYZ*) accum);
897 accum += sizeof(cmsCIEXYZ) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat64Number);
898
899 return accum;
900 }
901 }
902
903 // This is a conversion of XYZ float to 16 bits
904 static
905 cmsUInt8Number* UnrollXYZFloatTo16(CMSREGISTER _cmsTRANSFORM* info,
906 CMSREGISTER cmsUInt16Number wIn[],
907 CMSREGISTER cmsUInt8Number* accum,
908 CMSREGISTER cmsUInt32Number Stride)
909 {
910 if (T_PLANAR(info -> InputFormat)) {
911
912 cmsCIEXYZ XYZ;
913 cmsUInt8Number* pos_X;
914 cmsUInt8Number* pos_Y;
915 cmsUInt8Number* pos_Z;
916
917 pos_X = accum;
918 pos_Y = accum + Stride;
919 pos_Z = accum + Stride * 2;
920
921 XYZ.X = *(cmsFloat32Number*)pos_X;
922 XYZ.Y = *(cmsFloat32Number*)pos_Y;
923 XYZ.Z = *(cmsFloat32Number*)pos_Z;
924
925 cmsFloat2XYZEncoded(wIn, &XYZ);
926
927 return accum + sizeof(cmsFloat32Number);
928
929 }
930
931 else {
932 cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
933 cmsCIEXYZ XYZ;
934
935 XYZ.X = Pt[0];
936 XYZ.Y = Pt[1];
937 XYZ.Z = Pt[2];
938 cmsFloat2XYZEncoded(wIn, &XYZ);
939
940 accum += 3 * sizeof(cmsFloat32Number) + T_EXTRA(info ->InputFormat) * sizeof(cmsFloat32Number);
941
942 return accum;
943 }
944 }
945
946 // Check if space is marked as ink
947 cmsINLINE cmsBool IsInkSpace(cmsUInt32Number Type)
948 {
949 switch (T_COLORSPACE(Type)) {
950
951 case PT_CMY:
952 case PT_CMYK:
953 case PT_MCH5:
954 case PT_MCH6:
955 case PT_MCH7:
956 case PT_MCH8:
957 case PT_MCH9:
958 case PT_MCH10:
959 case PT_MCH11:
960 case PT_MCH12:
961 case PT_MCH13:
962 case PT_MCH14:
963 case PT_MCH15: return TRUE;
964
965 default: return FALSE;
966 }
967 }
968
969 // Return the size in bytes of a given formatter
970 static
971 cmsUInt32Number PixelSize(cmsUInt32Number Format)
972 {
973 cmsUInt32Number fmt_bytes = T_BYTES(Format);
974
975 // For double, the T_BYTES field is zero
976 if (fmt_bytes == 0)
977 return sizeof(cmsUInt64Number);
978
979 // Otherwise, it is already correct for all formats
980 return fmt_bytes;
981 }
982
983 // Inks does come in percentage, remaining cases are between 0..1.0, again to 16 bits
984 static
985 cmsUInt8Number* UnrollDoubleTo16(CMSREGISTER _cmsTRANSFORM* info,
986 CMSREGISTER cmsUInt16Number wIn[],
987 CMSREGISTER cmsUInt8Number* accum,
988 CMSREGISTER cmsUInt32Number Stride)
989 {
990
991 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
992 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
993 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
994 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
995 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
996 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
997 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
998 cmsFloat64Number v;
999 cmsUInt16Number vi;
1000 cmsUInt32Number i, start = 0;
1001 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
1002
1003
1004 Stride /= PixelSize(info->InputFormat);
1005
1006 if (ExtraFirst)
1007 start = Extra;
1008
1009 for (i=0; i < nChan; i++) {
1010
1011 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1012
1013 if (Planar)
1014 v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[(i + start) * Stride];
1015 else
1016 v = (cmsFloat32Number) ((cmsFloat64Number*) accum)[i + start];
1017
1018 vi = _cmsQuickSaturateWord(v * maximum);
1019
1020 if (Reverse)
1021 vi = REVERSE_FLAVOR_16(vi);
1022
1023 wIn[index] = vi;
1024 }
1025
1026
1027 if (Extra == 0 && SwapFirst) {
1028 cmsUInt16Number tmp = wIn[0];
1029
1030 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
1031 wIn[nChan-1] = tmp;
1032 }
1033
1034 if (T_PLANAR(info -> InputFormat))
1035 return accum + sizeof(cmsFloat64Number);
1036 else
1037 return accum + (nChan + Extra) * sizeof(cmsFloat64Number);
1038 }
1039
1040
1041
1042 static
1043 cmsUInt8Number* UnrollFloatTo16(CMSREGISTER _cmsTRANSFORM* info,
1044 CMSREGISTER cmsUInt16Number wIn[],
1045 CMSREGISTER cmsUInt8Number* accum,
1046 CMSREGISTER cmsUInt32Number Stride)
1047 {
1048
1049 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
1050 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
1051 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
1052 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
1053 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
1054 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
1055 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
1056 cmsFloat32Number v;
1057 cmsUInt16Number vi;
1058 cmsUInt32Number i, start = 0;
1059 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 655.35 : 65535.0;
1060
1061 Stride /= PixelSize(info->InputFormat);
1062
1063 if (ExtraFirst)
1064 start = Extra;
1065
1066 for (i=0; i < nChan; i++) {
1067
1068 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1069
1070 if (Planar)
1071 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride];
1072 else
1073 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start];
1074
1075 vi = _cmsQuickSaturateWord(v * maximum);
1076
1077 if (Reverse)
1078 vi = REVERSE_FLAVOR_16(vi);
1079
1080 wIn[index] = vi;
1081 }
1082
1083
1084 if (Extra == 0 && SwapFirst) {
1085 cmsUInt16Number tmp = wIn[0];
1086
1087 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
1088 wIn[nChan-1] = tmp;
1089 }
1090
1091 if (T_PLANAR(info -> InputFormat))
1092 return accum + sizeof(cmsFloat32Number);
1093 else
1094 return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
1095 }
1096
1097
1098
1099
1100 // For 1 channel, we need to duplicate data (it comes in 0..1.0 range)
1101 static
1102 cmsUInt8Number* UnrollDouble1Chan(CMSREGISTER _cmsTRANSFORM* info,
1103 CMSREGISTER cmsUInt16Number wIn[],
1104 CMSREGISTER cmsUInt8Number* accum,
1105 CMSREGISTER cmsUInt32Number Stride)
1106 {
1107 cmsFloat64Number* Inks = (cmsFloat64Number*) accum;
1108
1109 wIn[0] = wIn[1] = wIn[2] = _cmsQuickSaturateWord(Inks[0] * 65535.0);
1110
1111 return accum + sizeof(cmsFloat64Number);
1112
1113 cmsUNUSED_PARAMETER(info);
1114 cmsUNUSED_PARAMETER(Stride);
1115 }
1116
1117 //-------------------------------------------------------------------------------------------------------------------
1118
1119 // For anything going from cmsFloat32Number
1120 static
1121 cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info,
1122 cmsFloat32Number wIn[],
1123 cmsUInt8Number* accum,
1124 cmsUInt32Number Stride)
1125 {
1126
1127 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
1128 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
1129 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
1130 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
1131 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
1132 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
1133 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
1134 cmsFloat32Number v;
1135 cmsUInt32Number i, start = 0;
1136 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F;
1137
1138 Stride /= PixelSize(info->InputFormat);
1139
1140 if (ExtraFirst)
1141 start = Extra;
1142
1143 for (i=0; i < nChan; i++) {
1144
1145 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1146
1147 if (Planar)
1148 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[(i + start) * Stride];
1149 else
1150 v = (cmsFloat32Number) ((cmsFloat32Number*) accum)[i + start];
1151
1152 v /= maximum;
1153
1154 wIn[index] = Reverse ? 1 - v : v;
1155 }
1156
1157
1158 if (Extra == 0 && SwapFirst) {
1159 cmsFloat32Number tmp = wIn[0];
1160
1161 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
1162 wIn[nChan-1] = tmp;
1163 }
1164
1165 if (T_PLANAR(info -> InputFormat))
1166 return accum + sizeof(cmsFloat32Number);
1167 else
1168 return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
1169 }
1170
1171 // For anything going from double
1172
1173 static
1174 cmsUInt8Number* UnrollDoublesToFloat(_cmsTRANSFORM* info,
1175 cmsFloat32Number wIn[],
1176 cmsUInt8Number* accum,
1177 cmsUInt32Number Stride)
1178 {
1179
1180 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
1181 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
1182 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
1183 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
1184 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
1185 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
1186 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
1187 cmsFloat64Number v;
1188 cmsUInt32Number i, start = 0;
1189 cmsFloat64Number maximum = IsInkSpace(info ->InputFormat) ? 100.0 : 1.0;
1190
1191 Stride /= PixelSize(info->InputFormat);
1192
1193 if (ExtraFirst)
1194 start = Extra;
1195
1196 for (i=0; i < nChan; i++) {
1197
1198 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1199
1200 if (Planar)
1201 v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[(i + start) * Stride];
1202 else
1203 v = (cmsFloat64Number) ((cmsFloat64Number*) accum)[i + start];
1204
1205 v /= maximum;
1206
1207 wIn[index] = (cmsFloat32Number) (Reverse ? 1.0 - v : v);
1208 }
1209
1210
1211 if (Extra == 0 && SwapFirst) {
1212 cmsFloat32Number tmp = wIn[0];
1213
1214 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
1215 wIn[nChan-1] = tmp;
1216 }
1217
1218 if (T_PLANAR(info -> InputFormat))
1219 return accum + sizeof(cmsFloat64Number);
1220 else
1221 return accum + (nChan + Extra) * sizeof(cmsFloat64Number);
1222 }
1223
1224
1225
1226 // From Lab double to cmsFloat32Number
1227 static
1228 cmsUInt8Number* UnrollLabDoubleToFloat(_cmsTRANSFORM* info,
1229 cmsFloat32Number wIn[],
1230 cmsUInt8Number* accum,
1231 cmsUInt32Number Stride)
1232 {
1233 cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
1234
1235 if (T_PLANAR(info -> InputFormat)) {
1236
1237 Stride /= PixelSize(info->InputFormat);
1238
1239 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
1240 wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1
1241 wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0);
1242
1243 return accum + sizeof(cmsFloat64Number);
1244 }
1245 else {
1246
1247 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
1248 wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1
1249 wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0);
1250
1251 accum += sizeof(cmsFloat64Number)*(3 + T_EXTRA(info ->InputFormat));
1252 return accum;
1253 }
1254 }
1255
1256 // From Lab double to cmsFloat32Number
1257 static
1258 cmsUInt8Number* UnrollLabFloatToFloat(_cmsTRANSFORM* info,
1259 cmsFloat32Number wIn[],
1260 cmsUInt8Number* accum,
1261 cmsUInt32Number Stride)
1262 {
1263 cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
1264
1265 if (T_PLANAR(info -> InputFormat)) {
1266
1267 Stride /= PixelSize(info->InputFormat);
1268
1269 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
1270 wIn[1] = (cmsFloat32Number) ((Pt[Stride] + 128) / 255.0); // form -128..+127 to 0..1
1271 wIn[2] = (cmsFloat32Number) ((Pt[Stride*2] + 128) / 255.0);
1272
1273 return accum + sizeof(cmsFloat32Number);
1274 }
1275 else {
1276
1277 wIn[0] = (cmsFloat32Number) (Pt[0] / 100.0); // from 0..100 to 0..1
1278 wIn[1] = (cmsFloat32Number) ((Pt[1] + 128) / 255.0); // form -128..+127 to 0..1
1279 wIn[2] = (cmsFloat32Number) ((Pt[2] + 128) / 255.0);
1280
1281 accum += sizeof(cmsFloat32Number)*(3 + T_EXTRA(info ->InputFormat));
1282 return accum;
1283 }
1284 }
1285
1286
1287
1288 // 1.15 fixed point, that means maximum value is MAX_ENCODEABLE_XYZ (0xFFFF)
1289 static
1290 cmsUInt8Number* UnrollXYZDoubleToFloat(_cmsTRANSFORM* info,
1291 cmsFloat32Number wIn[],
1292 cmsUInt8Number* accum,
1293 cmsUInt32Number Stride)
1294 {
1295 cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
1296
1297 if (T_PLANAR(info -> InputFormat)) {
1298
1299 Stride /= PixelSize(info->InputFormat);
1300
1301 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
1302 wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
1303 wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ);
1304
1305 return accum + sizeof(cmsFloat64Number);
1306 }
1307 else {
1308
1309 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
1310 wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
1311 wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ);
1312
1313 accum += sizeof(cmsFloat64Number)*(3 + T_EXTRA(info ->InputFormat));
1314 return accum;
1315 }
1316 }
1317
1318 static
1319 cmsUInt8Number* UnrollXYZFloatToFloat(_cmsTRANSFORM* info,
1320 cmsFloat32Number wIn[],
1321 cmsUInt8Number* accum,
1322 cmsUInt32Number Stride)
1323 {
1324 cmsFloat32Number* Pt = (cmsFloat32Number*) accum;
1325
1326 if (T_PLANAR(info -> InputFormat)) {
1327
1328 Stride /= PixelSize(info->InputFormat);
1329
1330 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
1331 wIn[1] = (cmsFloat32Number) (Pt[Stride] / MAX_ENCODEABLE_XYZ);
1332 wIn[2] = (cmsFloat32Number) (Pt[Stride*2] / MAX_ENCODEABLE_XYZ);
1333
1334 return accum + sizeof(cmsFloat32Number);
1335 }
1336 else {
1337
1338 wIn[0] = (cmsFloat32Number) (Pt[0] / MAX_ENCODEABLE_XYZ);
1339 wIn[1] = (cmsFloat32Number) (Pt[1] / MAX_ENCODEABLE_XYZ);
1340 wIn[2] = (cmsFloat32Number) (Pt[2] / MAX_ENCODEABLE_XYZ);
1341
1342 accum += sizeof(cmsFloat32Number)*(3 + T_EXTRA(info ->InputFormat));
1343 return accum;
1344 }
1345 }
1346
1347
1348
1349 // Packing routines -----------------------------------------------------------------------------------------------------------
1350
1351
1352 // Generic chunky for byte
1353
1354 static
1355 cmsUInt8Number* PackAnyBytes(CMSREGISTER _cmsTRANSFORM* info,
1356 CMSREGISTER cmsUInt16Number wOut[],
1357 CMSREGISTER cmsUInt8Number* output,
1358 CMSREGISTER cmsUInt32Number Stride)
1359 {
1360 cmsUInt32Number nChan = T_CHANNELS(info -> OutputFormat);
1361 cmsUInt32Number DoSwap = T_DOSWAP(info ->OutputFormat);
1362 cmsUInt32Number Reverse = T_FLAVOR(info ->OutputFormat);
1363 cmsUInt32Number Extra = T_EXTRA(info -> OutputFormat);
1364 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> OutputFormat);
1365 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
1366 cmsUInt8Number* swap1;
1367 cmsUInt8Number v = 0;
1368 cmsUInt32Number i;
1369
1370 swap1 = output;
1371
1372 if (ExtraFirst) {
1373 output += Extra;
1374 }
1375
1376 for (i=0; i < nChan; i++) {
1377
1378 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1379
1380 v = FROM_16_TO_8(wOut[index]);
1381
1382 if (Reverse)
1383 v = REVERSE_FLAVOR_8(v);
1384
1385 *output++ = v;
1386 }
1387
1388 if (!ExtraFirst) {
1389 output += Extra;
1390 }
1391
1392 if (Extra == 0 && SwapFirst) {
1393
1394 memmove(swap1 + 1, swap1, nChan-1);
1395 *swap1 = v;
1396 }
1397
1398
1399 return output;
1400
1401 cmsUNUSED_PARAMETER(Stride);
1402 }
1403
1404
1405
1406 static
1407 cmsUInt8Number* PackAnyWords(CMSREGISTER _cmsTRANSFORM* info,
1408 CMSREGISTER cmsUInt16Number wOut[],
1409 CMSREGISTER cmsUInt8Number* output,
1410 CMSREGISTER cmsUInt32Number Stride)
1411 {
1412 cmsUInt32Number nChan = T_CHANNELS(info -> OutputFormat);
1413 cmsUInt32Number SwapEndian = T_ENDIAN16(info -> OutputFormat);
1414 cmsUInt32Number DoSwap = T_DOSWAP(info ->OutputFormat);
1415 cmsUInt32Number Reverse = T_FLAVOR(info ->OutputFormat);
1416 cmsUInt32Number Extra = T_EXTRA(info -> OutputFormat);
1417 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> OutputFormat);
1418 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
1419 cmsUInt16Number* swap1;
1420 cmsUInt16Number v = 0;
1421 cmsUInt32Number i;
1422
1423 swap1 = (cmsUInt16Number*) output;
1424
1425 if (ExtraFirst) {
1426 output += Extra * sizeof(cmsUInt16Number);
1427 }
1428
1429 for (i=0; i < nChan; i++) {
1430
1431 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1432
1433 v = wOut[index];
1434
1435 if (SwapEndian)
1436 v = CHANGE_ENDIAN(v);
1437
1438 if (Reverse)
1439 v = REVERSE_FLAVOR_16(v);
1440
1441 *(cmsUInt16Number*) output = v;
1442
1443 output += sizeof(cmsUInt16Number);
1444 }
1445
1446 if (!ExtraFirst) {
1447 output += Extra * sizeof(cmsUInt16Number);
1448 }
1449
1450 if (Extra == 0 && SwapFirst) {
1451
1452 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number));
1453 *swap1 = v;
1454 }
1455
1456
1457 return output;
1458
1459 cmsUNUSED_PARAMETER(Stride);
1460 }
1461
1462
1463 static
1464 cmsUInt8Number* PackPlanarBytes(CMSREGISTER _cmsTRANSFORM* info,
1465 CMSREGISTER cmsUInt16Number wOut[],
1466 CMSREGISTER cmsUInt8Number* output,
1467 CMSREGISTER cmsUInt32Number Stride)
1468 {
1469 cmsUInt32Number nChan = T_CHANNELS(info -> OutputFormat);
1470 cmsUInt32Number DoSwap = T_DOSWAP(info ->OutputFormat);
1471 cmsUInt32Number SwapFirst = T_SWAPFIRST(info ->OutputFormat);
1472 cmsUInt32Number Reverse = T_FLAVOR(info ->OutputFormat);
1473 cmsUInt32Number i;
1474 cmsUInt8Number* Init = output;
1475
1476
1477 if (DoSwap ^ SwapFirst) {
1478 output += T_EXTRA(info -> OutputFormat) * Stride;
1479 }
1480
1481
1482 for (i=0; i < nChan; i++) {
1483
1484 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1485 cmsUInt8Number v = FROM_16_TO_8(wOut[index]);
1486
1487 *(cmsUInt8Number*) output = (cmsUInt8Number) (Reverse ? REVERSE_FLAVOR_8(v) : v);
1488 output += Stride;
1489 }
1490
1491 return (Init + 1);
1492
1493 cmsUNUSED_PARAMETER(Stride);
1494 }
1495
1496
1497 static
1498 cmsUInt8Number* PackPlanarWords(CMSREGISTER _cmsTRANSFORM* info,
1499 CMSREGISTER cmsUInt16Number wOut[],
1500 CMSREGISTER cmsUInt8Number* output,
1501 CMSREGISTER cmsUInt32Number Stride)
1502 {
1503 cmsUInt32Number nChan = T_CHANNELS(info -> OutputFormat);
1504 cmsUInt32Number DoSwap = T_DOSWAP(info ->OutputFormat);
1505 cmsUInt32Number Reverse = T_FLAVOR(info ->OutputFormat);
1506 cmsUInt32Number SwapEndian = T_ENDIAN16(info -> OutputFormat);
1507 cmsUInt32Number i;
1508 cmsUInt8Number* Init = output;
1509 cmsUInt16Number v;
1510
1511 if (DoSwap) {
1512 output += T_EXTRA(info -> OutputFormat) * Stride;
1513 }
1514
1515 for (i=0; i < nChan; i++) {
1516
1517 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
1518
1519 v = wOut[index];
1520
1521 if (SwapEndian)
1522 v = CHANGE_ENDIAN(v);
1523
1524 if (Reverse)
1525 v = REVERSE_FLAVOR_16(v);
1526
1527 *(cmsUInt16Number*) output = v;
1528 output += Stride;
1529 }
1530
1531 return (Init + sizeof(cmsUInt16Number));
1532 }
1533
1534 // CMYKcm (unrolled for speed)
1535
1536 static
1537 cmsUInt8Number* Pack6Bytes(CMSREGISTER _cmsTRANSFORM* info,
1538 CMSREGISTER cmsUInt16Number wOut[],
1539 CMSREGISTER cmsUInt8Number* output,
1540 CMSREGISTER cmsUInt32Number Stride)
1541 {
1542 *output++ = FROM_16_TO_8(wOut[0]);
1543 *output++ = FROM_16_TO_8(wOut[1]);
1544 *output++ = FROM_16_TO_8(wOut[2]);
1545 *output++ = FROM_16_TO_8(wOut[3]);
1546 *output++ = FROM_16_TO_8(wOut[4]);
1547 *output++ = FROM_16_TO_8(wOut[5]);
1548
1549 return output;
1550
1551 cmsUNUSED_PARAMETER(info);
1552 cmsUNUSED_PARAMETER(Stride);
1553 }
1554
1555 // KCMYcm
1556
1557 static
1558 cmsUInt8Number* Pack6BytesSwap(CMSREGISTER _cmsTRANSFORM* info,
1559 CMSREGISTER cmsUInt16Number wOut[],
1560 CMSREGISTER cmsUInt8Number* output,
1561 CMSREGISTER cmsUInt32Number Stride)
1562 {
1563 *output++ = FROM_16_TO_8(wOut[5]);
1564 *output++ = FROM_16_TO_8(wOut[4]);
1565 *output++ = FROM_16_TO_8(wOut[3]);
1566 *output++ = FROM_16_TO_8(wOut[2]);
1567 *output++ = FROM_16_TO_8(wOut[1]);
1568 *output++ = FROM_16_TO_8(wOut[0]);
1569
1570 return output;
1571
1572 cmsUNUSED_PARAMETER(info);
1573 cmsUNUSED_PARAMETER(Stride);
1574 }
1575
1576 // CMYKcm
1577 static
1578 cmsUInt8Number* Pack6Words(CMSREGISTER _cmsTRANSFORM* info,
1579 CMSREGISTER cmsUInt16Number wOut[],
1580 CMSREGISTER cmsUInt8Number* output,
1581 CMSREGISTER cmsUInt32Number Stride)
1582 {
1583 *(cmsUInt16Number*) output = wOut[0];
1584 output+= 2;
1585 *(cmsUInt16Number*) output = wOut[1];
1586 output+= 2;
1587 *(cmsUInt16Number*) output = wOut[2];
1588 output+= 2;
1589 *(cmsUInt16Number*) output = wOut[3];
1590 output+= 2;
1591 *(cmsUInt16Number*) output = wOut[4];
1592 output+= 2;
1593 *(cmsUInt16Number*) output = wOut[5];
1594 output+= 2;
1595
1596 return output;
1597
1598 cmsUNUSED_PARAMETER(info);
1599 cmsUNUSED_PARAMETER(Stride);
1600 }
1601
1602 // KCMYcm
1603 static
1604 cmsUInt8Number* Pack6WordsSwap(CMSREGISTER _cmsTRANSFORM* info,
1605 CMSREGISTER cmsUInt16Number wOut[],
1606 CMSREGISTER cmsUInt8Number* output,
1607 CMSREGISTER cmsUInt32Number Stride)
1608 {
1609 *(cmsUInt16Number*) output = wOut[5];
1610 output+= 2;
1611 *(cmsUInt16Number*) output = wOut[4];
1612 output+= 2;
1613 *(cmsUInt16Number*) output = wOut[3];
1614 output+= 2;
1615 *(cmsUInt16Number*) output = wOut[2];
1616 output+= 2;
1617 *(cmsUInt16Number*) output = wOut[1];
1618 output+= 2;
1619 *(cmsUInt16Number*) output = wOut[0];
1620 output+= 2;
1621
1622 return output;
1623
1624 cmsUNUSED_PARAMETER(info);
1625 cmsUNUSED_PARAMETER(Stride);
1626 }
1627
1628
1629 static
1630 cmsUInt8Number* Pack4Bytes(CMSREGISTER _cmsTRANSFORM* info,
1631 CMSREGISTER cmsUInt16Number wOut[],
1632 CMSREGISTER cmsUInt8Number* output,
1633 CMSREGISTER cmsUInt32Number Stride)
1634 {
1635 *output++ = FROM_16_TO_8(wOut[0]);
1636 *output++ = FROM_16_TO_8(wOut[1]);
1637 *output++ = FROM_16_TO_8(wOut[2]);
1638 *output++ = FROM_16_TO_8(wOut[3]);
1639
1640 return output;
1641
1642 cmsUNUSED_PARAMETER(info);
1643 cmsUNUSED_PARAMETER(Stride);
1644 }
1645
1646 static
1647 cmsUInt8Number* Pack4BytesReverse(CMSREGISTER _cmsTRANSFORM* info,
1648 CMSREGISTER cmsUInt16Number wOut[],
1649 CMSREGISTER cmsUInt8Number* output,
1650 CMSREGISTER cmsUInt32Number Stride)
1651 {
1652 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[0]));
1653 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[1]));
1654 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[2]));
1655 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[3]));
1656
1657 return output;
1658
1659 cmsUNUSED_PARAMETER(info);
1660 cmsUNUSED_PARAMETER(Stride);
1661 }
1662
1663
1664 static
1665 cmsUInt8Number* Pack4BytesSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
1666 CMSREGISTER cmsUInt16Number wOut[],
1667 CMSREGISTER cmsUInt8Number* output,
1668 CMSREGISTER cmsUInt32Number Stride)
1669 {
1670 *output++ = FROM_16_TO_8(wOut[3]);
1671 *output++ = FROM_16_TO_8(wOut[0]);
1672 *output++ = FROM_16_TO_8(wOut[1]);
1673 *output++ = FROM_16_TO_8(wOut[2]);
1674
1675 return output;
1676
1677 cmsUNUSED_PARAMETER(info);
1678 cmsUNUSED_PARAMETER(Stride);
1679 }
1680
1681 // ABGR
1682 static
1683 cmsUInt8Number* Pack4BytesSwap(CMSREGISTER _cmsTRANSFORM* info,
1684 CMSREGISTER cmsUInt16Number wOut[],
1685 CMSREGISTER cmsUInt8Number* output,
1686 CMSREGISTER cmsUInt32Number Stride)
1687 {
1688 *output++ = FROM_16_TO_8(wOut[3]);
1689 *output++ = FROM_16_TO_8(wOut[2]);
1690 *output++ = FROM_16_TO_8(wOut[1]);
1691 *output++ = FROM_16_TO_8(wOut[0]);
1692
1693 return output;
1694
1695 cmsUNUSED_PARAMETER(info);
1696 cmsUNUSED_PARAMETER(Stride);
1697 }
1698
1699 static
1700 cmsUInt8Number* Pack4BytesSwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
1701 CMSREGISTER cmsUInt16Number wOut[],
1702 CMSREGISTER cmsUInt8Number* output,
1703 CMSREGISTER cmsUInt32Number Stride)
1704 {
1705 *output++ = FROM_16_TO_8(wOut[2]);
1706 *output++ = FROM_16_TO_8(wOut[1]);
1707 *output++ = FROM_16_TO_8(wOut[0]);
1708 *output++ = FROM_16_TO_8(wOut[3]);
1709
1710 return output;
1711
1712 cmsUNUSED_PARAMETER(info);
1713 cmsUNUSED_PARAMETER(Stride);
1714 }
1715
1716 static
1717 cmsUInt8Number* Pack4Words(CMSREGISTER _cmsTRANSFORM* info,
1718 CMSREGISTER cmsUInt16Number wOut[],
1719 CMSREGISTER cmsUInt8Number* output,
1720 CMSREGISTER cmsUInt32Number Stride)
1721 {
1722 *(cmsUInt16Number*) output = wOut[0];
1723 output+= 2;
1724 *(cmsUInt16Number*) output = wOut[1];
1725 output+= 2;
1726 *(cmsUInt16Number*) output = wOut[2];
1727 output+= 2;
1728 *(cmsUInt16Number*) output = wOut[3];
1729 output+= 2;
1730
1731 return output;
1732
1733 cmsUNUSED_PARAMETER(info);
1734 cmsUNUSED_PARAMETER(Stride);
1735 }
1736
1737 static
1738 cmsUInt8Number* Pack4WordsReverse(CMSREGISTER _cmsTRANSFORM* info,
1739 CMSREGISTER cmsUInt16Number wOut[],
1740 CMSREGISTER cmsUInt8Number* output,
1741 CMSREGISTER cmsUInt32Number Stride)
1742 {
1743 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
1744 output+= 2;
1745 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[1]);
1746 output+= 2;
1747 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[2]);
1748 output+= 2;
1749 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[3]);
1750 output+= 2;
1751
1752 return output;
1753
1754 cmsUNUSED_PARAMETER(info);
1755 cmsUNUSED_PARAMETER(Stride);
1756 }
1757
1758 // ABGR
1759 static
1760 cmsUInt8Number* Pack4WordsSwap(CMSREGISTER _cmsTRANSFORM* info,
1761 CMSREGISTER cmsUInt16Number wOut[],
1762 CMSREGISTER cmsUInt8Number* output,
1763 CMSREGISTER cmsUInt32Number Stride)
1764 {
1765 *(cmsUInt16Number*) output = wOut[3];
1766 output+= 2;
1767 *(cmsUInt16Number*) output = wOut[2];
1768 output+= 2;
1769 *(cmsUInt16Number*) output = wOut[1];
1770 output+= 2;
1771 *(cmsUInt16Number*) output = wOut[0];
1772 output+= 2;
1773
1774 return output;
1775
1776 cmsUNUSED_PARAMETER(info);
1777 cmsUNUSED_PARAMETER(Stride);
1778 }
1779
1780 // CMYK
1781 static
1782 cmsUInt8Number* Pack4WordsBigEndian(CMSREGISTER _cmsTRANSFORM* info,
1783 CMSREGISTER cmsUInt16Number wOut[],
1784 CMSREGISTER cmsUInt8Number* output,
1785 CMSREGISTER cmsUInt32Number Stride)
1786 {
1787 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1788 output+= 2;
1789 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1790 output+= 2;
1791 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1792 output+= 2;
1793 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[3]);
1794 output+= 2;
1795
1796 return output;
1797
1798 cmsUNUSED_PARAMETER(info);
1799 cmsUNUSED_PARAMETER(Stride);
1800 }
1801
1802
1803 static
1804 cmsUInt8Number* PackLabV2_8(CMSREGISTER _cmsTRANSFORM* info,
1805 CMSREGISTER cmsUInt16Number wOut[],
1806 CMSREGISTER cmsUInt8Number* output,
1807 CMSREGISTER cmsUInt32Number Stride)
1808 {
1809 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1810 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1811 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1812
1813 return output;
1814
1815 cmsUNUSED_PARAMETER(info);
1816 cmsUNUSED_PARAMETER(Stride);
1817 }
1818
1819 static
1820 cmsUInt8Number* PackALabV2_8(CMSREGISTER _cmsTRANSFORM* info,
1821 CMSREGISTER cmsUInt16Number wOut[],
1822 CMSREGISTER cmsUInt8Number* output,
1823 CMSREGISTER cmsUInt32Number Stride)
1824 {
1825 output++;
1826 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1827 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1828 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1829
1830 return output;
1831
1832 cmsUNUSED_PARAMETER(info);
1833 cmsUNUSED_PARAMETER(Stride);
1834 }
1835
1836 static
1837 cmsUInt8Number* PackLabV2_16(CMSREGISTER _cmsTRANSFORM* info,
1838 CMSREGISTER cmsUInt16Number wOut[],
1839 CMSREGISTER cmsUInt8Number* output,
1840 CMSREGISTER cmsUInt32Number Stride)
1841 {
1842 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[0]);
1843 output += 2;
1844 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[1]);
1845 output += 2;
1846 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[2]);
1847 output += 2;
1848
1849 return output;
1850
1851 cmsUNUSED_PARAMETER(info);
1852 cmsUNUSED_PARAMETER(Stride);
1853 }
1854
1855 static
1856 cmsUInt8Number* Pack3Bytes(CMSREGISTER _cmsTRANSFORM* info,
1857 CMSREGISTER cmsUInt16Number wOut[],
1858 CMSREGISTER cmsUInt8Number* output,
1859 CMSREGISTER cmsUInt32Number Stride)
1860 {
1861 *output++ = FROM_16_TO_8(wOut[0]);
1862 *output++ = FROM_16_TO_8(wOut[1]);
1863 *output++ = FROM_16_TO_8(wOut[2]);
1864
1865 return output;
1866
1867 cmsUNUSED_PARAMETER(info);
1868 cmsUNUSED_PARAMETER(Stride);
1869 }
1870
1871 static
1872 cmsUInt8Number* Pack3BytesOptimized(CMSREGISTER _cmsTRANSFORM* info,
1873 CMSREGISTER cmsUInt16Number wOut[],
1874 CMSREGISTER cmsUInt8Number* output,
1875 CMSREGISTER cmsUInt32Number Stride)
1876 {
1877 *output++ = (wOut[0] & 0xFFU);
1878 *output++ = (wOut[1] & 0xFFU);
1879 *output++ = (wOut[2] & 0xFFU);
1880
1881 return output;
1882
1883 cmsUNUSED_PARAMETER(info);
1884 cmsUNUSED_PARAMETER(Stride);
1885 }
1886
1887 static
1888 cmsUInt8Number* Pack3BytesSwap(CMSREGISTER _cmsTRANSFORM* info,
1889 CMSREGISTER cmsUInt16Number wOut[],
1890 CMSREGISTER cmsUInt8Number* output,
1891 CMSREGISTER cmsUInt32Number Stride)
1892 {
1893 *output++ = FROM_16_TO_8(wOut[2]);
1894 *output++ = FROM_16_TO_8(wOut[1]);
1895 *output++ = FROM_16_TO_8(wOut[0]);
1896
1897 return output;
1898
1899 cmsUNUSED_PARAMETER(info);
1900 cmsUNUSED_PARAMETER(Stride);
1901 }
1902
1903 static
1904 cmsUInt8Number* Pack3BytesSwapOptimized(CMSREGISTER _cmsTRANSFORM* info,
1905 CMSREGISTER cmsUInt16Number wOut[],
1906 CMSREGISTER cmsUInt8Number* output,
1907 CMSREGISTER cmsUInt32Number Stride)
1908 {
1909 *output++ = (wOut[2] & 0xFFU);
1910 *output++ = (wOut[1] & 0xFFU);
1911 *output++ = (wOut[0] & 0xFFU);
1912
1913 return output;
1914
1915 cmsUNUSED_PARAMETER(info);
1916 cmsUNUSED_PARAMETER(Stride);
1917 }
1918
1919
1920 static
1921 cmsUInt8Number* Pack3Words(CMSREGISTER _cmsTRANSFORM* info,
1922 CMSREGISTER cmsUInt16Number wOut[],
1923 CMSREGISTER cmsUInt8Number* output,
1924 CMSREGISTER cmsUInt32Number Stride)
1925 {
1926 *(cmsUInt16Number*) output = wOut[0];
1927 output+= 2;
1928 *(cmsUInt16Number*) output = wOut[1];
1929 output+= 2;
1930 *(cmsUInt16Number*) output = wOut[2];
1931 output+= 2;
1932
1933 return output;
1934
1935 cmsUNUSED_PARAMETER(info);
1936 cmsUNUSED_PARAMETER(Stride);
1937 }
1938
1939 static
1940 cmsUInt8Number* Pack3WordsSwap(CMSREGISTER _cmsTRANSFORM* info,
1941 CMSREGISTER cmsUInt16Number wOut[],
1942 CMSREGISTER cmsUInt8Number* output,
1943 CMSREGISTER cmsUInt32Number Stride)
1944 {
1945 *(cmsUInt16Number*) output = wOut[2];
1946 output+= 2;
1947 *(cmsUInt16Number*) output = wOut[1];
1948 output+= 2;
1949 *(cmsUInt16Number*) output = wOut[0];
1950 output+= 2;
1951
1952 return output;
1953
1954 cmsUNUSED_PARAMETER(info);
1955 cmsUNUSED_PARAMETER(Stride);
1956 }
1957
1958 static
1959 cmsUInt8Number* Pack3WordsBigEndian(CMSREGISTER _cmsTRANSFORM* info,
1960 CMSREGISTER cmsUInt16Number wOut[],
1961 CMSREGISTER cmsUInt8Number* output,
1962 CMSREGISTER cmsUInt32Number Stride)
1963 {
1964 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1965 output+= 2;
1966 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1967 output+= 2;
1968 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1969 output+= 2;
1970
1971 return output;
1972
1973 cmsUNUSED_PARAMETER(info);
1974 cmsUNUSED_PARAMETER(Stride);
1975 }
1976
1977 static
1978 cmsUInt8Number* Pack3BytesAndSkip1(CMSREGISTER _cmsTRANSFORM* info,
1979 CMSREGISTER cmsUInt16Number wOut[],
1980 CMSREGISTER cmsUInt8Number* output,
1981 CMSREGISTER cmsUInt32Number Stride)
1982 {
1983 *output++ = FROM_16_TO_8(wOut[0]);
1984 *output++ = FROM_16_TO_8(wOut[1]);
1985 *output++ = FROM_16_TO_8(wOut[2]);
1986 output++;
1987
1988 return output;
1989
1990 cmsUNUSED_PARAMETER(info);
1991 cmsUNUSED_PARAMETER(Stride);
1992 }
1993
1994 static
1995 cmsUInt8Number* Pack3BytesAndSkip1Optimized(CMSREGISTER _cmsTRANSFORM* info,
1996 CMSREGISTER cmsUInt16Number wOut[],
1997 CMSREGISTER cmsUInt8Number* output,
1998 CMSREGISTER cmsUInt32Number Stride)
1999 {
2000 *output++ = (wOut[0] & 0xFFU);
2001 *output++ = (wOut[1] & 0xFFU);
2002 *output++ = (wOut[2] & 0xFFU);
2003 output++;
2004
2005 return output;
2006
2007 cmsUNUSED_PARAMETER(info);
2008 cmsUNUSED_PARAMETER(Stride);
2009 }
2010
2011
2012 static
2013 cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2014 CMSREGISTER cmsUInt16Number wOut[],
2015 CMSREGISTER cmsUInt8Number* output,
2016 CMSREGISTER cmsUInt32Number Stride)
2017 {
2018 output++;
2019 *output++ = FROM_16_TO_8(wOut[0]);
2020 *output++ = FROM_16_TO_8(wOut[1]);
2021 *output++ = FROM_16_TO_8(wOut[2]);
2022
2023 return output;
2024
2025 cmsUNUSED_PARAMETER(info);
2026 cmsUNUSED_PARAMETER(Stride);
2027 }
2028
2029 static
2030 cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(CMSREGISTER _cmsTRANSFORM* info,
2031 CMSREGISTER cmsUInt16Number wOut[],
2032 CMSREGISTER cmsUInt8Number* output,
2033 CMSREGISTER cmsUInt32Number Stride)
2034 {
2035 output++;
2036 *output++ = (wOut[0] & 0xFFU);
2037 *output++ = (wOut[1] & 0xFFU);
2038 *output++ = (wOut[2] & 0xFFU);
2039
2040 return output;
2041
2042 cmsUNUSED_PARAMETER(info);
2043 cmsUNUSED_PARAMETER(Stride);
2044 }
2045
2046 static
2047 cmsUInt8Number* Pack3BytesAndSkip1Swap(CMSREGISTER _cmsTRANSFORM* info,
2048 CMSREGISTER cmsUInt16Number wOut[],
2049 CMSREGISTER cmsUInt8Number* output,
2050 CMSREGISTER cmsUInt32Number Stride)
2051 {
2052 output++;
2053 *output++ = FROM_16_TO_8(wOut[2]);
2054 *output++ = FROM_16_TO_8(wOut[1]);
2055 *output++ = FROM_16_TO_8(wOut[0]);
2056
2057 return output;
2058
2059 cmsUNUSED_PARAMETER(info);
2060 cmsUNUSED_PARAMETER(Stride);
2061 }
2062
2063 static
2064 cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(CMSREGISTER _cmsTRANSFORM* info,
2065 CMSREGISTER cmsUInt16Number wOut[],
2066 CMSREGISTER cmsUInt8Number* output,
2067 CMSREGISTER cmsUInt32Number Stride)
2068 {
2069 output++;
2070 *output++ = (wOut[2] & 0xFFU);
2071 *output++ = (wOut[1] & 0xFFU);
2072 *output++ = (wOut[0] & 0xFFU);
2073
2074 return output;
2075
2076 cmsUNUSED_PARAMETER(info);
2077 cmsUNUSED_PARAMETER(Stride);
2078 }
2079
2080
2081 static
2082 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2083 CMSREGISTER cmsUInt16Number wOut[],
2084 CMSREGISTER cmsUInt8Number* output,
2085 CMSREGISTER cmsUInt32Number Stride)
2086 {
2087 *output++ = FROM_16_TO_8(wOut[2]);
2088 *output++ = FROM_16_TO_8(wOut[1]);
2089 *output++ = FROM_16_TO_8(wOut[0]);
2090 output++;
2091
2092 return output;
2093
2094 cmsUNUSED_PARAMETER(info);
2095 cmsUNUSED_PARAMETER(Stride);
2096 }
2097
2098 static
2099 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(CMSREGISTER _cmsTRANSFORM* info,
2100 CMSREGISTER cmsUInt16Number wOut[],
2101 CMSREGISTER cmsUInt8Number* output,
2102 CMSREGISTER cmsUInt32Number Stride)
2103 {
2104 *output++ = (wOut[2] & 0xFFU);
2105 *output++ = (wOut[1] & 0xFFU);
2106 *output++ = (wOut[0] & 0xFFU);
2107 output++;
2108
2109 return output;
2110
2111 cmsUNUSED_PARAMETER(info);
2112 cmsUNUSED_PARAMETER(Stride);
2113 }
2114
2115 static
2116 cmsUInt8Number* Pack3WordsAndSkip1(CMSREGISTER _cmsTRANSFORM* info,
2117 CMSREGISTER cmsUInt16Number wOut[],
2118 CMSREGISTER cmsUInt8Number* output,
2119 CMSREGISTER cmsUInt32Number Stride)
2120 {
2121 *(cmsUInt16Number*) output = wOut[0];
2122 output+= 2;
2123 *(cmsUInt16Number*) output = wOut[1];
2124 output+= 2;
2125 *(cmsUInt16Number*) output = wOut[2];
2126 output+= 2;
2127 output+= 2;
2128
2129 return output;
2130
2131 cmsUNUSED_PARAMETER(info);
2132 cmsUNUSED_PARAMETER(Stride);
2133 }
2134
2135 static
2136 cmsUInt8Number* Pack3WordsAndSkip1Swap(CMSREGISTER _cmsTRANSFORM* info,
2137 CMSREGISTER cmsUInt16Number wOut[],
2138 CMSREGISTER cmsUInt8Number* output,
2139 CMSREGISTER cmsUInt32Number Stride)
2140 {
2141 output+= 2;
2142 *(cmsUInt16Number*) output = wOut[2];
2143 output+= 2;
2144 *(cmsUInt16Number*) output = wOut[1];
2145 output+= 2;
2146 *(cmsUInt16Number*) output = wOut[0];
2147 output+= 2;
2148
2149 return output;
2150
2151 cmsUNUSED_PARAMETER(info);
2152 cmsUNUSED_PARAMETER(Stride);
2153 }
2154
2155
2156 static
2157 cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2158 CMSREGISTER cmsUInt16Number wOut[],
2159 CMSREGISTER cmsUInt8Number* output,
2160 CMSREGISTER cmsUInt32Number Stride)
2161 {
2162 output+= 2;
2163 *(cmsUInt16Number*) output = wOut[0];
2164 output+= 2;
2165 *(cmsUInt16Number*) output = wOut[1];
2166 output+= 2;
2167 *(cmsUInt16Number*) output = wOut[2];
2168 output+= 2;
2169
2170 return output;
2171
2172 cmsUNUSED_PARAMETER(info);
2173 cmsUNUSED_PARAMETER(Stride);
2174 }
2175
2176
2177 static
2178 cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2179 CMSREGISTER cmsUInt16Number wOut[],
2180 CMSREGISTER cmsUInt8Number* output,
2181 CMSREGISTER cmsUInt32Number Stride)
2182 {
2183 *(cmsUInt16Number*) output = wOut[2];
2184 output+= 2;
2185 *(cmsUInt16Number*) output = wOut[1];
2186 output+= 2;
2187 *(cmsUInt16Number*) output = wOut[0];
2188 output+= 2;
2189 output+= 2;
2190
2191 return output;
2192
2193 cmsUNUSED_PARAMETER(info);
2194 cmsUNUSED_PARAMETER(Stride);
2195 }
2196
2197
2198
2199 static
2200 cmsUInt8Number* Pack1Byte(CMSREGISTER _cmsTRANSFORM* info,
2201 CMSREGISTER cmsUInt16Number wOut[],
2202 CMSREGISTER cmsUInt8Number* output,
2203 CMSREGISTER cmsUInt32Number Stride)
2204 {
2205 *output++ = FROM_16_TO_8(wOut[0]);
2206
2207 return output;
2208
2209 cmsUNUSED_PARAMETER(info);
2210 cmsUNUSED_PARAMETER(Stride);
2211 }
2212
2213
2214 static
2215 cmsUInt8Number* Pack1ByteReversed(CMSREGISTER _cmsTRANSFORM* info,
2216 CMSREGISTER cmsUInt16Number wOut[],
2217 CMSREGISTER cmsUInt8Number* output,
2218 CMSREGISTER cmsUInt32Number Stride)
2219 {
2220 *output++ = FROM_16_TO_8(REVERSE_FLAVOR_16(wOut[0]));
2221
2222 return output;
2223
2224 cmsUNUSED_PARAMETER(info);
2225 cmsUNUSED_PARAMETER(Stride);
2226 }
2227
2228
2229 static
2230 cmsUInt8Number* Pack1ByteSkip1(CMSREGISTER _cmsTRANSFORM* info,
2231 CMSREGISTER cmsUInt16Number wOut[],
2232 CMSREGISTER cmsUInt8Number* output,
2233 CMSREGISTER cmsUInt32Number Stride)
2234 {
2235 *output++ = FROM_16_TO_8(wOut[0]);
2236 output++;
2237
2238 return output;
2239
2240 cmsUNUSED_PARAMETER(info);
2241 cmsUNUSED_PARAMETER(Stride);
2242 }
2243
2244
2245 static
2246 cmsUInt8Number* Pack1ByteSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2247 CMSREGISTER cmsUInt16Number wOut[],
2248 CMSREGISTER cmsUInt8Number* output,
2249 CMSREGISTER cmsUInt32Number Stride)
2250 {
2251 output++;
2252 *output++ = FROM_16_TO_8(wOut[0]);
2253
2254 return output;
2255
2256 cmsUNUSED_PARAMETER(info);
2257 cmsUNUSED_PARAMETER(Stride);
2258 }
2259
2260 static
2261 cmsUInt8Number* Pack1Word(CMSREGISTER _cmsTRANSFORM* info,
2262 CMSREGISTER cmsUInt16Number wOut[],
2263 CMSREGISTER cmsUInt8Number* output,
2264 CMSREGISTER cmsUInt32Number Stride)
2265 {
2266 *(cmsUInt16Number*) output = wOut[0];
2267 output+= 2;
2268
2269 return output;
2270
2271 cmsUNUSED_PARAMETER(info);
2272 cmsUNUSED_PARAMETER(Stride);
2273 }
2274
2275
2276 static
2277 cmsUInt8Number* Pack1WordReversed(CMSREGISTER _cmsTRANSFORM* info,
2278 CMSREGISTER cmsUInt16Number wOut[],
2279 CMSREGISTER cmsUInt8Number* output,
2280 CMSREGISTER cmsUInt32Number Stride)
2281 {
2282 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
2283 output+= 2;
2284
2285 return output;
2286
2287 cmsUNUSED_PARAMETER(info);
2288 cmsUNUSED_PARAMETER(Stride);
2289 }
2290
2291 static
2292 cmsUInt8Number* Pack1WordBigEndian(CMSREGISTER _cmsTRANSFORM* info,
2293 CMSREGISTER cmsUInt16Number wOut[],
2294 CMSREGISTER cmsUInt8Number* output,
2295 CMSREGISTER cmsUInt32Number Stride)
2296 {
2297 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
2298 output+= 2;
2299
2300 return output;
2301
2302 cmsUNUSED_PARAMETER(info);
2303 cmsUNUSED_PARAMETER(Stride);
2304 }
2305
2306
2307 static
2308 cmsUInt8Number* Pack1WordSkip1(CMSREGISTER _cmsTRANSFORM* info,
2309 CMSREGISTER cmsUInt16Number wOut[],
2310 CMSREGISTER cmsUInt8Number* output,
2311 CMSREGISTER cmsUInt32Number Stride)
2312 {
2313 *(cmsUInt16Number*) output = wOut[0];
2314 output+= 4;
2315
2316 return output;
2317
2318 cmsUNUSED_PARAMETER(info);
2319 cmsUNUSED_PARAMETER(Stride);
2320 }
2321
2322 static
2323 cmsUInt8Number* Pack1WordSkip1SwapFirst(CMSREGISTER _cmsTRANSFORM* info,
2324 CMSREGISTER cmsUInt16Number wOut[],
2325 CMSREGISTER cmsUInt8Number* output,
2326 CMSREGISTER cmsUInt32Number Stride)
2327 {
2328 output += 2;
2329 *(cmsUInt16Number*) output = wOut[0];
2330 output+= 2;
2331
2332 return output;
2333
2334 cmsUNUSED_PARAMETER(info);
2335 cmsUNUSED_PARAMETER(Stride);
2336 }
2337
2338
2339 // Unencoded Float values -- don't try optimize speed
2340 static
2341 cmsUInt8Number* PackLabDoubleFrom16(CMSREGISTER _cmsTRANSFORM* info,
2342 CMSREGISTER cmsUInt16Number wOut[],
2343 CMSREGISTER cmsUInt8Number* output,
2344 CMSREGISTER cmsUInt32Number Stride)
2345 {
2346
2347 if (T_PLANAR(info -> OutputFormat)) {
2348
2349 cmsCIELab Lab;
2350 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2351 cmsLabEncoded2Float(&Lab, wOut);
2352
2353 Out[0] = Lab.L;
2354 Out[Stride] = Lab.a;
2355 Out[Stride*2] = Lab.b;
2356
2357 return output + sizeof(cmsFloat64Number);
2358 }
2359 else {
2360
2361 cmsLabEncoded2Float((cmsCIELab*) output, wOut);
2362 return output + (sizeof(cmsCIELab) + T_EXTRA(info ->OutputFormat) * sizeof(cmsFloat64Number));
2363 }
2364 }
2365
2366
2367 static
2368 cmsUInt8Number* PackLabFloatFrom16(CMSREGISTER _cmsTRANSFORM* info,
2369 CMSREGISTER cmsUInt16Number wOut[],
2370 CMSREGISTER cmsUInt8Number* output,
2371 CMSREGISTER cmsUInt32Number Stride)
2372 {
2373 cmsCIELab Lab;
2374 cmsLabEncoded2Float(&Lab, wOut);
2375
2376 if (T_PLANAR(info -> OutputFormat)) {
2377
2378 cmsFloat32Number* Out = (cmsFloat32Number*) output;
2379
2380 Stride /= PixelSize(info->OutputFormat);
2381
2382 Out[0] = (cmsFloat32Number)Lab.L;
2383 Out[Stride] = (cmsFloat32Number)Lab.a;
2384 Out[Stride*2] = (cmsFloat32Number)Lab.b;
2385
2386 return output + sizeof(cmsFloat32Number);
2387 }
2388 else {
2389
2390 ((cmsFloat32Number*) output)[0] = (cmsFloat32Number) Lab.L;
2391 ((cmsFloat32Number*) output)[1] = (cmsFloat32Number) Lab.a;
2392 ((cmsFloat32Number*) output)[2] = (cmsFloat32Number) Lab.b;
2393
2394 return output + (3 + T_EXTRA(info ->OutputFormat)) * sizeof(cmsFloat32Number);
2395 }
2396 }
2397
2398 static
2399 cmsUInt8Number* PackXYZDoubleFrom16(CMSREGISTER _cmsTRANSFORM* Info,
2400 CMSREGISTER cmsUInt16Number wOut[],
2401 CMSREGISTER cmsUInt8Number* output,
2402 CMSREGISTER cmsUInt32Number Stride)
2403 {
2404 if (T_PLANAR(Info -> OutputFormat)) {
2405
2406 cmsCIEXYZ XYZ;
2407 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2408 cmsXYZEncoded2Float(&XYZ, wOut);
2409
2410 Stride /= PixelSize(Info->OutputFormat);
2411
2412 Out[0] = XYZ.X;
2413 Out[Stride] = XYZ.Y;
2414 Out[Stride*2] = XYZ.Z;
2415
2416 return output + sizeof(cmsFloat64Number);
2417
2418 }
2419 else {
2420
2421 cmsXYZEncoded2Float((cmsCIEXYZ*) output, wOut);
2422
2423 return output + (sizeof(cmsCIEXYZ) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
2424 }
2425 }
2426
2427 static
2428 cmsUInt8Number* PackXYZFloatFrom16(CMSREGISTER _cmsTRANSFORM* Info,
2429 CMSREGISTER cmsUInt16Number wOut[],
2430 CMSREGISTER cmsUInt8Number* output,
2431 CMSREGISTER cmsUInt32Number Stride)
2432 {
2433 if (T_PLANAR(Info -> OutputFormat)) {
2434
2435 cmsCIEXYZ XYZ;
2436 cmsFloat32Number* Out = (cmsFloat32Number*) output;
2437 cmsXYZEncoded2Float(&XYZ, wOut);
2438
2439 Stride /= PixelSize(Info->OutputFormat);
2440
2441 Out[0] = (cmsFloat32Number) XYZ.X;
2442 Out[Stride] = (cmsFloat32Number) XYZ.Y;
2443 Out[Stride*2] = (cmsFloat32Number) XYZ.Z;
2444
2445 return output + sizeof(cmsFloat32Number);
2446
2447 }
2448 else {
2449
2450 cmsCIEXYZ XYZ;
2451 cmsFloat32Number* Out = (cmsFloat32Number*) output;
2452 cmsXYZEncoded2Float(&XYZ, wOut);
2453
2454 Out[0] = (cmsFloat32Number) XYZ.X;
2455 Out[1] = (cmsFloat32Number) XYZ.Y;
2456 Out[2] = (cmsFloat32Number) XYZ.Z;
2457
2458 return output + (3 * sizeof(cmsFloat32Number) + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
2459 }
2460 }
2461
2462 static
2463 cmsUInt8Number* PackDoubleFrom16(CMSREGISTER _cmsTRANSFORM* info,
2464 CMSREGISTER cmsUInt16Number wOut[],
2465 CMSREGISTER cmsUInt8Number* output,
2466 CMSREGISTER cmsUInt32Number Stride)
2467 {
2468 cmsUInt32Number nChan = T_CHANNELS(info -> OutputFormat);
2469 cmsUInt32Number DoSwap = T_DOSWAP(info ->OutputFormat);
2470 cmsUInt32Number Reverse = T_FLAVOR(info ->OutputFormat);
2471 cmsUInt32Number Extra = T_EXTRA(info -> OutputFormat);
2472 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> OutputFormat);
2473 cmsUInt32Number Planar = T_PLANAR(info -> OutputFormat);
2474 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2475 cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35 : 65535.0;
2476 cmsFloat64Number v = 0;
2477 cmsFloat64Number* swap1 = (cmsFloat64Number*) output;
2478 cmsUInt32Number i, start = 0;
2479
2480 Stride /= PixelSize(info->OutputFormat);
2481
2482 if (ExtraFirst)
2483 start = Extra;
2484
2485 for (i=0; i < nChan; i++) {
2486
2487 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2488
2489 v = (cmsFloat64Number) wOut[index] / maximum;
2490
2491 if (Reverse)
2492 v = maximum - v;
2493
2494 if (Planar)
2495 ((cmsFloat64Number*) output)[(i + start) * Stride]= v;
2496 else
2497 ((cmsFloat64Number*) output)[i + start] = v;
2498 }
2499
2500
2501 if (Extra == 0 && SwapFirst) {
2502
2503 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number));
2504 *swap1 = v;
2505 }
2506
2507 if (T_PLANAR(info -> OutputFormat))
2508 return output + sizeof(cmsFloat64Number);
2509 else
2510 return output + (nChan + Extra) * sizeof(cmsFloat64Number);
2511
2512 }
2513
2514
2515 static
2516 cmsUInt8Number* PackFloatFrom16(CMSREGISTER _cmsTRANSFORM* info,
2517 CMSREGISTER cmsUInt16Number wOut[],
2518 CMSREGISTER cmsUInt8Number* output,
2519 CMSREGISTER cmsUInt32Number Stride)
2520 {
2521 cmsUInt32Number nChan = T_CHANNELS(info->OutputFormat);
2522 cmsUInt32Number DoSwap = T_DOSWAP(info->OutputFormat);
2523 cmsUInt32Number Reverse = T_FLAVOR(info->OutputFormat);
2524 cmsUInt32Number Extra = T_EXTRA(info->OutputFormat);
2525 cmsUInt32Number SwapFirst = T_SWAPFIRST(info->OutputFormat);
2526 cmsUInt32Number Planar = T_PLANAR(info->OutputFormat);
2527 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2528 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 655.35 : 65535.0;
2529 cmsFloat64Number v = 0;
2530 cmsFloat32Number* swap1 = (cmsFloat32Number*)output;
2531 cmsUInt32Number i, start = 0;
2532
2533 Stride /= PixelSize(info->OutputFormat);
2534
2535 if (ExtraFirst)
2536 start = Extra;
2537
2538 for (i = 0; i < nChan; i++) {
2539
2540 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2541
2542 v = (cmsFloat64Number)wOut[index] / maximum;
2543
2544 if (Reverse)
2545 v = maximum - v;
2546
2547 if (Planar)
2548 ((cmsFloat32Number*)output)[(i + start) * Stride] = (cmsFloat32Number)v;
2549 else
2550 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v;
2551 }
2552
2553
2554 if (Extra == 0 && SwapFirst) {
2555
2556 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number));
2557 *swap1 = (cmsFloat32Number)v;
2558 }
2559
2560 if (T_PLANAR(info->OutputFormat))
2561 return output + sizeof(cmsFloat32Number);
2562 else
2563 return output + (nChan + Extra) * sizeof(cmsFloat32Number);
2564 }
2565
2566
2567
2568 // --------------------------------------------------------------------------------------------------------
2569
2570 static
2571 cmsUInt8Number* PackFloatsFromFloat(_cmsTRANSFORM* info,
2572 cmsFloat32Number wOut[],
2573 cmsUInt8Number* output,
2574 cmsUInt32Number Stride)
2575 {
2576 cmsUInt32Number nChan = T_CHANNELS(info->OutputFormat);
2577 cmsUInt32Number DoSwap = T_DOSWAP(info->OutputFormat);
2578 cmsUInt32Number Reverse = T_FLAVOR(info->OutputFormat);
2579 cmsUInt32Number Extra = T_EXTRA(info->OutputFormat);
2580 cmsUInt32Number SwapFirst = T_SWAPFIRST(info->OutputFormat);
2581 cmsUInt32Number Planar = T_PLANAR(info->OutputFormat);
2582 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2583 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0;
2584 cmsFloat32Number* swap1 = (cmsFloat32Number*)output;
2585 cmsFloat64Number v = 0;
2586 cmsUInt32Number i, start = 0;
2587
2588 Stride /= PixelSize(info->OutputFormat);
2589
2590 if (ExtraFirst)
2591 start = Extra;
2592
2593 for (i = 0; i < nChan; i++) {
2594
2595 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2596
2597 v = wOut[index] * maximum;
2598
2599 if (Reverse)
2600 v = maximum - v;
2601
2602 if (Planar)
2603 ((cmsFloat32Number*)output)[(i + start)* Stride] = (cmsFloat32Number)v;
2604 else
2605 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v;
2606 }
2607
2608
2609 if (Extra == 0 && SwapFirst) {
2610
2611 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number));
2612 *swap1 = (cmsFloat32Number)v;
2613 }
2614
2615 if (T_PLANAR(info->OutputFormat))
2616 return output + sizeof(cmsFloat32Number);
2617 else
2618 return output + (nChan + Extra) * sizeof(cmsFloat32Number);
2619 }
2620
2621 static
2622 cmsUInt8Number* PackDoublesFromFloat(_cmsTRANSFORM* info,
2623 cmsFloat32Number wOut[],
2624 cmsUInt8Number* output,
2625 cmsUInt32Number Stride)
2626 {
2627 cmsUInt32Number nChan = T_CHANNELS(info->OutputFormat);
2628 cmsUInt32Number DoSwap = T_DOSWAP(info->OutputFormat);
2629 cmsUInt32Number Reverse = T_FLAVOR(info->OutputFormat);
2630 cmsUInt32Number Extra = T_EXTRA(info->OutputFormat);
2631 cmsUInt32Number SwapFirst = T_SWAPFIRST(info->OutputFormat);
2632 cmsUInt32Number Planar = T_PLANAR(info->OutputFormat);
2633 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2634 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0;
2635 cmsFloat64Number v = 0;
2636 cmsFloat64Number* swap1 = (cmsFloat64Number*)output;
2637 cmsUInt32Number i, start = 0;
2638
2639 Stride /= PixelSize(info->OutputFormat);
2640
2641 if (ExtraFirst)
2642 start = Extra;
2643
2644 for (i = 0; i < nChan; i++) {
2645
2646 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2647
2648 v = wOut[index] * maximum;
2649
2650 if (Reverse)
2651 v = maximum - v;
2652
2653 if (Planar)
2654 ((cmsFloat64Number*)output)[(i + start) * Stride] = v;
2655 else
2656 ((cmsFloat64Number*)output)[i + start] = v;
2657 }
2658
2659 if (Extra == 0 && SwapFirst) {
2660
2661 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat64Number));
2662 *swap1 = v;
2663 }
2664
2665
2666 if (T_PLANAR(info->OutputFormat))
2667 return output + sizeof(cmsFloat64Number);
2668 else
2669 return output + (nChan + Extra) * sizeof(cmsFloat64Number);
2670
2671 }
2672
2673
2674
2675
2676
2677 static
2678 cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info,
2679 cmsFloat32Number wOut[],
2680 cmsUInt8Number* output,
2681 cmsUInt32Number Stride)
2682 {
2683 cmsFloat32Number* Out = (cmsFloat32Number*) output;
2684
2685 if (T_PLANAR(Info -> OutputFormat)) {
2686
2687 Stride /= PixelSize(Info->OutputFormat);
2688
2689 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0);
2690 Out[Stride] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0);
2691 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0);
2692
2693 return output + sizeof(cmsFloat32Number);
2694 }
2695 else {
2696
2697 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0);
2698 Out[1] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0);
2699 Out[2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0);
2700
2701 return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
2702 }
2703
2704 }
2705
2706
2707 static
2708 cmsUInt8Number* PackLabDoubleFromFloat(_cmsTRANSFORM* Info,
2709 cmsFloat32Number wOut[],
2710 cmsUInt8Number* output,
2711 cmsUInt32Number Stride)
2712 {
2713 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2714
2715 if (T_PLANAR(Info -> OutputFormat)) {
2716
2717 Stride /= PixelSize(Info->OutputFormat);
2718
2719 Out[0] = (cmsFloat64Number) (wOut[0] * 100.0);
2720 Out[Stride] = (cmsFloat64Number) (wOut[1] * 255.0 - 128.0);
2721 Out[Stride*2] = (cmsFloat64Number) (wOut[2] * 255.0 - 128.0);
2722
2723 return output + sizeof(cmsFloat64Number);
2724 }
2725 else {
2726
2727 Out[0] = (cmsFloat64Number) (wOut[0] * 100.0);
2728 Out[1] = (cmsFloat64Number) (wOut[1] * 255.0 - 128.0);
2729 Out[2] = (cmsFloat64Number) (wOut[2] * 255.0 - 128.0);
2730
2731 return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
2732 }
2733
2734 }
2735
2736
2737 // From 0..1 range to 0..MAX_ENCODEABLE_XYZ
2738 static
2739 cmsUInt8Number* PackXYZFloatFromFloat(_cmsTRANSFORM* Info,
2740 cmsFloat32Number wOut[],
2741 cmsUInt8Number* output,
2742 cmsUInt32Number Stride)
2743 {
2744 cmsFloat32Number* Out = (cmsFloat32Number*) output;
2745
2746 if (T_PLANAR(Info -> OutputFormat)) {
2747
2748 Stride /= PixelSize(Info->OutputFormat);
2749
2750 Out[0] = (cmsFloat32Number) (wOut[0] * MAX_ENCODEABLE_XYZ);
2751 Out[Stride] = (cmsFloat32Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
2752 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
2753
2754 return output + sizeof(cmsFloat32Number);
2755 }
2756 else {
2757
2758 Out[0] = (cmsFloat32Number) (wOut[0] * MAX_ENCODEABLE_XYZ);
2759 Out[1] = (cmsFloat32Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
2760 Out[2] = (cmsFloat32Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
2761
2762 return output + (sizeof(cmsFloat32Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat32Number));
2763 }
2764
2765 }
2766
2767 // Same, but convert to double
2768 static
2769 cmsUInt8Number* PackXYZDoubleFromFloat(_cmsTRANSFORM* Info,
2770 cmsFloat32Number wOut[],
2771 cmsUInt8Number* output,
2772 cmsUInt32Number Stride)
2773 {
2774 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2775
2776 if (T_PLANAR(Info -> OutputFormat)) {
2777
2778 Stride /= PixelSize(Info->OutputFormat);
2779
2780 Out[0] = (cmsFloat64Number) (wOut[0] * MAX_ENCODEABLE_XYZ);
2781 Out[Stride] = (cmsFloat64Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
2782 Out[Stride*2] = (cmsFloat64Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
2783
2784 return output + sizeof(cmsFloat64Number);
2785 }
2786 else {
2787
2788 Out[0] = (cmsFloat64Number) (wOut[0] * MAX_ENCODEABLE_XYZ);
2789 Out[1] = (cmsFloat64Number) (wOut[1] * MAX_ENCODEABLE_XYZ);
2790 Out[2] = (cmsFloat64Number) (wOut[2] * MAX_ENCODEABLE_XYZ);
2791
2792 return output + (sizeof(cmsFloat64Number)*3 + T_EXTRA(Info ->OutputFormat) * sizeof(cmsFloat64Number));
2793 }
2794
2795 }
2796
2797
2798 // ----------------------------------------------------------------------------------------------------------------
2799
2800 #ifndef CMS_NO_HALF_SUPPORT
2801
2802 // Decodes an stream of half floats to wIn[] described by input format
2803
2804 static
2805 cmsUInt8Number* UnrollHalfTo16(CMSREGISTER _cmsTRANSFORM* info,
2806 CMSREGISTER cmsUInt16Number wIn[],
2807 CMSREGISTER cmsUInt8Number* accum,
2808 CMSREGISTER cmsUInt32Number Stride)
2809 {
2810
2811 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
2812 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
2813 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
2814 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
2815 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
2816 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2817 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
2818 cmsFloat32Number v;
2819 cmsUInt32Number i, start = 0;
2820 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 655.35F : 65535.0F;
2821
2822
2823 Stride /= PixelSize(info->OutputFormat);
2824
2825 if (ExtraFirst)
2826 start = Extra;
2827
2828 for (i=0; i < nChan; i++) {
2829
2830 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2831
2832 if (Planar)
2833 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] );
2834 else
2835 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ;
2836
2837 if (Reverse) v = maximum - v;
2838
2839 wIn[index] = _cmsQuickSaturateWord(v * maximum);
2840 }
2841
2842
2843 if (Extra == 0 && SwapFirst) {
2844 cmsUInt16Number tmp = wIn[0];
2845
2846 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
2847 wIn[nChan-1] = tmp;
2848 }
2849
2850 if (T_PLANAR(info -> InputFormat))
2851 return accum + sizeof(cmsUInt16Number);
2852 else
2853 return accum + (nChan + Extra) * sizeof(cmsUInt16Number);
2854 }
2855
2856 // Decodes an stream of half floats to wIn[] described by input format
2857
2858 static
2859 cmsUInt8Number* UnrollHalfToFloat(_cmsTRANSFORM* info,
2860 cmsFloat32Number wIn[],
2861 cmsUInt8Number* accum,
2862 cmsUInt32Number Stride)
2863 {
2864
2865 cmsUInt32Number nChan = T_CHANNELS(info -> InputFormat);
2866 cmsUInt32Number DoSwap = T_DOSWAP(info ->InputFormat);
2867 cmsUInt32Number Reverse = T_FLAVOR(info ->InputFormat);
2868 cmsUInt32Number SwapFirst = T_SWAPFIRST(info -> InputFormat);
2869 cmsUInt32Number Extra = T_EXTRA(info -> InputFormat);
2870 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2871 cmsUInt32Number Planar = T_PLANAR(info -> InputFormat);
2872 cmsFloat32Number v;
2873 cmsUInt32Number i, start = 0;
2874 cmsFloat32Number maximum = IsInkSpace(info ->InputFormat) ? 100.0F : 1.0F;
2875
2876 Stride /= PixelSize(info->OutputFormat);
2877
2878 if (ExtraFirst)
2879 start = Extra;
2880
2881 for (i=0; i < nChan; i++) {
2882
2883 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2884
2885 if (Planar)
2886 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[(i + start) * Stride] );
2887 else
2888 v = _cmsHalf2Float ( ((cmsUInt16Number*) accum)[i + start] ) ;
2889
2890 v /= maximum;
2891
2892 wIn[index] = Reverse ? 1 - v : v;
2893 }
2894
2895
2896 if (Extra == 0 && SwapFirst) {
2897 cmsFloat32Number tmp = wIn[0];
2898
2899 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number));
2900 wIn[nChan-1] = tmp;
2901 }
2902
2903 if (T_PLANAR(info -> InputFormat))
2904 return accum + sizeof(cmsUInt16Number);
2905 else
2906 return accum + (nChan + Extra) * sizeof(cmsUInt16Number);
2907 }
2908
2909
2910 static
2911 cmsUInt8Number* PackHalfFrom16(CMSREGISTER _cmsTRANSFORM* info,
2912 CMSREGISTER cmsUInt16Number wOut[],
2913 CMSREGISTER cmsUInt8Number* output,
2914 CMSREGISTER cmsUInt32Number Stride)
2915 {
2916 cmsUInt32Number nChan = T_CHANNELS(info->OutputFormat);
2917 cmsUInt32Number DoSwap = T_DOSWAP(info->OutputFormat);
2918 cmsUInt32Number Reverse = T_FLAVOR(info->OutputFormat);
2919 cmsUInt32Number Extra = T_EXTRA(info->OutputFormat);
2920 cmsUInt32Number SwapFirst = T_SWAPFIRST(info->OutputFormat);
2921 cmsUInt32Number Planar = T_PLANAR(info->OutputFormat);
2922 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2923 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 655.35F : 65535.0F;
2924 cmsFloat32Number v = 0;
2925 cmsUInt16Number* swap1 = (cmsUInt16Number*)output;
2926 cmsUInt32Number i, start = 0;
2927
2928 Stride /= PixelSize(info->OutputFormat);
2929
2930 if (ExtraFirst)
2931 start = Extra;
2932
2933 for (i = 0; i < nChan; i++) {
2934
2935 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2936
2937 v = (cmsFloat32Number)wOut[index] / maximum;
2938
2939 if (Reverse)
2940 v = maximum - v;
2941
2942 if (Planar)
2943 ((cmsUInt16Number*)output)[(i + start) * Stride] = _cmsFloat2Half(v);
2944 else
2945 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v);
2946 }
2947
2948
2949 if (Extra == 0 && SwapFirst) {
2950
2951 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number));
2952 *swap1 = _cmsFloat2Half(v);
2953 }
2954
2955 if (T_PLANAR(info->OutputFormat))
2956 return output + sizeof(cmsUInt16Number);
2957 else
2958 return output + (nChan + Extra) * sizeof(cmsUInt16Number);
2959 }
2960
2961
2962
2963 static
2964 cmsUInt8Number* PackHalfFromFloat(_cmsTRANSFORM* info,
2965 cmsFloat32Number wOut[],
2966 cmsUInt8Number* output,
2967 cmsUInt32Number Stride)
2968 {
2969 cmsUInt32Number nChan = T_CHANNELS(info->OutputFormat);
2970 cmsUInt32Number DoSwap = T_DOSWAP(info->OutputFormat);
2971 cmsUInt32Number Reverse = T_FLAVOR(info->OutputFormat);
2972 cmsUInt32Number Extra = T_EXTRA(info->OutputFormat);
2973 cmsUInt32Number SwapFirst = T_SWAPFIRST(info->OutputFormat);
2974 cmsUInt32Number Planar = T_PLANAR(info->OutputFormat);
2975 cmsUInt32Number ExtraFirst = DoSwap ^ SwapFirst;
2976 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 100.0F : 1.0F;
2977 cmsUInt16Number* swap1 = (cmsUInt16Number*)output;
2978 cmsFloat32Number v = 0;
2979 cmsUInt32Number i, start = 0;
2980
2981 Stride /= PixelSize(info->OutputFormat);
2982
2983 if (ExtraFirst)
2984 start = Extra;
2985
2986 for (i = 0; i < nChan; i++) {
2987
2988 cmsUInt32Number index = DoSwap ? (nChan - i - 1) : i;
2989
2990 v = wOut[index] * maximum;
2991
2992 if (Reverse)
2993 v = maximum - v;
2994
2995 if (Planar)
2996 ((cmsUInt16Number*)output)[(i + start)* Stride] = _cmsFloat2Half(v);
2997 else
2998 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v);
2999 }
3000
3001
3002 if (Extra == 0 && SwapFirst) {
3003
3004 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number));
3005 *swap1 = (cmsUInt16Number)_cmsFloat2Half(v);
3006 }
3007
3008 if (T_PLANAR(info->OutputFormat))
3009 return output + sizeof(cmsUInt16Number);
3010 else
3011 return output + (nChan + Extra)* sizeof(cmsUInt16Number);
3012 }
3013
3014 #endif
3015
3016 // ----------------------------------------------------------------------------------------------------------------
3017
3018
3019 static const cmsFormatters16 InputFormatters16[] = {
3020
3021 // Type Mask Function
3022 // ---------------------------- ------------------------------------ ----------------------------
3023 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleTo16},
3024 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleTo16},
3025 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatTo16},
3026 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatTo16},
3027 { TYPE_GRAY_DBL, 0, UnrollDouble1Chan},
3028 { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
3029 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollDoubleTo16},
3030 { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
3031 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollFloatTo16},
3032 #ifndef CMS_NO_HALF_SUPPORT
3033 { FLOAT_SH(1)|BYTES_SH(2), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR|
3034 ANYEXTRA|ANYSWAP|ANYSPACE, UnrollHalfTo16},
3035 #endif
3036
3037 { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Unroll1Byte},
3038 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Unroll1ByteSkip1},
3039 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(2), ANYSPACE, Unroll1ByteSkip2},
3040 { CHANNELS_SH(1)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll1ByteReversed},
3041 { COLORSPACE_SH(PT_MCH2)|CHANNELS_SH(2)|BYTES_SH(1), 0, Unroll2Bytes},
3042
3043 { TYPE_LabV2_8, 0, UnrollLabV2_8 },
3044 { TYPE_ALabV2_8, 0, UnrollALabV2_8 },
3045 { TYPE_LabV2_16, 0, UnrollLabV2_16 },
3046
3047 { CHANNELS_SH(3)|BYTES_SH(1), ANYSPACE, Unroll3Bytes},
3048 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3BytesSwap},
3049 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3BytesSkip1Swap},
3050 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3BytesSkip1SwapFirst},
3051
3052 { CHANNELS_SH(3)|EXTRA_SH(1)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
3053 ANYSPACE, Unroll3BytesSkip1SwapSwapFirst},
3054
3055 { CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Unroll4Bytes},
3056 { CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Unroll4BytesReverse},
3057 { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapFirst},
3058 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll4BytesSwap},
3059 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4BytesSwapSwapFirst},
3060
3061 { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST|
3062 ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarBytes},
3063
3064 { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
3065 ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollChunkyBytes},
3066
3067 { CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Unroll1Word},
3068 { CHANNELS_SH(1)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll1WordReversed},
3069 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(3), ANYSPACE, Unroll1WordSkip3},
3070
3071 { CHANNELS_SH(2)|BYTES_SH(2), ANYSPACE, Unroll2Words},
3072 { CHANNELS_SH(3)|BYTES_SH(2), ANYSPACE, Unroll3Words},
3073 { CHANNELS_SH(4)|BYTES_SH(2), ANYSPACE, Unroll4Words},
3074
3075 { CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll3WordsSwap},
3076 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll3WordsSkip1SwapFirst},
3077 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Unroll3WordsSkip1Swap},
3078 { CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Unroll4WordsReverse},
3079 { CHANNELS_SH(4)|BYTES_SH(2)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapFirst},
3080 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Unroll4WordsSwap},
3081 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Unroll4WordsSwapSwapFirst},
3082
3083
3084 { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollPlanarWords},
3085 { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, UnrollAnyWords},
3086 };
3087
3088
3089
3090 static const cmsFormattersFloat InputFormattersFloat[] = {
3091
3092 // Type Mask Function
3093 // ---------------------------- ------------------------------------ ----------------------------
3094 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleToFloat},
3095 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatToFloat},
3096
3097 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleToFloat},
3098 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatToFloat},
3099
3100 { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
3101 ANYCHANNELS|ANYSPACE, UnrollFloatsToFloat},
3102
3103 { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
3104 ANYCHANNELS|ANYSPACE, UnrollDoublesToFloat},
3105 #ifndef CMS_NO_HALF_SUPPORT
3106 { FLOAT_SH(1)|BYTES_SH(2), ANYPLANAR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|
3107 ANYCHANNELS|ANYSPACE, UnrollHalfToFloat},
3108 #endif
3109 };
3110
3111
3112 // Bit fields set to one in the mask are not compared
3113 static
3114 cmsFormatter _cmsGetStockInputFormatter(cmsUInt32Number dwInput, cmsUInt32Number dwFlags)
3115 {
3116 cmsUInt32Number i;
3117 cmsFormatter fr;
3118
3119 switch (dwFlags) {
3120
3121 case CMS_PACK_FLAGS_16BITS: {
3122 for (i=0; i < sizeof(InputFormatters16) / sizeof(cmsFormatters16); i++) {
3123 const cmsFormatters16* f = InputFormatters16 + i;
3124
3125 if ((dwInput & ~f ->Mask) == f ->Type) {
3126 fr.Fmt16 = f ->Frm;
3127 return fr;
3128 }
3129 }
3130 }
3131 break;
3132
3133 case CMS_PACK_FLAGS_FLOAT: {
3134 for (i=0; i < sizeof(InputFormattersFloat) / sizeof(cmsFormattersFloat); i++) {
3135 const cmsFormattersFloat* f = InputFormattersFloat + i;
3136
3137 if ((dwInput & ~f ->Mask) == f ->Type) {
3138 fr.FmtFloat = f ->Frm;
3139 return fr;
3140 }
3141 }
3142 }
3143 break;
3144
3145 default:;
3146
3147 }
3148
3149 fr.Fmt16 = NULL;
3150 return fr;
3151 }
3152
3153 static const cmsFormatters16 OutputFormatters16[] = {
3154 // Type Mask Function
3155 // ---------------------------- ------------------------------------ ----------------------------
3156
3157 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFrom16},
3158 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFrom16},
3159
3160 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFrom16},
3161 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFrom16},
3162
3163 { FLOAT_SH(1)|BYTES_SH(0), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
3164 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackDoubleFrom16},
3165 { FLOAT_SH(1)|BYTES_SH(4), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
3166 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackFloatFrom16},
3167 #ifndef CMS_NO_HALF_SUPPORT
3168 { FLOAT_SH(1)|BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|
3169 ANYCHANNELS|ANYPLANAR|ANYEXTRA|ANYSPACE, PackHalfFrom16},
3170 #endif
3171
3172 { CHANNELS_SH(1)|BYTES_SH(1), ANYSPACE, Pack1Byte},
3173 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack1ByteSkip1},
3174 { CHANNELS_SH(1)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack1ByteSkip1SwapFirst},
3175
3176 { CHANNELS_SH(1)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Pack1ByteReversed},
3177
3178 { TYPE_LabV2_8, 0, PackLabV2_8 },
3179 { TYPE_ALabV2_8, 0, PackALabV2_8 },
3180 { TYPE_LabV2_16, 0, PackLabV2_16 },
3181
3182 { CHANNELS_SH(3)|BYTES_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesOptimized},
3183 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesAndSkip1Optimized},
3184 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1),
3185 ANYSPACE, Pack3BytesAndSkip1SwapFirstOptimized},
3186 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1)|OPTIMIZED_SH(1),
3187 ANYSPACE, Pack3BytesAndSkip1SwapSwapFirstOptimized},
3188 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1)|OPTIMIZED_SH(1),
3189 ANYSPACE, Pack3BytesAndSkip1SwapOptimized},
3190 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|OPTIMIZED_SH(1), ANYSPACE, Pack3BytesSwapOptimized},
3191
3192
3193
3194 { CHANNELS_SH(3)|BYTES_SH(1), ANYSPACE, Pack3Bytes},
3195 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1},
3196 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3BytesAndSkip1SwapFirst},
3197 { CHANNELS_SH(3)|BYTES_SH(1)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
3198 ANYSPACE, Pack3BytesAndSkip1SwapSwapFirst},
3199 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1)|EXTRA_SH(1), ANYSPACE, Pack3BytesAndSkip1Swap},
3200 { CHANNELS_SH(3)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3BytesSwap},
3201 { CHANNELS_SH(6)|BYTES_SH(1), ANYSPACE, Pack6Bytes},
3202 { CHANNELS_SH(6)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack6BytesSwap},
3203 { CHANNELS_SH(4)|BYTES_SH(1), ANYSPACE, Pack4Bytes},
3204 { CHANNELS_SH(4)|BYTES_SH(1)|FLAVOR_SH(1), ANYSPACE, Pack4BytesReverse},
3205 { CHANNELS_SH(4)|BYTES_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapFirst},
3206 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack4BytesSwap},
3207 { CHANNELS_SH(4)|BYTES_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack4BytesSwapSwapFirst},
3208
3209 { BYTES_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyBytes},
3210 { BYTES_SH(1)|PLANAR_SH(1), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarBytes},
3211
3212 { CHANNELS_SH(1)|BYTES_SH(2), ANYSPACE, Pack1Word},
3213 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(1), ANYSPACE, Pack1WordSkip1},
3214 { CHANNELS_SH(1)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack1WordSkip1SwapFirst},
3215 { CHANNELS_SH(1)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Pack1WordReversed},
3216 { CHANNELS_SH(1)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack1WordBigEndian},
3217 { CHANNELS_SH(3)|BYTES_SH(2), ANYSPACE, Pack3Words},
3218 { CHANNELS_SH(3)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack3WordsSwap},
3219 { CHANNELS_SH(3)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack3WordsBigEndian},
3220 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1), ANYSPACE, Pack3WordsAndSkip1},
3221 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1), ANYSPACE, Pack3WordsAndSkip1Swap},
3222 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|SWAPFIRST_SH(1), ANYSPACE, Pack3WordsAndSkip1SwapFirst},
3223
3224 { CHANNELS_SH(3)|BYTES_SH(2)|EXTRA_SH(1)|DOSWAP_SH(1)|SWAPFIRST_SH(1),
3225 ANYSPACE, Pack3WordsAndSkip1SwapSwapFirst},
3226
3227 { CHANNELS_SH(4)|BYTES_SH(2), ANYSPACE, Pack4Words},
3228 { CHANNELS_SH(4)|BYTES_SH(2)|FLAVOR_SH(1), ANYSPACE, Pack4WordsReverse},
3229 { CHANNELS_SH(4)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack4WordsSwap},
3230 { CHANNELS_SH(4)|BYTES_SH(2)|ENDIAN16_SH(1), ANYSPACE, Pack4WordsBigEndian},
3231
3232 { CHANNELS_SH(6)|BYTES_SH(2), ANYSPACE, Pack6Words},
3233 { CHANNELS_SH(6)|BYTES_SH(2)|DOSWAP_SH(1), ANYSPACE, Pack6WordsSwap},
3234
3235 { BYTES_SH(2)|PLANAR_SH(1), ANYFLAVOR|ANYENDIAN|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackPlanarWords},
3236 { BYTES_SH(2), ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYENDIAN|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackAnyWords}
3237
3238 };
3239
3240
3241 static const cmsFormattersFloat OutputFormattersFloat[] = {
3242 // Type Mask Function
3243 // ---------------------------- --------------------------------------------------- ----------------------------
3244 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, PackLabFloatFromFloat},
3245 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, PackXYZFloatFromFloat},
3246
3247 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, PackLabDoubleFromFloat},
3248 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, PackXYZDoubleFromFloat},
3249
3250 { FLOAT_SH(1)|BYTES_SH(4), ANYPLANAR|
3251 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackFloatsFromFloat },
3252 { FLOAT_SH(1)|BYTES_SH(0), ANYPLANAR|
3253 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackDoublesFromFloat },
3254 #ifndef CMS_NO_HALF_SUPPORT
3255 { FLOAT_SH(1)|BYTES_SH(2),
3256 ANYFLAVOR|ANYSWAPFIRST|ANYSWAP|ANYEXTRA|ANYCHANNELS|ANYSPACE, PackHalfFromFloat },
3257 #endif
3258
3259 };
3260
3261
3262 // Bit fields set to one in the mask are not compared
3263 static
3264 cmsFormatter _cmsGetStockOutputFormatter(cmsUInt32Number dwInput, cmsUInt32Number dwFlags)
3265 {
3266 cmsUInt32Number i;
3267 cmsFormatter fr;
3268
3269 // Optimization is only a hint
3270 dwInput &= ~OPTIMIZED_SH(1);
3271
3272 switch (dwFlags)
3273 {
3274
3275 case CMS_PACK_FLAGS_16BITS: {
3276
3277 for (i=0; i < sizeof(OutputFormatters16) / sizeof(cmsFormatters16); i++) {
3278 const cmsFormatters16* f = OutputFormatters16 + i;
3279
3280 if ((dwInput & ~f ->Mask) == f ->Type) {
3281 fr.Fmt16 = f ->Frm;
3282 return fr;
3283 }
3284 }
3285 }
3286 break;
3287
3288 case CMS_PACK_FLAGS_FLOAT: {
3289
3290 for (i=0; i < sizeof(OutputFormattersFloat) / sizeof(cmsFormattersFloat); i++) {
3291 const cmsFormattersFloat* f = OutputFormattersFloat + i;
3292
3293 if ((dwInput & ~f ->Mask) == f ->Type) {
3294 fr.FmtFloat = f ->Frm;
3295 return fr;
3296 }
3297 }
3298 }
3299 break;
3300
3301 default:;
3302
3303 }
3304
3305 fr.Fmt16 = NULL;
3306 return fr;
3307 }
3308
3309
3310 typedef struct _cms_formatters_factory_list {
3311
3312 cmsFormatterFactory Factory;
3313 struct _cms_formatters_factory_list *Next;
3314
3315 } cmsFormattersFactoryList;
3316
3317 _cmsFormattersPluginChunkType _cmsFormattersPluginChunk = { NULL };
3318
3319
3320 // Duplicates the zone of memory used by the plug-in in the new context
3321 static
3322 void DupFormatterFactoryList(struct _cmsContext_struct* ctx,
3323 const struct _cmsContext_struct* src)
3324 {
3325 _cmsFormattersPluginChunkType newHead = { NULL };
3326 cmsFormattersFactoryList* entry;
3327 cmsFormattersFactoryList* Anterior = NULL;
3328 _cmsFormattersPluginChunkType* head = (_cmsFormattersPluginChunkType*) src->chunks[FormattersPlugin];
3329
3330 _cmsAssert(head != NULL);
3331
3332 // Walk the list copying all nodes
3333 for (entry = head->FactoryList;
3334 entry != NULL;
3335 entry = entry ->Next) {
3336
3337 cmsFormattersFactoryList *newEntry = ( cmsFormattersFactoryList *) _cmsSubAllocDup(ctx ->MemPool, entry, sizeof(cmsFormattersFactoryList));
3338
3339 if (newEntry == NULL)
3340 return;
3341
3342 // We want to keep the linked list order, so this is a little bit tricky
3343 newEntry -> Next = NULL;
3344 if (Anterior)
3345 Anterior -> Next = newEntry;
3346
3347 Anterior = newEntry;
3348
3349 if (newHead.FactoryList == NULL)
3350 newHead.FactoryList = newEntry;
3351 }
3352
3353 ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx->MemPool, &newHead, sizeof(_cmsFormattersPluginChunkType));
3354 }
3355
3356 // The interpolation plug-in memory chunk allocator/dup
3357 void _cmsAllocFormattersPluginChunk(struct _cmsContext_struct* ctx,
3358 const struct _cmsContext_struct* src)
3359 {
3360 _cmsAssert(ctx != NULL);
3361
3362 if (src != NULL) {
3363
3364 // Duplicate the LIST
3365 DupFormatterFactoryList(ctx, src);
3366 }
3367 else {
3368 static _cmsFormattersPluginChunkType FormattersPluginChunk = { NULL };
3369 ctx ->chunks[FormattersPlugin] = _cmsSubAllocDup(ctx ->MemPool, &FormattersPluginChunk, sizeof(_cmsFormattersPluginChunkType));
3370 }
3371 }
3372
3373
3374
3375 // Formatters management
3376 cmsBool _cmsRegisterFormattersPlugin(cmsContext ContextID, cmsPluginBase* Data)
3377 {
3378 _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin);
3379 cmsPluginFormatters* Plugin = (cmsPluginFormatters*) Data;
3380 cmsFormattersFactoryList* fl ;
3381
3382 // Reset to built-in defaults
3383 if (Data == NULL) {
3384
3385 ctx ->FactoryList = NULL;
3386 return TRUE;
3387 }
3388
3389 fl = (cmsFormattersFactoryList*) _cmsPluginMalloc(ContextID, sizeof(cmsFormattersFactoryList));
3390 if (fl == NULL) return FALSE;
3391
3392 fl ->Factory = Plugin ->FormattersFactory;
3393
3394 fl ->Next = ctx -> FactoryList;
3395 ctx ->FactoryList = fl;
3396
3397 return TRUE;
3398 }
3399
3400 cmsFormatter CMSEXPORT _cmsGetFormatter(cmsContext ContextID,
3401 cmsUInt32Number Type, // Specific type, i.e. TYPE_RGB_8
3402 cmsFormatterDirection Dir,
3403 cmsUInt32Number dwFlags)
3404 {
3405 _cmsFormattersPluginChunkType* ctx = ( _cmsFormattersPluginChunkType*) _cmsContextGetClientChunk(ContextID, FormattersPlugin);
3406 cmsFormattersFactoryList* f;
3407
3408 for (f =ctx->FactoryList; f != NULL; f = f ->Next) {
3409
3410 cmsFormatter fn = f ->Factory(Type, Dir, dwFlags);
3411 if (fn.Fmt16 != NULL) return fn;
3412 }
3413
3414 // Revert to default
3415 if (Dir == cmsFormatterInput)
3416 return _cmsGetStockInputFormatter(Type, dwFlags);
3417 else
3418 return _cmsGetStockOutputFormatter(Type, dwFlags);
3419 }
3420
3421
3422 // Return whatever given formatter refers to float values
3423 cmsBool _cmsFormatterIsFloat(cmsUInt32Number Type)
3424 {
3425 return T_FLOAT(Type) ? TRUE : FALSE;
3426 }
3427
3428 // Return whatever given formatter refers to 8 bits
3429 cmsBool _cmsFormatterIs8bit(cmsUInt32Number Type)
3430 {
3431 cmsUInt32Number Bytes = T_BYTES(Type);
3432
3433 return (Bytes == 1);
3434 }
3435
3436 // Build a suitable formatter for the colorspace of this profile
3437 cmsUInt32Number CMSEXPORT cmsFormatterForColorspaceOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat)
3438 {
3439
3440 cmsColorSpaceSignature ColorSpace = cmsGetColorSpace(hProfile);
3441 cmsUInt32Number ColorSpaceBits = (cmsUInt32Number) _cmsLCMScolorSpace(ColorSpace);
3442 cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace);
3443 cmsUInt32Number Float = lIsFloat ? 1U : 0;
3444
3445 // Create a fake formatter for result
3446 return FLOAT_SH(Float) | COLORSPACE_SH(ColorSpaceBits) | BYTES_SH(nBytes) | CHANNELS_SH(nOutputChans);
3447 }
3448
3449 // Build a suitable formatter for the colorspace of this profile
3450 cmsUInt32Number CMSEXPORT cmsFormatterForPCSOfProfile(cmsHPROFILE hProfile, cmsUInt32Number nBytes, cmsBool lIsFloat)
3451 {
3452
3453 cmsColorSpaceSignature ColorSpace = cmsGetPCS(hProfile);
3454
3455 cmsUInt32Number ColorSpaceBits = (cmsUInt32Number) _cmsLCMScolorSpace(ColorSpace);
3456 cmsUInt32Number nOutputChans = cmsChannelsOf(ColorSpace);
3457 cmsUInt32Number Float = lIsFloat ? 1U : 0;
3458
3459 // Create a fake formatter for result
3460 return FLOAT_SH(Float) | COLORSPACE_SH(ColorSpaceBits) | BYTES_SH(nBytes) | CHANNELS_SH(nOutputChans);
3461 }
3462