142 for (i=0; i < nChan; i++) {
143 int 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(register _cmsTRANSFORM* info,
172 register cmsUInt16Number wIn[],
173 register cmsUInt8Number* accum,
174 register cmsUInt32Number Stride)
175 {
176 int nChan = T_CHANNELS(info -> InputFormat);
177 int DoSwap = T_DOSWAP(info ->InputFormat);
178 int SwapFirst = T_SWAPFIRST(info ->InputFormat);
179 int Reverse = T_FLAVOR(info ->InputFormat);
180 int i;
181 cmsUInt8Number* Init = accum;
182
183 if (DoSwap ^ SwapFirst) {
184 accum += T_EXTRA(info -> InputFormat) * Stride;
185 }
186
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(register _cmsTRANSFORM* info,
202 register cmsUInt16Number wIn[],
203 register cmsUInt8Number* accum,
204 register 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(register _cmsTRANSFORM* info,
219 register cmsUInt16Number wIn[],
220 register cmsUInt8Number* accum,
221 register 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(register _cmsTRANSFORM* info,
236 register cmsUInt16Number wIn[],
237 register cmsUInt8Number* accum,
238 register 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(register _cmsTRANSFORM* info,
254 register cmsUInt16Number wIn[],
255 register cmsUInt8Number* accum,
256 register 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(register _cmsTRANSFORM* info,
271 register cmsUInt16Number wIn[],
272 register cmsUInt8Number* accum,
273 register 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(register _cmsTRANSFORM* info,
288 register cmsUInt16Number wIn[],
289 register cmsUInt8Number* accum,
290 register 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(register _cmsTRANSFORM* info,
304 register cmsUInt16Number wIn[],
305 register cmsUInt8Number* accum,
306 register 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(register _cmsTRANSFORM* info,
321 register cmsUInt16Number wIn[],
322 register cmsUInt8Number* accum,
323 register 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(register _cmsTRANSFORM* info,
338 register cmsUInt16Number wIn[],
339 register cmsUInt8Number* accum,
340 register 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(register _cmsTRANSFORM* info,
357 register cmsUInt16Number wIn[],
358 register cmsUInt8Number* accum,
359 register 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(register _cmsTRANSFORM* info,
373 register cmsUInt16Number wIn[],
374 register cmsUInt8Number* accum,
375 register 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(register _cmsTRANSFORM* info,
389 register cmsUInt16Number wIn[],
390 register cmsUInt8Number* accum,
391 register 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(register _cmsTRANSFORM* info,
406 register cmsUInt16Number wIn[],
407 register cmsUInt8Number* accum,
408 register 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(register _cmsTRANSFORM* info,
423 register cmsUInt16Number wIn[],
424 register cmsUInt8Number* accum,
425 register 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(register _cmsTRANSFORM* info,
442 register cmsUInt16Number wIn[],
443 register cmsUInt8Number* accum,
444 register 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(register _cmsTRANSFORM* info,
457 register cmsUInt16Number wIn[],
458 register cmsUInt8Number* accum,
459 register 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(register _cmsTRANSFORM* info,
472 register cmsUInt16Number wIn[],
473 register cmsUInt8Number* accum,
474 register 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(register _cmsTRANSFORM* info,
487 register cmsUInt16Number wIn[],
488 register cmsUInt8Number* accum,
489 register 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(register _cmsTRANSFORM* info,
502 register cmsUInt16Number wIn[],
503 register cmsUInt8Number* accum,
504 register cmsUInt32Number Stride)
505 {
506 int nChan = T_CHANNELS(info -> InputFormat);
507 int SwapEndian = T_ENDIAN16(info -> InputFormat);
508 int DoSwap = T_DOSWAP(info ->InputFormat);
509 int Reverse = T_FLAVOR(info ->InputFormat);
510 int SwapFirst = T_SWAPFIRST(info -> InputFormat);
511 int Extra = T_EXTRA(info -> InputFormat);
512 int ExtraFirst = DoSwap ^ SwapFirst;
513 int i;
514
515 if (ExtraFirst) {
516 accum += Extra * sizeof(cmsUInt16Number);
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(register _cmsTRANSFORM* info,
551 register cmsUInt16Number wIn[],
552 register cmsUInt8Number* accum,
553 register cmsUInt32Number Stride)
554 {
555 int nChan = T_CHANNELS(info -> InputFormat);
556 int DoSwap= T_DOSWAP(info ->InputFormat);
557 int Reverse= T_FLAVOR(info ->InputFormat);
558 int SwapEndian = T_ENDIAN16(info -> InputFormat);
559 int i;
560 cmsUInt8Number* Init = accum;
561
562 if (DoSwap) {
563 accum += T_EXTRA(info -> InputFormat) * Stride * sizeof(cmsUInt16Number);
564 }
565
566 for (i=0; i < nChan; i++) {
574 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
575
576 accum += Stride * sizeof(cmsUInt16Number);
577 }
578
579 return (Init + sizeof(cmsUInt16Number));
580 }
581
582
583 static
584 cmsUInt8Number* Unroll4Words(register _cmsTRANSFORM* info,
585 register cmsUInt16Number wIn[],
586 register cmsUInt8Number* accum,
587 register 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(register _cmsTRANSFORM* info,
602 register cmsUInt16Number wIn[],
603 register cmsUInt8Number* accum,
604 register 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(register _cmsTRANSFORM* info,
619 register cmsUInt16Number wIn[],
620 register cmsUInt8Number* accum,
621 register 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(register _cmsTRANSFORM* info,
637 register cmsUInt16Number wIn[],
638 register cmsUInt8Number* accum,
639 register 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(register _cmsTRANSFORM* info,
654 register cmsUInt16Number wIn[],
655 register cmsUInt8Number* accum,
656 register 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(register _cmsTRANSFORM* info,
671 register cmsUInt16Number wIn[],
672 register cmsUInt8Number* accum,
673 register 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(register _cmsTRANSFORM* info,
687 register cmsUInt16Number wIn[],
688 register cmsUInt8Number* accum,
689 register 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(register _cmsTRANSFORM* info,
703 register cmsUInt16Number wIn[],
704 register cmsUInt8Number* accum,
705 register 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(register _cmsTRANSFORM* info,
720 register cmsUInt16Number wIn[],
721 register cmsUInt8Number* accum,
722 register 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(register _cmsTRANSFORM* info,
737 register cmsUInt16Number wIn[],
738 register cmsUInt8Number* accum,
739 register 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(register _cmsTRANSFORM* info,
751 register cmsUInt16Number wIn[],
752 register cmsUInt8Number* accum,
753 register 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(register _cmsTRANSFORM* info,
765 register cmsUInt16Number wIn[],
766 register cmsUInt8Number* accum,
767 register 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(register _cmsTRANSFORM* info,
781 register cmsUInt16Number wIn[],
782 register cmsUInt8Number* accum,
783 register 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(register _cmsTRANSFORM* info,
798 register cmsUInt16Number wIn[],
799 register cmsUInt8Number* accum,
800 register cmsUInt32Number Stride)
801 {
802 if (T_PLANAR(info -> InputFormat)) {
803
804 cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
805
806 cmsCIELab Lab;
807
808 Lab.L = Pt[0];
809 Lab.a = Pt[Stride];
810 Lab.b = Pt[Stride*2];
811
1050 if (T_PLANAR(info -> InputFormat))
1051 return accum + sizeof(cmsFloat32Number);
1052 else
1053 return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
1054 }
1055
1056
1057
1058
1059 // For 1 channel, we need to duplicate data (it comes in 0..1.0 range)
1060 static
1061 cmsUInt8Number* UnrollDouble1Chan(register _cmsTRANSFORM* info,
1062 register cmsUInt16Number wIn[],
1063 register cmsUInt8Number* accum,
1064 register cmsUInt32Number Stride)
1065 {
1066 cmsFloat64Number* Inks = (cmsFloat64Number*) accum;
1067
1068 wIn[0] = wIn[1] = wIn[2] = _cmsQuickSaturateWord(Inks[0] * 65535.0);
1069
1070 return accum + sizeof(cmsFloat64Number);
1071
1072 cmsUNUSED_PARAMETER(info);
1073 cmsUNUSED_PARAMETER(Stride);
1074 }
1075
1076 //-------------------------------------------------------------------------------------------------------------------
1077
1078 // For anything going from cmsFloat32Number
1079 static
1080 cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info,
1081 cmsFloat32Number wIn[],
1082 cmsUInt8Number* accum,
1083 cmsUInt32Number Stride)
1084 {
1085
1086 int nChan = T_CHANNELS(info -> InputFormat);
1087 int DoSwap = T_DOSWAP(info ->InputFormat);
1088 int Reverse = T_FLAVOR(info ->InputFormat);
1089 int SwapFirst = T_SWAPFIRST(info -> InputFormat);
1090 int Extra = T_EXTRA(info -> InputFormat);
1091 int ExtraFirst = DoSwap ^ SwapFirst;
1092 int Planar = T_PLANAR(info -> InputFormat);
1093 cmsFloat32Number v;
1327 int index = DoSwap ? (nChan - i - 1) : i;
1328
1329 v = FROM_16_TO_8(wOut[index]);
1330
1331 if (Reverse)
1332 v = REVERSE_FLAVOR_8(v);
1333
1334 *output++ = v;
1335 }
1336
1337 if (!ExtraFirst) {
1338 output += Extra;
1339 }
1340
1341 if (Extra == 0 && SwapFirst) {
1342
1343 memmove(swap1 + 1, swap1, nChan-1);
1344 *swap1 = v;
1345 }
1346
1347
1348 return output;
1349
1350 cmsUNUSED_PARAMETER(Stride);
1351 }
1352
1353
1354
1355 static
1356 cmsUInt8Number* PackAnyWords(register _cmsTRANSFORM* info,
1357 register cmsUInt16Number wOut[],
1358 register cmsUInt8Number* output,
1359 register cmsUInt32Number Stride)
1360 {
1361 int nChan = T_CHANNELS(info -> OutputFormat);
1362 int SwapEndian = T_ENDIAN16(info -> InputFormat);
1363 int DoSwap = T_DOSWAP(info ->OutputFormat);
1364 int Reverse = T_FLAVOR(info ->OutputFormat);
1365 int Extra = T_EXTRA(info -> OutputFormat);
1366 int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
1367 int ExtraFirst = DoSwap ^ SwapFirst;
1368 cmsUInt16Number* swap1;
1369 cmsUInt16Number v = 0;
1370 int i;
1385 v = CHANGE_ENDIAN(v);
1386
1387 if (Reverse)
1388 v = REVERSE_FLAVOR_16(v);
1389
1390 *(cmsUInt16Number*) output = v;
1391
1392 output += sizeof(cmsUInt16Number);
1393 }
1394
1395 if (!ExtraFirst) {
1396 output += Extra * sizeof(cmsUInt16Number);
1397 }
1398
1399 if (Extra == 0 && SwapFirst) {
1400
1401 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number));
1402 *swap1 = v;
1403 }
1404
1405
1406 return output;
1407
1408 cmsUNUSED_PARAMETER(Stride);
1409 }
1410
1411
1412 static
1413 cmsUInt8Number* PackPlanarBytes(register _cmsTRANSFORM* info,
1414 register cmsUInt16Number wOut[],
1415 register cmsUInt8Number* output,
1416 register cmsUInt32Number Stride)
1417 {
1418 int nChan = T_CHANNELS(info -> OutputFormat);
1419 int DoSwap = T_DOSWAP(info ->OutputFormat);
1420 int SwapFirst = T_SWAPFIRST(info ->OutputFormat);
1421 int Reverse = T_FLAVOR(info ->OutputFormat);
1422 int i;
1423 cmsUInt8Number* Init = output;
1424
1425
1426 if (DoSwap ^ SwapFirst) {
1427 output += T_EXTRA(info -> OutputFormat) * Stride;
1428 }
1429
1430
1431 for (i=0; i < nChan; i++) {
1432
1433 int index = DoSwap ? (nChan - i - 1) : i;
1434 cmsUInt8Number v = FROM_16_TO_8(wOut[index]);
1435
1436 *(cmsUInt8Number*) output = (cmsUInt8Number) (Reverse ? REVERSE_FLAVOR_8(v) : v);
1437 output += Stride;
1438 }
1439
1440 return (Init + 1);
1441
1442 cmsUNUSED_PARAMETER(Stride);
1443 }
1444
1445
1446 static
1447 cmsUInt8Number* PackPlanarWords(register _cmsTRANSFORM* info,
1448 register cmsUInt16Number wOut[],
1449 register cmsUInt8Number* output,
1450 register cmsUInt32Number Stride)
1451 {
1452 int nChan = T_CHANNELS(info -> OutputFormat);
1453 int DoSwap = T_DOSWAP(info ->OutputFormat);
1454 int Reverse= T_FLAVOR(info ->OutputFormat);
1455 int SwapEndian = T_ENDIAN16(info -> OutputFormat);
1456 int i;
1457 cmsUInt8Number* Init = output;
1458 cmsUInt16Number v;
1459
1460 if (DoSwap) {
1461 output += T_EXTRA(info -> OutputFormat) * Stride * sizeof(cmsUInt16Number);
1462 }
1478 }
1479
1480 return (Init + sizeof(cmsUInt16Number));
1481 }
1482
1483 // CMYKcm (unrolled for speed)
1484
1485 static
1486 cmsUInt8Number* Pack6Bytes(register _cmsTRANSFORM* info,
1487 register cmsUInt16Number wOut[],
1488 register cmsUInt8Number* output,
1489 register cmsUInt32Number Stride)
1490 {
1491 *output++ = FROM_16_TO_8(wOut[0]);
1492 *output++ = FROM_16_TO_8(wOut[1]);
1493 *output++ = FROM_16_TO_8(wOut[2]);
1494 *output++ = FROM_16_TO_8(wOut[3]);
1495 *output++ = FROM_16_TO_8(wOut[4]);
1496 *output++ = FROM_16_TO_8(wOut[5]);
1497
1498 return output;
1499
1500 cmsUNUSED_PARAMETER(info);
1501 cmsUNUSED_PARAMETER(Stride);
1502 }
1503
1504 // KCMYcm
1505
1506 static
1507 cmsUInt8Number* Pack6BytesSwap(register _cmsTRANSFORM* info,
1508 register cmsUInt16Number wOut[],
1509 register cmsUInt8Number* output,
1510 register cmsUInt32Number Stride)
1511 {
1512 *output++ = FROM_16_TO_8(wOut[5]);
1513 *output++ = FROM_16_TO_8(wOut[4]);
1514 *output++ = FROM_16_TO_8(wOut[3]);
1515 *output++ = FROM_16_TO_8(wOut[2]);
1516 *output++ = FROM_16_TO_8(wOut[1]);
1517 *output++ = FROM_16_TO_8(wOut[0]);
1518
1519 return output;
1520
1521 cmsUNUSED_PARAMETER(info);
1522 cmsUNUSED_PARAMETER(Stride);
1523 }
1524
1525 // CMYKcm
1526 static
1527 cmsUInt8Number* Pack6Words(register _cmsTRANSFORM* info,
1528 register cmsUInt16Number wOut[],
1529 register cmsUInt8Number* output,
1530 register cmsUInt32Number Stride)
1531 {
1532 *(cmsUInt16Number*) output = wOut[0];
1533 output+= 2;
1534 *(cmsUInt16Number*) output = wOut[1];
1535 output+= 2;
1536 *(cmsUInt16Number*) output = wOut[2];
1537 output+= 2;
1538 *(cmsUInt16Number*) output = wOut[3];
1539 output+= 2;
1540 *(cmsUInt16Number*) output = wOut[4];
1541 output+= 2;
1542 *(cmsUInt16Number*) output = wOut[5];
1543 output+= 2;
1544
1545 return output;
1546
1547 cmsUNUSED_PARAMETER(info);
1548 cmsUNUSED_PARAMETER(Stride);
1549 }
1550
1551 // KCMYcm
1552 static
1553 cmsUInt8Number* Pack6WordsSwap(register _cmsTRANSFORM* info,
1554 register cmsUInt16Number wOut[],
1555 register cmsUInt8Number* output,
1556 register cmsUInt32Number Stride)
1557 {
1558 *(cmsUInt16Number*) output = wOut[5];
1559 output+= 2;
1560 *(cmsUInt16Number*) output = wOut[4];
1561 output+= 2;
1562 *(cmsUInt16Number*) output = wOut[3];
1563 output+= 2;
1564 *(cmsUInt16Number*) output = wOut[2];
1565 output+= 2;
1566 *(cmsUInt16Number*) output = wOut[1];
1567 output+= 2;
1568 *(cmsUInt16Number*) output = wOut[0];
1569 output+= 2;
1570
1571 return output;
1572
1573 cmsUNUSED_PARAMETER(info);
1574 cmsUNUSED_PARAMETER(Stride);
1575 }
1576
1577
1578 static
1579 cmsUInt8Number* Pack4Bytes(register _cmsTRANSFORM* info,
1580 register cmsUInt16Number wOut[],
1581 register cmsUInt8Number* output,
1582 register cmsUInt32Number Stride)
1583 {
1584 *output++ = FROM_16_TO_8(wOut[0]);
1585 *output++ = FROM_16_TO_8(wOut[1]);
1586 *output++ = FROM_16_TO_8(wOut[2]);
1587 *output++ = FROM_16_TO_8(wOut[3]);
1588
1589 return output;
1590
1591 cmsUNUSED_PARAMETER(info);
1592 cmsUNUSED_PARAMETER(Stride);
1593 }
1594
1595 static
1596 cmsUInt8Number* Pack4BytesReverse(register _cmsTRANSFORM* info,
1597 register cmsUInt16Number wOut[],
1598 register cmsUInt8Number* output,
1599 register cmsUInt32Number Stride)
1600 {
1601 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[0]));
1602 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[1]));
1603 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[2]));
1604 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[3]));
1605
1606 return output;
1607
1608 cmsUNUSED_PARAMETER(info);
1609 cmsUNUSED_PARAMETER(Stride);
1610 }
1611
1612
1613 static
1614 cmsUInt8Number* Pack4BytesSwapFirst(register _cmsTRANSFORM* info,
1615 register cmsUInt16Number wOut[],
1616 register cmsUInt8Number* output,
1617 register cmsUInt32Number Stride)
1618 {
1619 *output++ = FROM_16_TO_8(wOut[3]);
1620 *output++ = FROM_16_TO_8(wOut[0]);
1621 *output++ = FROM_16_TO_8(wOut[1]);
1622 *output++ = FROM_16_TO_8(wOut[2]);
1623
1624 return output;
1625
1626 cmsUNUSED_PARAMETER(info);
1627 cmsUNUSED_PARAMETER(Stride);
1628 }
1629
1630 // ABGR
1631 static
1632 cmsUInt8Number* Pack4BytesSwap(register _cmsTRANSFORM* info,
1633 register cmsUInt16Number wOut[],
1634 register cmsUInt8Number* output,
1635 register cmsUInt32Number Stride)
1636 {
1637 *output++ = FROM_16_TO_8(wOut[3]);
1638 *output++ = FROM_16_TO_8(wOut[2]);
1639 *output++ = FROM_16_TO_8(wOut[1]);
1640 *output++ = FROM_16_TO_8(wOut[0]);
1641
1642 return output;
1643
1644 cmsUNUSED_PARAMETER(info);
1645 cmsUNUSED_PARAMETER(Stride);
1646 }
1647
1648 static
1649 cmsUInt8Number* Pack4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
1650 register cmsUInt16Number wOut[],
1651 register cmsUInt8Number* output,
1652 register cmsUInt32Number Stride)
1653 {
1654 *output++ = FROM_16_TO_8(wOut[2]);
1655 *output++ = FROM_16_TO_8(wOut[1]);
1656 *output++ = FROM_16_TO_8(wOut[0]);
1657 *output++ = FROM_16_TO_8(wOut[3]);
1658
1659 return output;
1660
1661 cmsUNUSED_PARAMETER(info);
1662 cmsUNUSED_PARAMETER(Stride);
1663 }
1664
1665 static
1666 cmsUInt8Number* Pack4Words(register _cmsTRANSFORM* info,
1667 register cmsUInt16Number wOut[],
1668 register cmsUInt8Number* output,
1669 register cmsUInt32Number Stride)
1670 {
1671 *(cmsUInt16Number*) output = wOut[0];
1672 output+= 2;
1673 *(cmsUInt16Number*) output = wOut[1];
1674 output+= 2;
1675 *(cmsUInt16Number*) output = wOut[2];
1676 output+= 2;
1677 *(cmsUInt16Number*) output = wOut[3];
1678 output+= 2;
1679
1680 return output;
1681
1682 cmsUNUSED_PARAMETER(info);
1683 cmsUNUSED_PARAMETER(Stride);
1684 }
1685
1686 static
1687 cmsUInt8Number* Pack4WordsReverse(register _cmsTRANSFORM* info,
1688 register cmsUInt16Number wOut[],
1689 register cmsUInt8Number* output,
1690 register cmsUInt32Number Stride)
1691 {
1692 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
1693 output+= 2;
1694 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[1]);
1695 output+= 2;
1696 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[2]);
1697 output+= 2;
1698 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[3]);
1699 output+= 2;
1700
1701 return output;
1702
1703 cmsUNUSED_PARAMETER(info);
1704 cmsUNUSED_PARAMETER(Stride);
1705 }
1706
1707 // ABGR
1708 static
1709 cmsUInt8Number* Pack4WordsSwap(register _cmsTRANSFORM* info,
1710 register cmsUInt16Number wOut[],
1711 register cmsUInt8Number* output,
1712 register cmsUInt32Number Stride)
1713 {
1714 *(cmsUInt16Number*) output = wOut[3];
1715 output+= 2;
1716 *(cmsUInt16Number*) output = wOut[2];
1717 output+= 2;
1718 *(cmsUInt16Number*) output = wOut[1];
1719 output+= 2;
1720 *(cmsUInt16Number*) output = wOut[0];
1721 output+= 2;
1722
1723 return output;
1724
1725 cmsUNUSED_PARAMETER(info);
1726 cmsUNUSED_PARAMETER(Stride);
1727 }
1728
1729 // CMYK
1730 static
1731 cmsUInt8Number* Pack4WordsBigEndian(register _cmsTRANSFORM* info,
1732 register cmsUInt16Number wOut[],
1733 register cmsUInt8Number* output,
1734 register cmsUInt32Number Stride)
1735 {
1736 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1737 output+= 2;
1738 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1739 output+= 2;
1740 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1741 output+= 2;
1742 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[3]);
1743 output+= 2;
1744
1745 return output;
1746
1747 cmsUNUSED_PARAMETER(info);
1748 cmsUNUSED_PARAMETER(Stride);
1749 }
1750
1751
1752 static
1753 cmsUInt8Number* PackLabV2_8(register _cmsTRANSFORM* info,
1754 register cmsUInt16Number wOut[],
1755 register cmsUInt8Number* output,
1756 register cmsUInt32Number Stride)
1757 {
1758 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1759 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1760 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1761
1762 return output;
1763
1764 cmsUNUSED_PARAMETER(info);
1765 cmsUNUSED_PARAMETER(Stride);
1766 }
1767
1768 static
1769 cmsUInt8Number* PackALabV2_8(register _cmsTRANSFORM* info,
1770 register cmsUInt16Number wOut[],
1771 register cmsUInt8Number* output,
1772 register cmsUInt32Number Stride)
1773 {
1774 output++;
1775 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1776 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1777 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1778
1779 return output;
1780
1781 cmsUNUSED_PARAMETER(info);
1782 cmsUNUSED_PARAMETER(Stride);
1783 }
1784
1785 static
1786 cmsUInt8Number* PackLabV2_16(register _cmsTRANSFORM* info,
1787 register cmsUInt16Number wOut[],
1788 register cmsUInt8Number* output,
1789 register cmsUInt32Number Stride)
1790 {
1791 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[0]);
1792 output += 2;
1793 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[1]);
1794 output += 2;
1795 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[2]);
1796 output += 2;
1797
1798 return output;
1799
1800 cmsUNUSED_PARAMETER(info);
1801 cmsUNUSED_PARAMETER(Stride);
1802 }
1803
1804 static
1805 cmsUInt8Number* Pack3Bytes(register _cmsTRANSFORM* info,
1806 register cmsUInt16Number wOut[],
1807 register cmsUInt8Number* output,
1808 register cmsUInt32Number Stride)
1809 {
1810 *output++ = FROM_16_TO_8(wOut[0]);
1811 *output++ = FROM_16_TO_8(wOut[1]);
1812 *output++ = FROM_16_TO_8(wOut[2]);
1813
1814 return output;
1815
1816 cmsUNUSED_PARAMETER(info);
1817 cmsUNUSED_PARAMETER(Stride);
1818 }
1819
1820 static
1821 cmsUInt8Number* Pack3BytesOptimized(register _cmsTRANSFORM* info,
1822 register cmsUInt16Number wOut[],
1823 register cmsUInt8Number* output,
1824 register cmsUInt32Number Stride)
1825 {
1826 *output++ = (wOut[0] & 0xFF);
1827 *output++ = (wOut[1] & 0xFF);
1828 *output++ = (wOut[2] & 0xFF);
1829
1830 return output;
1831
1832 cmsUNUSED_PARAMETER(info);
1833 cmsUNUSED_PARAMETER(Stride);
1834 }
1835
1836 static
1837 cmsUInt8Number* Pack3BytesSwap(register _cmsTRANSFORM* info,
1838 register cmsUInt16Number wOut[],
1839 register cmsUInt8Number* output,
1840 register cmsUInt32Number Stride)
1841 {
1842 *output++ = FROM_16_TO_8(wOut[2]);
1843 *output++ = FROM_16_TO_8(wOut[1]);
1844 *output++ = FROM_16_TO_8(wOut[0]);
1845
1846 return output;
1847
1848 cmsUNUSED_PARAMETER(info);
1849 cmsUNUSED_PARAMETER(Stride);
1850 }
1851
1852 static
1853 cmsUInt8Number* Pack3BytesSwapOptimized(register _cmsTRANSFORM* info,
1854 register cmsUInt16Number wOut[],
1855 register cmsUInt8Number* output,
1856 register cmsUInt32Number Stride)
1857 {
1858 *output++ = (wOut[2] & 0xFF);
1859 *output++ = (wOut[1] & 0xFF);
1860 *output++ = (wOut[0] & 0xFF);
1861
1862 return output;
1863
1864 cmsUNUSED_PARAMETER(info);
1865 cmsUNUSED_PARAMETER(Stride);
1866 }
1867
1868
1869 static
1870 cmsUInt8Number* Pack3Words(register _cmsTRANSFORM* info,
1871 register cmsUInt16Number wOut[],
1872 register cmsUInt8Number* output,
1873 register cmsUInt32Number Stride)
1874 {
1875 *(cmsUInt16Number*) output = wOut[0];
1876 output+= 2;
1877 *(cmsUInt16Number*) output = wOut[1];
1878 output+= 2;
1879 *(cmsUInt16Number*) output = wOut[2];
1880 output+= 2;
1881
1882 return output;
1883
1884 cmsUNUSED_PARAMETER(info);
1885 cmsUNUSED_PARAMETER(Stride);
1886 }
1887
1888 static
1889 cmsUInt8Number* Pack3WordsSwap(register _cmsTRANSFORM* info,
1890 register cmsUInt16Number wOut[],
1891 register cmsUInt8Number* output,
1892 register cmsUInt32Number Stride)
1893 {
1894 *(cmsUInt16Number*) output = wOut[2];
1895 output+= 2;
1896 *(cmsUInt16Number*) output = wOut[1];
1897 output+= 2;
1898 *(cmsUInt16Number*) output = wOut[0];
1899 output+= 2;
1900
1901 return output;
1902
1903 cmsUNUSED_PARAMETER(info);
1904 cmsUNUSED_PARAMETER(Stride);
1905 }
1906
1907 static
1908 cmsUInt8Number* Pack3WordsBigEndian(register _cmsTRANSFORM* info,
1909 register cmsUInt16Number wOut[],
1910 register cmsUInt8Number* output,
1911 register cmsUInt32Number Stride)
1912 {
1913 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1914 output+= 2;
1915 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1916 output+= 2;
1917 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1918 output+= 2;
1919
1920 return output;
1921
1922 cmsUNUSED_PARAMETER(info);
1923 cmsUNUSED_PARAMETER(Stride);
1924 }
1925
1926 static
1927 cmsUInt8Number* Pack3BytesAndSkip1(register _cmsTRANSFORM* info,
1928 register cmsUInt16Number wOut[],
1929 register cmsUInt8Number* output,
1930 register cmsUInt32Number Stride)
1931 {
1932 *output++ = FROM_16_TO_8(wOut[0]);
1933 *output++ = FROM_16_TO_8(wOut[1]);
1934 *output++ = FROM_16_TO_8(wOut[2]);
1935 output++;
1936
1937 return output;
1938
1939 cmsUNUSED_PARAMETER(info);
1940 cmsUNUSED_PARAMETER(Stride);
1941 }
1942
1943 static
1944 cmsUInt8Number* Pack3BytesAndSkip1Optimized(register _cmsTRANSFORM* info,
1945 register cmsUInt16Number wOut[],
1946 register cmsUInt8Number* output,
1947 register cmsUInt32Number Stride)
1948 {
1949 *output++ = (wOut[0] & 0xFF);
1950 *output++ = (wOut[1] & 0xFF);
1951 *output++ = (wOut[2] & 0xFF);
1952 output++;
1953
1954 return output;
1955
1956 cmsUNUSED_PARAMETER(info);
1957 cmsUNUSED_PARAMETER(Stride);
1958 }
1959
1960
1961 static
1962 cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(register _cmsTRANSFORM* info,
1963 register cmsUInt16Number wOut[],
1964 register cmsUInt8Number* output,
1965 register cmsUInt32Number Stride)
1966 {
1967 output++;
1968 *output++ = FROM_16_TO_8(wOut[0]);
1969 *output++ = FROM_16_TO_8(wOut[1]);
1970 *output++ = FROM_16_TO_8(wOut[2]);
1971
1972 return output;
1973
1974 cmsUNUSED_PARAMETER(info);
1975 cmsUNUSED_PARAMETER(Stride);
1976 }
1977
1978 static
1979 cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(register _cmsTRANSFORM* info,
1980 register cmsUInt16Number wOut[],
1981 register cmsUInt8Number* output,
1982 register cmsUInt32Number Stride)
1983 {
1984 output++;
1985 *output++ = (wOut[0] & 0xFF);
1986 *output++ = (wOut[1] & 0xFF);
1987 *output++ = (wOut[2] & 0xFF);
1988
1989 return output;
1990
1991 cmsUNUSED_PARAMETER(info);
1992 cmsUNUSED_PARAMETER(Stride);
1993 }
1994
1995 static
1996 cmsUInt8Number* Pack3BytesAndSkip1Swap(register _cmsTRANSFORM* info,
1997 register cmsUInt16Number wOut[],
1998 register cmsUInt8Number* output,
1999 register cmsUInt32Number Stride)
2000 {
2001 output++;
2002 *output++ = FROM_16_TO_8(wOut[2]);
2003 *output++ = FROM_16_TO_8(wOut[1]);
2004 *output++ = FROM_16_TO_8(wOut[0]);
2005
2006 return output;
2007
2008 cmsUNUSED_PARAMETER(info);
2009 cmsUNUSED_PARAMETER(Stride);
2010 }
2011
2012 static
2013 cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(register _cmsTRANSFORM* info,
2014 register cmsUInt16Number wOut[],
2015 register cmsUInt8Number* output,
2016 register cmsUInt32Number Stride)
2017 {
2018 output++;
2019 *output++ = (wOut[2] & 0xFF);
2020 *output++ = (wOut[1] & 0xFF);
2021 *output++ = (wOut[0] & 0xFF);
2022
2023 return output;
2024
2025 cmsUNUSED_PARAMETER(info);
2026 cmsUNUSED_PARAMETER(Stride);
2027 }
2028
2029
2030 static
2031 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
2032 register cmsUInt16Number wOut[],
2033 register cmsUInt8Number* output,
2034 register cmsUInt32Number Stride)
2035 {
2036 *output++ = FROM_16_TO_8(wOut[2]);
2037 *output++ = FROM_16_TO_8(wOut[1]);
2038 *output++ = FROM_16_TO_8(wOut[0]);
2039 output++;
2040
2041 return output;
2042
2043 cmsUNUSED_PARAMETER(info);
2044 cmsUNUSED_PARAMETER(Stride);
2045 }
2046
2047 static
2048 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(register _cmsTRANSFORM* info,
2049 register cmsUInt16Number wOut[],
2050 register cmsUInt8Number* output,
2051 register cmsUInt32Number Stride)
2052 {
2053 *output++ = (wOut[2] & 0xFF);
2054 *output++ = (wOut[1] & 0xFF);
2055 *output++ = (wOut[0] & 0xFF);
2056 output++;
2057
2058 return output;
2059
2060 cmsUNUSED_PARAMETER(info);
2061 cmsUNUSED_PARAMETER(Stride);
2062 }
2063
2064 static
2065 cmsUInt8Number* Pack3WordsAndSkip1(register _cmsTRANSFORM* info,
2066 register cmsUInt16Number wOut[],
2067 register cmsUInt8Number* output,
2068 register cmsUInt32Number Stride)
2069 {
2070 *(cmsUInt16Number*) output = wOut[0];
2071 output+= 2;
2072 *(cmsUInt16Number*) output = wOut[1];
2073 output+= 2;
2074 *(cmsUInt16Number*) output = wOut[2];
2075 output+= 2;
2076 output+= 2;
2077
2078 return output;
2079
2080 cmsUNUSED_PARAMETER(info);
2081 cmsUNUSED_PARAMETER(Stride);
2082 }
2083
2084 static
2085 cmsUInt8Number* Pack3WordsAndSkip1Swap(register _cmsTRANSFORM* info,
2086 register cmsUInt16Number wOut[],
2087 register cmsUInt8Number* output,
2088 register cmsUInt32Number Stride)
2089 {
2090 output+= 2;
2091 *(cmsUInt16Number*) output = wOut[2];
2092 output+= 2;
2093 *(cmsUInt16Number*) output = wOut[1];
2094 output+= 2;
2095 *(cmsUInt16Number*) output = wOut[0];
2096 output+= 2;
2097
2098 return output;
2099
2100 cmsUNUSED_PARAMETER(info);
2101 cmsUNUSED_PARAMETER(Stride);
2102 }
2103
2104
2105 static
2106 cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(register _cmsTRANSFORM* info,
2107 register cmsUInt16Number wOut[],
2108 register cmsUInt8Number* output,
2109 register cmsUInt32Number Stride)
2110 {
2111 output+= 2;
2112 *(cmsUInt16Number*) output = wOut[0];
2113 output+= 2;
2114 *(cmsUInt16Number*) output = wOut[1];
2115 output+= 2;
2116 *(cmsUInt16Number*) output = wOut[2];
2117 output+= 2;
2118
2119 return output;
2120
2121 cmsUNUSED_PARAMETER(info);
2122 cmsUNUSED_PARAMETER(Stride);
2123 }
2124
2125
2126 static
2127 cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
2128 register cmsUInt16Number wOut[],
2129 register cmsUInt8Number* output,
2130 register cmsUInt32Number Stride)
2131 {
2132 *(cmsUInt16Number*) output = wOut[2];
2133 output+= 2;
2134 *(cmsUInt16Number*) output = wOut[1];
2135 output+= 2;
2136 *(cmsUInt16Number*) output = wOut[0];
2137 output+= 2;
2138 output+= 2;
2139
2140 return output;
2141
2142 cmsUNUSED_PARAMETER(info);
2143 cmsUNUSED_PARAMETER(Stride);
2144 }
2145
2146
2147
2148 static
2149 cmsUInt8Number* Pack1Byte(register _cmsTRANSFORM* info,
2150 register cmsUInt16Number wOut[],
2151 register cmsUInt8Number* output,
2152 register cmsUInt32Number Stride)
2153 {
2154 *output++ = FROM_16_TO_8(wOut[0]);
2155
2156 return output;
2157
2158 cmsUNUSED_PARAMETER(info);
2159 cmsUNUSED_PARAMETER(Stride);
2160 }
2161
2162
2163 static
2164 cmsUInt8Number* Pack1ByteReversed(register _cmsTRANSFORM* info,
2165 register cmsUInt16Number wOut[],
2166 register cmsUInt8Number* output,
2167 register cmsUInt32Number Stride)
2168 {
2169 *output++ = FROM_16_TO_8(REVERSE_FLAVOR_16(wOut[0]));
2170
2171 return output;
2172
2173 cmsUNUSED_PARAMETER(info);
2174 cmsUNUSED_PARAMETER(Stride);
2175 }
2176
2177
2178 static
2179 cmsUInt8Number* Pack1ByteSkip1(register _cmsTRANSFORM* info,
2180 register cmsUInt16Number wOut[],
2181 register cmsUInt8Number* output,
2182 register cmsUInt32Number Stride)
2183 {
2184 *output++ = FROM_16_TO_8(wOut[0]);
2185 output++;
2186
2187 return output;
2188
2189 cmsUNUSED_PARAMETER(info);
2190 cmsUNUSED_PARAMETER(Stride);
2191 }
2192
2193
2194 static
2195 cmsUInt8Number* Pack1ByteSkip1SwapFirst(register _cmsTRANSFORM* info,
2196 register cmsUInt16Number wOut[],
2197 register cmsUInt8Number* output,
2198 register cmsUInt32Number Stride)
2199 {
2200 output++;
2201 *output++ = FROM_16_TO_8(wOut[0]);
2202
2203 return output;
2204
2205 cmsUNUSED_PARAMETER(info);
2206 cmsUNUSED_PARAMETER(Stride);
2207 }
2208
2209 static
2210 cmsUInt8Number* Pack1Word(register _cmsTRANSFORM* info,
2211 register cmsUInt16Number wOut[],
2212 register cmsUInt8Number* output,
2213 register cmsUInt32Number Stride)
2214 {
2215 *(cmsUInt16Number*) output = wOut[0];
2216 output+= 2;
2217
2218 return output;
2219
2220 cmsUNUSED_PARAMETER(info);
2221 cmsUNUSED_PARAMETER(Stride);
2222 }
2223
2224
2225 static
2226 cmsUInt8Number* Pack1WordReversed(register _cmsTRANSFORM* info,
2227 register cmsUInt16Number wOut[],
2228 register cmsUInt8Number* output,
2229 register cmsUInt32Number Stride)
2230 {
2231 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
2232 output+= 2;
2233
2234 return output;
2235
2236 cmsUNUSED_PARAMETER(info);
2237 cmsUNUSED_PARAMETER(Stride);
2238 }
2239
2240 static
2241 cmsUInt8Number* Pack1WordBigEndian(register _cmsTRANSFORM* info,
2242 register cmsUInt16Number wOut[],
2243 register cmsUInt8Number* output,
2244 register cmsUInt32Number Stride)
2245 {
2246 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
2247 output+= 2;
2248
2249 return output;
2250
2251 cmsUNUSED_PARAMETER(info);
2252 cmsUNUSED_PARAMETER(Stride);
2253 }
2254
2255
2256 static
2257 cmsUInt8Number* Pack1WordSkip1(register _cmsTRANSFORM* info,
2258 register cmsUInt16Number wOut[],
2259 register cmsUInt8Number* output,
2260 register cmsUInt32Number Stride)
2261 {
2262 *(cmsUInt16Number*) output = wOut[0];
2263 output+= 4;
2264
2265 return output;
2266
2267 cmsUNUSED_PARAMETER(info);
2268 cmsUNUSED_PARAMETER(Stride);
2269 }
2270
2271 static
2272 cmsUInt8Number* Pack1WordSkip1SwapFirst(register _cmsTRANSFORM* info,
2273 register cmsUInt16Number wOut[],
2274 register cmsUInt8Number* output,
2275 register cmsUInt32Number Stride)
2276 {
2277 output += 2;
2278 *(cmsUInt16Number*) output = wOut[0];
2279 output+= 2;
2280
2281 return output;
2282
2283 cmsUNUSED_PARAMETER(info);
2284 cmsUNUSED_PARAMETER(Stride);
2285 }
2286
2287
2288 // Unencoded Float values -- don't try optimize speed
2289 static
2290 cmsUInt8Number* PackLabDoubleFrom16(register _cmsTRANSFORM* info,
2291 register cmsUInt16Number wOut[],
2292 register cmsUInt8Number* output,
2293 register cmsUInt32Number Stride)
2294 {
2295
2296 if (T_PLANAR(info -> OutputFormat)) {
2297
2298 cmsCIELab Lab;
2299 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2300 cmsLabEncoded2Float(&Lab, wOut);
2301
2302 Out[0] = Lab.L;
2303 Out[Stride] = Lab.a;
2304 Out[Stride*2] = Lab.b;
|
142 for (i=0; i < nChan; i++) {
143 int 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 cmsUNUSED_PARAMETER(info);
163 cmsUNUSED_PARAMETER(Stride);
164
165 return accum;
166
167
168 }
169
170 // Extra channels are just ignored because come in the next planes
171 static
172 cmsUInt8Number* UnrollPlanarBytes(register _cmsTRANSFORM* info,
173 register cmsUInt16Number wIn[],
174 register cmsUInt8Number* accum,
175 register cmsUInt32Number Stride)
176 {
177 int nChan = T_CHANNELS(info -> InputFormat);
178 int DoSwap = T_DOSWAP(info ->InputFormat);
179 int SwapFirst = T_SWAPFIRST(info ->InputFormat);
180 int Reverse = T_FLAVOR(info ->InputFormat);
181 int i;
182 cmsUInt8Number* Init = accum;
183
184 if (DoSwap ^ SwapFirst) {
185 accum += T_EXTRA(info -> InputFormat) * Stride;
186 }
187
192
193 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
194 accum += Stride;
195 }
196
197 return (Init + 1);
198 }
199
200 // Special cases, provided for performance
201 static
202 cmsUInt8Number* Unroll4Bytes(register _cmsTRANSFORM* info,
203 register cmsUInt16Number wIn[],
204 register cmsUInt8Number* accum,
205 register cmsUInt32Number Stride)
206 {
207 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
208 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
209 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
210 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
211
212 cmsUNUSED_PARAMETER(info);
213 cmsUNUSED_PARAMETER(Stride);
214
215 return accum;
216
217 }
218
219 static
220 cmsUInt8Number* Unroll4BytesReverse(register _cmsTRANSFORM* info,
221 register cmsUInt16Number wIn[],
222 register cmsUInt8Number* accum,
223 register cmsUInt32Number Stride)
224 {
225 wIn[0] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // C
226 wIn[1] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // M
227 wIn[2] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // Y
228 wIn[3] = FROM_8_TO_16(REVERSE_FLAVOR_8(*accum)); accum++; // K
229
230 cmsUNUSED_PARAMETER(info);
231 cmsUNUSED_PARAMETER(Stride);
232
233 return accum;
234
235 }
236
237 static
238 cmsUInt8Number* Unroll4BytesSwapFirst(register _cmsTRANSFORM* info,
239 register cmsUInt16Number wIn[],
240 register cmsUInt8Number* accum,
241 register cmsUInt32Number Stride)
242 {
243 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
244 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
245 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
246 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
247
248 cmsUNUSED_PARAMETER(info);
249 cmsUNUSED_PARAMETER(Stride);
250
251 return accum;
252
253 }
254
255 // KYMC
256 static
257 cmsUInt8Number* Unroll4BytesSwap(register _cmsTRANSFORM* info,
258 register cmsUInt16Number wIn[],
259 register cmsUInt8Number* accum,
260 register cmsUInt32Number Stride)
261 {
262 wIn[3] = FROM_8_TO_16(*accum); accum++; // K
263 wIn[2] = FROM_8_TO_16(*accum); accum++; // Y
264 wIn[1] = FROM_8_TO_16(*accum); accum++; // M
265 wIn[0] = FROM_8_TO_16(*accum); accum++; // C
266
267 cmsUNUSED_PARAMETER(info);
268 cmsUNUSED_PARAMETER(Stride);
269
270 return accum;
271
272 }
273
274 static
275 cmsUInt8Number* Unroll4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
276 register cmsUInt16Number wIn[],
277 register cmsUInt8Number* accum,
278 register cmsUInt32Number Stride)
279 {
280 wIn[2] = FROM_8_TO_16(*accum); accum++; // K
281 wIn[1] = FROM_8_TO_16(*accum); accum++; // Y
282 wIn[0] = FROM_8_TO_16(*accum); accum++; // M
283 wIn[3] = FROM_8_TO_16(*accum); accum++; // C
284
285 cmsUNUSED_PARAMETER(info);
286 cmsUNUSED_PARAMETER(Stride);
287
288 return accum;
289
290 }
291
292 static
293 cmsUInt8Number* Unroll3Bytes(register _cmsTRANSFORM* info,
294 register cmsUInt16Number wIn[],
295 register cmsUInt8Number* accum,
296 register cmsUInt32Number Stride)
297 {
298 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
299 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
300 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
301
302 cmsUNUSED_PARAMETER(info);
303 cmsUNUSED_PARAMETER(Stride);
304
305 return accum;
306
307 }
308
309 static
310 cmsUInt8Number* Unroll3BytesSkip1Swap(register _cmsTRANSFORM* info,
311 register cmsUInt16Number wIn[],
312 register cmsUInt8Number* accum,
313 register cmsUInt32Number Stride)
314 {
315 accum++; // A
316 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
317 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
318 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
319
320 cmsUNUSED_PARAMETER(info);
321 cmsUNUSED_PARAMETER(Stride);
322
323 return accum;
324
325 }
326
327 static
328 cmsUInt8Number* Unroll3BytesSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
329 register cmsUInt16Number wIn[],
330 register cmsUInt8Number* accum,
331 register cmsUInt32Number Stride)
332 {
333 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
334 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
335 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
336 accum++; // A
337
338 cmsUNUSED_PARAMETER(info);
339 cmsUNUSED_PARAMETER(Stride);
340
341 return accum;
342
343 }
344
345 static
346 cmsUInt8Number* Unroll3BytesSkip1SwapFirst(register _cmsTRANSFORM* info,
347 register cmsUInt16Number wIn[],
348 register cmsUInt8Number* accum,
349 register cmsUInt32Number Stride)
350 {
351 accum++; // A
352 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
353 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
354 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
355
356 cmsUNUSED_PARAMETER(info);
357 cmsUNUSED_PARAMETER(Stride);
358
359 return accum;
360
361 }
362
363
364 // BRG
365 static
366 cmsUInt8Number* Unroll3BytesSwap(register _cmsTRANSFORM* info,
367 register cmsUInt16Number wIn[],
368 register cmsUInt8Number* accum,
369 register cmsUInt32Number Stride)
370 {
371 wIn[2] = FROM_8_TO_16(*accum); accum++; // B
372 wIn[1] = FROM_8_TO_16(*accum); accum++; // G
373 wIn[0] = FROM_8_TO_16(*accum); accum++; // R
374
375 cmsUNUSED_PARAMETER(info);
376 cmsUNUSED_PARAMETER(Stride);
377
378 return accum;
379
380 }
381
382 static
383 cmsUInt8Number* UnrollLabV2_8(register _cmsTRANSFORM* info,
384 register cmsUInt16Number wIn[],
385 register cmsUInt8Number* accum,
386 register cmsUInt32Number Stride)
387 {
388 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L
389 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a
390 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
391
392 cmsUNUSED_PARAMETER(info);
393 cmsUNUSED_PARAMETER(Stride);
394
395 return accum;
396
397 }
398
399 static
400 cmsUInt8Number* UnrollALabV2_8(register _cmsTRANSFORM* info,
401 register cmsUInt16Number wIn[],
402 register cmsUInt8Number* accum,
403 register cmsUInt32Number Stride)
404 {
405 accum++; // A
406 wIn[0] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // L
407 wIn[1] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // a
408 wIn[2] = FomLabV2ToLabV4(FROM_8_TO_16(*accum)); accum++; // b
409
410 cmsUNUSED_PARAMETER(info);
411 cmsUNUSED_PARAMETER(Stride);
412
413 return accum;
414
415 }
416
417 static
418 cmsUInt8Number* UnrollLabV2_16(register _cmsTRANSFORM* info,
419 register cmsUInt16Number wIn[],
420 register cmsUInt8Number* accum,
421 register cmsUInt32Number Stride)
422 {
423 wIn[0] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // L
424 wIn[1] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // a
425 wIn[2] = FomLabV2ToLabV4(*(cmsUInt16Number*) accum); accum += 2; // b
426
427 cmsUNUSED_PARAMETER(info);
428 cmsUNUSED_PARAMETER(Stride);
429
430 return accum;
431
432 }
433
434 // for duplex
435 static
436 cmsUInt8Number* Unroll2Bytes(register _cmsTRANSFORM* info,
437 register cmsUInt16Number wIn[],
438 register cmsUInt8Number* accum,
439 register cmsUInt32Number Stride)
440 {
441 wIn[0] = FROM_8_TO_16(*accum); accum++; // ch1
442 wIn[1] = FROM_8_TO_16(*accum); accum++; // ch2
443
444 cmsUNUSED_PARAMETER(info);
445 cmsUNUSED_PARAMETER(Stride);
446
447 return accum;
448
449 }
450
451
452
453
454 // Monochrome duplicates L into RGB for null-transforms
455 static
456 cmsUInt8Number* Unroll1Byte(register _cmsTRANSFORM* info,
457 register cmsUInt16Number wIn[],
458 register cmsUInt8Number* accum,
459 register cmsUInt32Number Stride)
460 {
461 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
462
463 cmsUNUSED_PARAMETER(info);
464 cmsUNUSED_PARAMETER(Stride);
465
466 return accum;
467
468 }
469
470
471 static
472 cmsUInt8Number* Unroll1ByteSkip1(register _cmsTRANSFORM* info,
473 register cmsUInt16Number wIn[],
474 register cmsUInt8Number* accum,
475 register cmsUInt32Number Stride)
476 {
477 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
478 accum += 1;
479
480 cmsUNUSED_PARAMETER(info);
481 cmsUNUSED_PARAMETER(Stride);
482
483 return accum;
484
485 }
486
487 static
488 cmsUInt8Number* Unroll1ByteSkip2(register _cmsTRANSFORM* info,
489 register cmsUInt16Number wIn[],
490 register cmsUInt8Number* accum,
491 register cmsUInt32Number Stride)
492 {
493 wIn[0] = wIn[1] = wIn[2] = FROM_8_TO_16(*accum); accum++; // L
494 accum += 2;
495
496 cmsUNUSED_PARAMETER(info);
497 cmsUNUSED_PARAMETER(Stride);
498
499 return accum;
500
501 }
502
503 static
504 cmsUInt8Number* Unroll1ByteReversed(register _cmsTRANSFORM* info,
505 register cmsUInt16Number wIn[],
506 register cmsUInt8Number* accum,
507 register cmsUInt32Number Stride)
508 {
509 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(FROM_8_TO_16(*accum)); accum++; // L
510
511 cmsUNUSED_PARAMETER(info);
512 cmsUNUSED_PARAMETER(Stride);
513
514 return accum;
515
516 }
517
518
519 static
520 cmsUInt8Number* UnrollAnyWords(register _cmsTRANSFORM* info,
521 register cmsUInt16Number wIn[],
522 register cmsUInt8Number* accum,
523 register cmsUInt32Number Stride)
524 {
525 int nChan = T_CHANNELS(info -> InputFormat);
526 int SwapEndian = T_ENDIAN16(info -> InputFormat);
527 int DoSwap = T_DOSWAP(info ->InputFormat);
528 int Reverse = T_FLAVOR(info ->InputFormat);
529 int SwapFirst = T_SWAPFIRST(info -> InputFormat);
530 int Extra = T_EXTRA(info -> InputFormat);
531 int ExtraFirst = DoSwap ^ SwapFirst;
532 int i;
533
534 if (ExtraFirst) {
535 accum += Extra * sizeof(cmsUInt16Number);
543 if (SwapEndian)
544 v = CHANGE_ENDIAN(v);
545
546 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
547
548 accum += sizeof(cmsUInt16Number);
549 }
550
551 if (!ExtraFirst) {
552 accum += Extra * sizeof(cmsUInt16Number);
553 }
554
555 if (Extra == 0 && SwapFirst) {
556
557 cmsUInt16Number tmp = wIn[0];
558
559 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsUInt16Number));
560 wIn[nChan-1] = tmp;
561 }
562
563 cmsUNUSED_PARAMETER(Stride);
564
565 return accum;
566
567 }
568
569 static
570 cmsUInt8Number* UnrollPlanarWords(register _cmsTRANSFORM* info,
571 register cmsUInt16Number wIn[],
572 register cmsUInt8Number* accum,
573 register cmsUInt32Number Stride)
574 {
575 int nChan = T_CHANNELS(info -> InputFormat);
576 int DoSwap= T_DOSWAP(info ->InputFormat);
577 int Reverse= T_FLAVOR(info ->InputFormat);
578 int SwapEndian = T_ENDIAN16(info -> InputFormat);
579 int i;
580 cmsUInt8Number* Init = accum;
581
582 if (DoSwap) {
583 accum += T_EXTRA(info -> InputFormat) * Stride * sizeof(cmsUInt16Number);
584 }
585
586 for (i=0; i < nChan; i++) {
594 wIn[index] = Reverse ? REVERSE_FLAVOR_16(v) : v;
595
596 accum += Stride * sizeof(cmsUInt16Number);
597 }
598
599 return (Init + sizeof(cmsUInt16Number));
600 }
601
602
603 static
604 cmsUInt8Number* Unroll4Words(register _cmsTRANSFORM* info,
605 register cmsUInt16Number wIn[],
606 register cmsUInt8Number* accum,
607 register cmsUInt32Number Stride)
608 {
609 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
610 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
611 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
612 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
613
614 cmsUNUSED_PARAMETER(info);
615 cmsUNUSED_PARAMETER(Stride);
616
617 return accum;
618
619 }
620
621 static
622 cmsUInt8Number* Unroll4WordsReverse(register _cmsTRANSFORM* info,
623 register cmsUInt16Number wIn[],
624 register cmsUInt8Number* accum,
625 register cmsUInt32Number Stride)
626 {
627 wIn[0] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // C
628 wIn[1] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // M
629 wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // Y
630 wIn[3] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2; // K
631
632 cmsUNUSED_PARAMETER(info);
633 cmsUNUSED_PARAMETER(Stride);
634
635 return accum;
636
637 }
638
639 static
640 cmsUInt8Number* Unroll4WordsSwapFirst(register _cmsTRANSFORM* info,
641 register cmsUInt16Number wIn[],
642 register cmsUInt8Number* accum,
643 register cmsUInt32Number Stride)
644 {
645 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
646 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
647 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
648 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
649
650 cmsUNUSED_PARAMETER(info);
651 cmsUNUSED_PARAMETER(Stride);
652
653 return accum;
654
655 }
656
657 // KYMC
658 static
659 cmsUInt8Number* Unroll4WordsSwap(register _cmsTRANSFORM* info,
660 register cmsUInt16Number wIn[],
661 register cmsUInt8Number* accum,
662 register cmsUInt32Number Stride)
663 {
664 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // K
665 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y
666 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M
667 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C
668
669 cmsUNUSED_PARAMETER(info);
670 cmsUNUSED_PARAMETER(Stride);
671
672 return accum;
673
674 }
675
676 static
677 cmsUInt8Number* Unroll4WordsSwapSwapFirst(register _cmsTRANSFORM* info,
678 register cmsUInt16Number wIn[],
679 register cmsUInt8Number* accum,
680 register cmsUInt32Number Stride)
681 {
682 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // K
683 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // Y
684 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // M
685 wIn[3] = *(cmsUInt16Number*) accum; accum+= 2; // C
686
687 cmsUNUSED_PARAMETER(info);
688 cmsUNUSED_PARAMETER(Stride);
689
690 return accum;
691
692 }
693
694 static
695 cmsUInt8Number* Unroll3Words(register _cmsTRANSFORM* info,
696 register cmsUInt16Number wIn[],
697 register cmsUInt8Number* accum,
698 register cmsUInt32Number Stride)
699 {
700 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // C R
701 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
702 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
703
704 cmsUNUSED_PARAMETER(info);
705 cmsUNUSED_PARAMETER(Stride);
706
707 return accum;
708
709 }
710
711 static
712 cmsUInt8Number* Unroll3WordsSwap(register _cmsTRANSFORM* info,
713 register cmsUInt16Number wIn[],
714 register cmsUInt8Number* accum,
715 register cmsUInt32Number Stride)
716 {
717 wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // C R
718 wIn[1] = *(cmsUInt16Number*) accum; accum+= 2; // M G
719 wIn[0] = *(cmsUInt16Number*) accum; accum+= 2; // Y B
720
721 cmsUNUSED_PARAMETER(info);
722 cmsUNUSED_PARAMETER(Stride);
723
724 return accum;
725
726 }
727
728 static
729 cmsUInt8Number* Unroll3WordsSkip1Swap(register _cmsTRANSFORM* info,
730 register cmsUInt16Number wIn[],
731 register cmsUInt8Number* accum,
732 register cmsUInt32Number Stride)
733 {
734 accum += 2; // A
735 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // R
736 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G
737 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // B
738
739 cmsUNUSED_PARAMETER(info);
740 cmsUNUSED_PARAMETER(Stride);
741
742 return accum;
743
744 }
745
746 static
747 cmsUInt8Number* Unroll3WordsSkip1SwapFirst(register _cmsTRANSFORM* info,
748 register cmsUInt16Number wIn[],
749 register cmsUInt8Number* accum,
750 register cmsUInt32Number Stride)
751 {
752 accum += 2; // A
753 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // R
754 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // G
755 wIn[2] = *(cmsUInt16Number*) accum; accum += 2; // B
756
757 cmsUNUSED_PARAMETER(info);
758 cmsUNUSED_PARAMETER(Stride);
759
760 return accum;
761
762 }
763
764 static
765 cmsUInt8Number* Unroll1Word(register _cmsTRANSFORM* info,
766 register cmsUInt16Number wIn[],
767 register cmsUInt8Number* accum,
768 register cmsUInt32Number Stride)
769 {
770 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum; accum+= 2; // L
771
772 cmsUNUSED_PARAMETER(info);
773 cmsUNUSED_PARAMETER(Stride);
774
775 return accum;
776
777 }
778
779 static
780 cmsUInt8Number* Unroll1WordReversed(register _cmsTRANSFORM* info,
781 register cmsUInt16Number wIn[],
782 register cmsUInt8Number* accum,
783 register cmsUInt32Number Stride)
784 {
785 wIn[0] = wIn[1] = wIn[2] = REVERSE_FLAVOR_16(*(cmsUInt16Number*) accum); accum+= 2;
786
787 cmsUNUSED_PARAMETER(info);
788 cmsUNUSED_PARAMETER(Stride);
789
790 return accum;
791
792 }
793
794 static
795 cmsUInt8Number* Unroll1WordSkip3(register _cmsTRANSFORM* info,
796 register cmsUInt16Number wIn[],
797 register cmsUInt8Number* accum,
798 register cmsUInt32Number Stride)
799 {
800 wIn[0] = wIn[1] = wIn[2] = *(cmsUInt16Number*) accum;
801
802 accum += 8;
803
804 cmsUNUSED_PARAMETER(info);
805 cmsUNUSED_PARAMETER(Stride);
806
807 return accum;
808
809 }
810
811 static
812 cmsUInt8Number* Unroll2Words(register _cmsTRANSFORM* info,
813 register cmsUInt16Number wIn[],
814 register cmsUInt8Number* accum,
815 register cmsUInt32Number Stride)
816 {
817 wIn[0] = *(cmsUInt16Number*) accum; accum += 2; // ch1
818 wIn[1] = *(cmsUInt16Number*) accum; accum += 2; // ch2
819
820 cmsUNUSED_PARAMETER(info);
821 cmsUNUSED_PARAMETER(Stride);
822
823 return accum;
824
825 }
826
827
828 // This is a conversion of Lab double to 16 bits
829 static
830 cmsUInt8Number* UnrollLabDoubleTo16(register _cmsTRANSFORM* info,
831 register cmsUInt16Number wIn[],
832 register cmsUInt8Number* accum,
833 register cmsUInt32Number Stride)
834 {
835 if (T_PLANAR(info -> InputFormat)) {
836
837 cmsFloat64Number* Pt = (cmsFloat64Number*) accum;
838
839 cmsCIELab Lab;
840
841 Lab.L = Pt[0];
842 Lab.a = Pt[Stride];
843 Lab.b = Pt[Stride*2];
844
1083 if (T_PLANAR(info -> InputFormat))
1084 return accum + sizeof(cmsFloat32Number);
1085 else
1086 return accum + (nChan + Extra) * sizeof(cmsFloat32Number);
1087 }
1088
1089
1090
1091
1092 // For 1 channel, we need to duplicate data (it comes in 0..1.0 range)
1093 static
1094 cmsUInt8Number* UnrollDouble1Chan(register _cmsTRANSFORM* info,
1095 register cmsUInt16Number wIn[],
1096 register cmsUInt8Number* accum,
1097 register cmsUInt32Number Stride)
1098 {
1099 cmsFloat64Number* Inks = (cmsFloat64Number*) accum;
1100
1101 wIn[0] = wIn[1] = wIn[2] = _cmsQuickSaturateWord(Inks[0] * 65535.0);
1102
1103 cmsUNUSED_PARAMETER(info);
1104 cmsUNUSED_PARAMETER(Stride);
1105
1106 return accum + sizeof(cmsFloat64Number);
1107
1108 }
1109
1110 //-------------------------------------------------------------------------------------------------------------------
1111
1112 // For anything going from cmsFloat32Number
1113 static
1114 cmsUInt8Number* UnrollFloatsToFloat(_cmsTRANSFORM* info,
1115 cmsFloat32Number wIn[],
1116 cmsUInt8Number* accum,
1117 cmsUInt32Number Stride)
1118 {
1119
1120 int nChan = T_CHANNELS(info -> InputFormat);
1121 int DoSwap = T_DOSWAP(info ->InputFormat);
1122 int Reverse = T_FLAVOR(info ->InputFormat);
1123 int SwapFirst = T_SWAPFIRST(info -> InputFormat);
1124 int Extra = T_EXTRA(info -> InputFormat);
1125 int ExtraFirst = DoSwap ^ SwapFirst;
1126 int Planar = T_PLANAR(info -> InputFormat);
1127 cmsFloat32Number v;
1361 int index = DoSwap ? (nChan - i - 1) : i;
1362
1363 v = FROM_16_TO_8(wOut[index]);
1364
1365 if (Reverse)
1366 v = REVERSE_FLAVOR_8(v);
1367
1368 *output++ = v;
1369 }
1370
1371 if (!ExtraFirst) {
1372 output += Extra;
1373 }
1374
1375 if (Extra == 0 && SwapFirst) {
1376
1377 memmove(swap1 + 1, swap1, nChan-1);
1378 *swap1 = v;
1379 }
1380
1381 cmsUNUSED_PARAMETER(Stride);
1382
1383 return output;
1384
1385 }
1386
1387
1388
1389 static
1390 cmsUInt8Number* PackAnyWords(register _cmsTRANSFORM* info,
1391 register cmsUInt16Number wOut[],
1392 register cmsUInt8Number* output,
1393 register cmsUInt32Number Stride)
1394 {
1395 int nChan = T_CHANNELS(info -> OutputFormat);
1396 int SwapEndian = T_ENDIAN16(info -> InputFormat);
1397 int DoSwap = T_DOSWAP(info ->OutputFormat);
1398 int Reverse = T_FLAVOR(info ->OutputFormat);
1399 int Extra = T_EXTRA(info -> OutputFormat);
1400 int SwapFirst = T_SWAPFIRST(info -> OutputFormat);
1401 int ExtraFirst = DoSwap ^ SwapFirst;
1402 cmsUInt16Number* swap1;
1403 cmsUInt16Number v = 0;
1404 int i;
1419 v = CHANGE_ENDIAN(v);
1420
1421 if (Reverse)
1422 v = REVERSE_FLAVOR_16(v);
1423
1424 *(cmsUInt16Number*) output = v;
1425
1426 output += sizeof(cmsUInt16Number);
1427 }
1428
1429 if (!ExtraFirst) {
1430 output += Extra * sizeof(cmsUInt16Number);
1431 }
1432
1433 if (Extra == 0 && SwapFirst) {
1434
1435 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number));
1436 *swap1 = v;
1437 }
1438
1439 cmsUNUSED_PARAMETER(Stride);
1440
1441 return output;
1442
1443 }
1444
1445
1446 static
1447 cmsUInt8Number* PackPlanarBytes(register _cmsTRANSFORM* info,
1448 register cmsUInt16Number wOut[],
1449 register cmsUInt8Number* output,
1450 register cmsUInt32Number Stride)
1451 {
1452 int nChan = T_CHANNELS(info -> OutputFormat);
1453 int DoSwap = T_DOSWAP(info ->OutputFormat);
1454 int SwapFirst = T_SWAPFIRST(info ->OutputFormat);
1455 int Reverse = T_FLAVOR(info ->OutputFormat);
1456 int i;
1457 cmsUInt8Number* Init = output;
1458
1459
1460 if (DoSwap ^ SwapFirst) {
1461 output += T_EXTRA(info -> OutputFormat) * Stride;
1462 }
1463
1464
1465 for (i=0; i < nChan; i++) {
1466
1467 int index = DoSwap ? (nChan - i - 1) : i;
1468 cmsUInt8Number v = FROM_16_TO_8(wOut[index]);
1469
1470 *(cmsUInt8Number*) output = (cmsUInt8Number) (Reverse ? REVERSE_FLAVOR_8(v) : v);
1471 output += Stride;
1472 }
1473
1474 cmsUNUSED_PARAMETER(Stride);
1475
1476 return (Init + 1);
1477
1478 }
1479
1480
1481 static
1482 cmsUInt8Number* PackPlanarWords(register _cmsTRANSFORM* info,
1483 register cmsUInt16Number wOut[],
1484 register cmsUInt8Number* output,
1485 register cmsUInt32Number Stride)
1486 {
1487 int nChan = T_CHANNELS(info -> OutputFormat);
1488 int DoSwap = T_DOSWAP(info ->OutputFormat);
1489 int Reverse= T_FLAVOR(info ->OutputFormat);
1490 int SwapEndian = T_ENDIAN16(info -> OutputFormat);
1491 int i;
1492 cmsUInt8Number* Init = output;
1493 cmsUInt16Number v;
1494
1495 if (DoSwap) {
1496 output += T_EXTRA(info -> OutputFormat) * Stride * sizeof(cmsUInt16Number);
1497 }
1513 }
1514
1515 return (Init + sizeof(cmsUInt16Number));
1516 }
1517
1518 // CMYKcm (unrolled for speed)
1519
1520 static
1521 cmsUInt8Number* Pack6Bytes(register _cmsTRANSFORM* info,
1522 register cmsUInt16Number wOut[],
1523 register cmsUInt8Number* output,
1524 register cmsUInt32Number Stride)
1525 {
1526 *output++ = FROM_16_TO_8(wOut[0]);
1527 *output++ = FROM_16_TO_8(wOut[1]);
1528 *output++ = FROM_16_TO_8(wOut[2]);
1529 *output++ = FROM_16_TO_8(wOut[3]);
1530 *output++ = FROM_16_TO_8(wOut[4]);
1531 *output++ = FROM_16_TO_8(wOut[5]);
1532
1533 cmsUNUSED_PARAMETER(info);
1534 cmsUNUSED_PARAMETER(Stride);
1535
1536 return output;
1537
1538 }
1539
1540 // KCMYcm
1541
1542 static
1543 cmsUInt8Number* Pack6BytesSwap(register _cmsTRANSFORM* info,
1544 register cmsUInt16Number wOut[],
1545 register cmsUInt8Number* output,
1546 register cmsUInt32Number Stride)
1547 {
1548 *output++ = FROM_16_TO_8(wOut[5]);
1549 *output++ = FROM_16_TO_8(wOut[4]);
1550 *output++ = FROM_16_TO_8(wOut[3]);
1551 *output++ = FROM_16_TO_8(wOut[2]);
1552 *output++ = FROM_16_TO_8(wOut[1]);
1553 *output++ = FROM_16_TO_8(wOut[0]);
1554
1555 cmsUNUSED_PARAMETER(info);
1556 cmsUNUSED_PARAMETER(Stride);
1557
1558 return output;
1559
1560 }
1561
1562 // CMYKcm
1563 static
1564 cmsUInt8Number* Pack6Words(register _cmsTRANSFORM* info,
1565 register cmsUInt16Number wOut[],
1566 register cmsUInt8Number* output,
1567 register cmsUInt32Number Stride)
1568 {
1569 *(cmsUInt16Number*) output = wOut[0];
1570 output+= 2;
1571 *(cmsUInt16Number*) output = wOut[1];
1572 output+= 2;
1573 *(cmsUInt16Number*) output = wOut[2];
1574 output+= 2;
1575 *(cmsUInt16Number*) output = wOut[3];
1576 output+= 2;
1577 *(cmsUInt16Number*) output = wOut[4];
1578 output+= 2;
1579 *(cmsUInt16Number*) output = wOut[5];
1580 output+= 2;
1581
1582 cmsUNUSED_PARAMETER(info);
1583 cmsUNUSED_PARAMETER(Stride);
1584
1585 return output;
1586
1587 }
1588
1589 // KCMYcm
1590 static
1591 cmsUInt8Number* Pack6WordsSwap(register _cmsTRANSFORM* info,
1592 register cmsUInt16Number wOut[],
1593 register cmsUInt8Number* output,
1594 register cmsUInt32Number Stride)
1595 {
1596 *(cmsUInt16Number*) output = wOut[5];
1597 output+= 2;
1598 *(cmsUInt16Number*) output = wOut[4];
1599 output+= 2;
1600 *(cmsUInt16Number*) output = wOut[3];
1601 output+= 2;
1602 *(cmsUInt16Number*) output = wOut[2];
1603 output+= 2;
1604 *(cmsUInt16Number*) output = wOut[1];
1605 output+= 2;
1606 *(cmsUInt16Number*) output = wOut[0];
1607 output+= 2;
1608
1609 cmsUNUSED_PARAMETER(info);
1610 cmsUNUSED_PARAMETER(Stride);
1611
1612 return output;
1613
1614 }
1615
1616
1617 static
1618 cmsUInt8Number* Pack4Bytes(register _cmsTRANSFORM* info,
1619 register cmsUInt16Number wOut[],
1620 register cmsUInt8Number* output,
1621 register cmsUInt32Number Stride)
1622 {
1623 *output++ = FROM_16_TO_8(wOut[0]);
1624 *output++ = FROM_16_TO_8(wOut[1]);
1625 *output++ = FROM_16_TO_8(wOut[2]);
1626 *output++ = FROM_16_TO_8(wOut[3]);
1627
1628 cmsUNUSED_PARAMETER(info);
1629 cmsUNUSED_PARAMETER(Stride);
1630
1631 return output;
1632
1633 }
1634
1635 static
1636 cmsUInt8Number* Pack4BytesReverse(register _cmsTRANSFORM* info,
1637 register cmsUInt16Number wOut[],
1638 register cmsUInt8Number* output,
1639 register cmsUInt32Number Stride)
1640 {
1641 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[0]));
1642 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[1]));
1643 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[2]));
1644 *output++ = REVERSE_FLAVOR_8(FROM_16_TO_8(wOut[3]));
1645
1646 cmsUNUSED_PARAMETER(info);
1647 cmsUNUSED_PARAMETER(Stride);
1648
1649 return output;
1650
1651 }
1652
1653
1654 static
1655 cmsUInt8Number* Pack4BytesSwapFirst(register _cmsTRANSFORM* info,
1656 register cmsUInt16Number wOut[],
1657 register cmsUInt8Number* output,
1658 register cmsUInt32Number Stride)
1659 {
1660 *output++ = FROM_16_TO_8(wOut[3]);
1661 *output++ = FROM_16_TO_8(wOut[0]);
1662 *output++ = FROM_16_TO_8(wOut[1]);
1663 *output++ = FROM_16_TO_8(wOut[2]);
1664
1665 cmsUNUSED_PARAMETER(info);
1666 cmsUNUSED_PARAMETER(Stride);
1667
1668 return output;
1669
1670 }
1671
1672 // ABGR
1673 static
1674 cmsUInt8Number* Pack4BytesSwap(register _cmsTRANSFORM* info,
1675 register cmsUInt16Number wOut[],
1676 register cmsUInt8Number* output,
1677 register cmsUInt32Number Stride)
1678 {
1679 *output++ = FROM_16_TO_8(wOut[3]);
1680 *output++ = FROM_16_TO_8(wOut[2]);
1681 *output++ = FROM_16_TO_8(wOut[1]);
1682 *output++ = FROM_16_TO_8(wOut[0]);
1683
1684 cmsUNUSED_PARAMETER(info);
1685 cmsUNUSED_PARAMETER(Stride);
1686
1687 return output;
1688
1689 }
1690
1691 static
1692 cmsUInt8Number* Pack4BytesSwapSwapFirst(register _cmsTRANSFORM* info,
1693 register cmsUInt16Number wOut[],
1694 register cmsUInt8Number* output,
1695 register cmsUInt32Number Stride)
1696 {
1697 *output++ = FROM_16_TO_8(wOut[2]);
1698 *output++ = FROM_16_TO_8(wOut[1]);
1699 *output++ = FROM_16_TO_8(wOut[0]);
1700 *output++ = FROM_16_TO_8(wOut[3]);
1701
1702 cmsUNUSED_PARAMETER(info);
1703 cmsUNUSED_PARAMETER(Stride);
1704
1705 return output;
1706
1707 }
1708
1709 static
1710 cmsUInt8Number* Pack4Words(register _cmsTRANSFORM* info,
1711 register cmsUInt16Number wOut[],
1712 register cmsUInt8Number* output,
1713 register cmsUInt32Number Stride)
1714 {
1715 *(cmsUInt16Number*) output = wOut[0];
1716 output+= 2;
1717 *(cmsUInt16Number*) output = wOut[1];
1718 output+= 2;
1719 *(cmsUInt16Number*) output = wOut[2];
1720 output+= 2;
1721 *(cmsUInt16Number*) output = wOut[3];
1722 output+= 2;
1723
1724 cmsUNUSED_PARAMETER(info);
1725 cmsUNUSED_PARAMETER(Stride);
1726
1727 return output;
1728
1729 }
1730
1731 static
1732 cmsUInt8Number* Pack4WordsReverse(register _cmsTRANSFORM* info,
1733 register cmsUInt16Number wOut[],
1734 register cmsUInt8Number* output,
1735 register cmsUInt32Number Stride)
1736 {
1737 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
1738 output+= 2;
1739 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[1]);
1740 output+= 2;
1741 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[2]);
1742 output+= 2;
1743 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[3]);
1744 output+= 2;
1745
1746 cmsUNUSED_PARAMETER(info);
1747 cmsUNUSED_PARAMETER(Stride);
1748
1749 return output;
1750
1751 }
1752
1753 // ABGR
1754 static
1755 cmsUInt8Number* Pack4WordsSwap(register _cmsTRANSFORM* info,
1756 register cmsUInt16Number wOut[],
1757 register cmsUInt8Number* output,
1758 register cmsUInt32Number Stride)
1759 {
1760 *(cmsUInt16Number*) output = wOut[3];
1761 output+= 2;
1762 *(cmsUInt16Number*) output = wOut[2];
1763 output+= 2;
1764 *(cmsUInt16Number*) output = wOut[1];
1765 output+= 2;
1766 *(cmsUInt16Number*) output = wOut[0];
1767 output+= 2;
1768
1769 cmsUNUSED_PARAMETER(info);
1770 cmsUNUSED_PARAMETER(Stride);
1771
1772 return output;
1773
1774 }
1775
1776 // CMYK
1777 static
1778 cmsUInt8Number* Pack4WordsBigEndian(register _cmsTRANSFORM* info,
1779 register cmsUInt16Number wOut[],
1780 register cmsUInt8Number* output,
1781 register cmsUInt32Number Stride)
1782 {
1783 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1784 output+= 2;
1785 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1786 output+= 2;
1787 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1788 output+= 2;
1789 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[3]);
1790 output+= 2;
1791
1792 cmsUNUSED_PARAMETER(info);
1793 cmsUNUSED_PARAMETER(Stride);
1794
1795 return output;
1796
1797 }
1798
1799
1800 static
1801 cmsUInt8Number* PackLabV2_8(register _cmsTRANSFORM* info,
1802 register cmsUInt16Number wOut[],
1803 register cmsUInt8Number* output,
1804 register cmsUInt32Number Stride)
1805 {
1806 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1807 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1808 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1809
1810 cmsUNUSED_PARAMETER(info);
1811 cmsUNUSED_PARAMETER(Stride);
1812
1813 return output;
1814
1815 }
1816
1817 static
1818 cmsUInt8Number* PackALabV2_8(register _cmsTRANSFORM* info,
1819 register cmsUInt16Number wOut[],
1820 register cmsUInt8Number* output,
1821 register cmsUInt32Number Stride)
1822 {
1823 output++;
1824 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[0]));
1825 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[1]));
1826 *output++ = FROM_16_TO_8(FomLabV4ToLabV2(wOut[2]));
1827
1828 cmsUNUSED_PARAMETER(info);
1829 cmsUNUSED_PARAMETER(Stride);
1830
1831 return output;
1832
1833 }
1834
1835 static
1836 cmsUInt8Number* PackLabV2_16(register _cmsTRANSFORM* info,
1837 register cmsUInt16Number wOut[],
1838 register cmsUInt8Number* output,
1839 register cmsUInt32Number Stride)
1840 {
1841 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[0]);
1842 output += 2;
1843 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[1]);
1844 output += 2;
1845 *(cmsUInt16Number*) output = FomLabV4ToLabV2(wOut[2]);
1846 output += 2;
1847
1848 cmsUNUSED_PARAMETER(info);
1849 cmsUNUSED_PARAMETER(Stride);
1850
1851 return output;
1852
1853 }
1854
1855 static
1856 cmsUInt8Number* Pack3Bytes(register _cmsTRANSFORM* info,
1857 register cmsUInt16Number wOut[],
1858 register cmsUInt8Number* output,
1859 register 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 cmsUNUSED_PARAMETER(info);
1866 cmsUNUSED_PARAMETER(Stride);
1867
1868 return output;
1869
1870 }
1871
1872 static
1873 cmsUInt8Number* Pack3BytesOptimized(register _cmsTRANSFORM* info,
1874 register cmsUInt16Number wOut[],
1875 register cmsUInt8Number* output,
1876 register cmsUInt32Number Stride)
1877 {
1878 *output++ = (wOut[0] & 0xFF);
1879 *output++ = (wOut[1] & 0xFF);
1880 *output++ = (wOut[2] & 0xFF);
1881
1882 cmsUNUSED_PARAMETER(info);
1883 cmsUNUSED_PARAMETER(Stride);
1884
1885 return output;
1886
1887 }
1888
1889 static
1890 cmsUInt8Number* Pack3BytesSwap(register _cmsTRANSFORM* info,
1891 register cmsUInt16Number wOut[],
1892 register cmsUInt8Number* output,
1893 register cmsUInt32Number Stride)
1894 {
1895 *output++ = FROM_16_TO_8(wOut[2]);
1896 *output++ = FROM_16_TO_8(wOut[1]);
1897 *output++ = FROM_16_TO_8(wOut[0]);
1898
1899 cmsUNUSED_PARAMETER(info);
1900 cmsUNUSED_PARAMETER(Stride);
1901
1902 return output;
1903
1904 }
1905
1906 static
1907 cmsUInt8Number* Pack3BytesSwapOptimized(register _cmsTRANSFORM* info,
1908 register cmsUInt16Number wOut[],
1909 register cmsUInt8Number* output,
1910 register cmsUInt32Number Stride)
1911 {
1912 *output++ = (wOut[2] & 0xFF);
1913 *output++ = (wOut[1] & 0xFF);
1914 *output++ = (wOut[0] & 0xFF);
1915
1916 cmsUNUSED_PARAMETER(info);
1917 cmsUNUSED_PARAMETER(Stride);
1918
1919 return output;
1920
1921 }
1922
1923
1924 static
1925 cmsUInt8Number* Pack3Words(register _cmsTRANSFORM* info,
1926 register cmsUInt16Number wOut[],
1927 register cmsUInt8Number* output,
1928 register cmsUInt32Number Stride)
1929 {
1930 *(cmsUInt16Number*) output = wOut[0];
1931 output+= 2;
1932 *(cmsUInt16Number*) output = wOut[1];
1933 output+= 2;
1934 *(cmsUInt16Number*) output = wOut[2];
1935 output+= 2;
1936
1937 cmsUNUSED_PARAMETER(info);
1938 cmsUNUSED_PARAMETER(Stride);
1939
1940 return output;
1941
1942 }
1943
1944 static
1945 cmsUInt8Number* Pack3WordsSwap(register _cmsTRANSFORM* info,
1946 register cmsUInt16Number wOut[],
1947 register cmsUInt8Number* output,
1948 register cmsUInt32Number Stride)
1949 {
1950 *(cmsUInt16Number*) output = wOut[2];
1951 output+= 2;
1952 *(cmsUInt16Number*) output = wOut[1];
1953 output+= 2;
1954 *(cmsUInt16Number*) output = wOut[0];
1955 output+= 2;
1956
1957 cmsUNUSED_PARAMETER(info);
1958 cmsUNUSED_PARAMETER(Stride);
1959
1960 return output;
1961
1962 }
1963
1964 static
1965 cmsUInt8Number* Pack3WordsBigEndian(register _cmsTRANSFORM* info,
1966 register cmsUInt16Number wOut[],
1967 register cmsUInt8Number* output,
1968 register cmsUInt32Number Stride)
1969 {
1970 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
1971 output+= 2;
1972 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[1]);
1973 output+= 2;
1974 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[2]);
1975 output+= 2;
1976
1977 cmsUNUSED_PARAMETER(info);
1978 cmsUNUSED_PARAMETER(Stride);
1979
1980 return output;
1981
1982 }
1983
1984 static
1985 cmsUInt8Number* Pack3BytesAndSkip1(register _cmsTRANSFORM* info,
1986 register cmsUInt16Number wOut[],
1987 register cmsUInt8Number* output,
1988 register cmsUInt32Number Stride)
1989 {
1990 *output++ = FROM_16_TO_8(wOut[0]);
1991 *output++ = FROM_16_TO_8(wOut[1]);
1992 *output++ = FROM_16_TO_8(wOut[2]);
1993 output++;
1994
1995 cmsUNUSED_PARAMETER(info);
1996 cmsUNUSED_PARAMETER(Stride);
1997
1998 return output;
1999
2000 }
2001
2002 static
2003 cmsUInt8Number* Pack3BytesAndSkip1Optimized(register _cmsTRANSFORM* info,
2004 register cmsUInt16Number wOut[],
2005 register cmsUInt8Number* output,
2006 register cmsUInt32Number Stride)
2007 {
2008 *output++ = (wOut[0] & 0xFF);
2009 *output++ = (wOut[1] & 0xFF);
2010 *output++ = (wOut[2] & 0xFF);
2011 output++;
2012
2013 cmsUNUSED_PARAMETER(info);
2014 cmsUNUSED_PARAMETER(Stride);
2015
2016 return output;
2017
2018 }
2019
2020
2021 static
2022 cmsUInt8Number* Pack3BytesAndSkip1SwapFirst(register _cmsTRANSFORM* info,
2023 register cmsUInt16Number wOut[],
2024 register cmsUInt8Number* output,
2025 register cmsUInt32Number Stride)
2026 {
2027 output++;
2028 *output++ = FROM_16_TO_8(wOut[0]);
2029 *output++ = FROM_16_TO_8(wOut[1]);
2030 *output++ = FROM_16_TO_8(wOut[2]);
2031
2032 cmsUNUSED_PARAMETER(info);
2033 cmsUNUSED_PARAMETER(Stride);
2034
2035 return output;
2036
2037 }
2038
2039 static
2040 cmsUInt8Number* Pack3BytesAndSkip1SwapFirstOptimized(register _cmsTRANSFORM* info,
2041 register cmsUInt16Number wOut[],
2042 register cmsUInt8Number* output,
2043 register cmsUInt32Number Stride)
2044 {
2045 output++;
2046 *output++ = (wOut[0] & 0xFF);
2047 *output++ = (wOut[1] & 0xFF);
2048 *output++ = (wOut[2] & 0xFF);
2049
2050 cmsUNUSED_PARAMETER(info);
2051 cmsUNUSED_PARAMETER(Stride);
2052
2053 return output;
2054
2055 }
2056
2057 static
2058 cmsUInt8Number* Pack3BytesAndSkip1Swap(register _cmsTRANSFORM* info,
2059 register cmsUInt16Number wOut[],
2060 register cmsUInt8Number* output,
2061 register cmsUInt32Number Stride)
2062 {
2063 output++;
2064 *output++ = FROM_16_TO_8(wOut[2]);
2065 *output++ = FROM_16_TO_8(wOut[1]);
2066 *output++ = FROM_16_TO_8(wOut[0]);
2067
2068 cmsUNUSED_PARAMETER(info);
2069 cmsUNUSED_PARAMETER(Stride);
2070
2071 return output;
2072
2073 }
2074
2075 static
2076 cmsUInt8Number* Pack3BytesAndSkip1SwapOptimized(register _cmsTRANSFORM* info,
2077 register cmsUInt16Number wOut[],
2078 register cmsUInt8Number* output,
2079 register cmsUInt32Number Stride)
2080 {
2081 output++;
2082 *output++ = (wOut[2] & 0xFF);
2083 *output++ = (wOut[1] & 0xFF);
2084 *output++ = (wOut[0] & 0xFF);
2085
2086 cmsUNUSED_PARAMETER(info);
2087 cmsUNUSED_PARAMETER(Stride);
2088
2089 return output;
2090
2091 }
2092
2093
2094 static
2095 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
2096 register cmsUInt16Number wOut[],
2097 register cmsUInt8Number* output,
2098 register cmsUInt32Number Stride)
2099 {
2100 *output++ = FROM_16_TO_8(wOut[2]);
2101 *output++ = FROM_16_TO_8(wOut[1]);
2102 *output++ = FROM_16_TO_8(wOut[0]);
2103 output++;
2104
2105 cmsUNUSED_PARAMETER(info);
2106 cmsUNUSED_PARAMETER(Stride);
2107
2108 return output;
2109
2110 }
2111
2112 static
2113 cmsUInt8Number* Pack3BytesAndSkip1SwapSwapFirstOptimized(register _cmsTRANSFORM* info,
2114 register cmsUInt16Number wOut[],
2115 register cmsUInt8Number* output,
2116 register cmsUInt32Number Stride)
2117 {
2118 *output++ = (wOut[2] & 0xFF);
2119 *output++ = (wOut[1] & 0xFF);
2120 *output++ = (wOut[0] & 0xFF);
2121 output++;
2122
2123 cmsUNUSED_PARAMETER(info);
2124 cmsUNUSED_PARAMETER(Stride);
2125
2126 return output;
2127
2128 }
2129
2130 static
2131 cmsUInt8Number* Pack3WordsAndSkip1(register _cmsTRANSFORM* info,
2132 register cmsUInt16Number wOut[],
2133 register cmsUInt8Number* output,
2134 register cmsUInt32Number Stride)
2135 {
2136 *(cmsUInt16Number*) output = wOut[0];
2137 output+= 2;
2138 *(cmsUInt16Number*) output = wOut[1];
2139 output+= 2;
2140 *(cmsUInt16Number*) output = wOut[2];
2141 output+= 2;
2142 output+= 2;
2143
2144 cmsUNUSED_PARAMETER(info);
2145 cmsUNUSED_PARAMETER(Stride);
2146
2147 return output;
2148
2149 }
2150
2151 static
2152 cmsUInt8Number* Pack3WordsAndSkip1Swap(register _cmsTRANSFORM* info,
2153 register cmsUInt16Number wOut[],
2154 register cmsUInt8Number* output,
2155 register cmsUInt32Number Stride)
2156 {
2157 output+= 2;
2158 *(cmsUInt16Number*) output = wOut[2];
2159 output+= 2;
2160 *(cmsUInt16Number*) output = wOut[1];
2161 output+= 2;
2162 *(cmsUInt16Number*) output = wOut[0];
2163 output+= 2;
2164
2165 cmsUNUSED_PARAMETER(info);
2166 cmsUNUSED_PARAMETER(Stride);
2167
2168 return output;
2169
2170 }
2171
2172
2173 static
2174 cmsUInt8Number* Pack3WordsAndSkip1SwapFirst(register _cmsTRANSFORM* info,
2175 register cmsUInt16Number wOut[],
2176 register cmsUInt8Number* output,
2177 register cmsUInt32Number Stride)
2178 {
2179 output+= 2;
2180 *(cmsUInt16Number*) output = wOut[0];
2181 output+= 2;
2182 *(cmsUInt16Number*) output = wOut[1];
2183 output+= 2;
2184 *(cmsUInt16Number*) output = wOut[2];
2185 output+= 2;
2186
2187 cmsUNUSED_PARAMETER(info);
2188 cmsUNUSED_PARAMETER(Stride);
2189
2190 return output;
2191
2192 }
2193
2194
2195 static
2196 cmsUInt8Number* Pack3WordsAndSkip1SwapSwapFirst(register _cmsTRANSFORM* info,
2197 register cmsUInt16Number wOut[],
2198 register cmsUInt8Number* output,
2199 register cmsUInt32Number Stride)
2200 {
2201 *(cmsUInt16Number*) output = wOut[2];
2202 output+= 2;
2203 *(cmsUInt16Number*) output = wOut[1];
2204 output+= 2;
2205 *(cmsUInt16Number*) output = wOut[0];
2206 output+= 2;
2207 output+= 2;
2208
2209 cmsUNUSED_PARAMETER(info);
2210 cmsUNUSED_PARAMETER(Stride);
2211
2212 return output;
2213
2214 }
2215
2216
2217
2218 static
2219 cmsUInt8Number* Pack1Byte(register _cmsTRANSFORM* info,
2220 register cmsUInt16Number wOut[],
2221 register cmsUInt8Number* output,
2222 register cmsUInt32Number Stride)
2223 {
2224 *output++ = FROM_16_TO_8(wOut[0]);
2225
2226 cmsUNUSED_PARAMETER(info);
2227 cmsUNUSED_PARAMETER(Stride);
2228
2229 return output;
2230
2231 }
2232
2233
2234 static
2235 cmsUInt8Number* Pack1ByteReversed(register _cmsTRANSFORM* info,
2236 register cmsUInt16Number wOut[],
2237 register cmsUInt8Number* output,
2238 register cmsUInt32Number Stride)
2239 {
2240 *output++ = FROM_16_TO_8(REVERSE_FLAVOR_16(wOut[0]));
2241
2242 cmsUNUSED_PARAMETER(info);
2243 cmsUNUSED_PARAMETER(Stride);
2244
2245 return output;
2246
2247 }
2248
2249
2250 static
2251 cmsUInt8Number* Pack1ByteSkip1(register _cmsTRANSFORM* info,
2252 register cmsUInt16Number wOut[],
2253 register cmsUInt8Number* output,
2254 register cmsUInt32Number Stride)
2255 {
2256 *output++ = FROM_16_TO_8(wOut[0]);
2257 output++;
2258
2259 cmsUNUSED_PARAMETER(info);
2260 cmsUNUSED_PARAMETER(Stride);
2261
2262 return output;
2263
2264 }
2265
2266
2267 static
2268 cmsUInt8Number* Pack1ByteSkip1SwapFirst(register _cmsTRANSFORM* info,
2269 register cmsUInt16Number wOut[],
2270 register cmsUInt8Number* output,
2271 register cmsUInt32Number Stride)
2272 {
2273 output++;
2274 *output++ = FROM_16_TO_8(wOut[0]);
2275
2276 cmsUNUSED_PARAMETER(info);
2277 cmsUNUSED_PARAMETER(Stride);
2278
2279 return output;
2280
2281 }
2282
2283 static
2284 cmsUInt8Number* Pack1Word(register _cmsTRANSFORM* info,
2285 register cmsUInt16Number wOut[],
2286 register cmsUInt8Number* output,
2287 register cmsUInt32Number Stride)
2288 {
2289 *(cmsUInt16Number*) output = wOut[0];
2290 output+= 2;
2291
2292 cmsUNUSED_PARAMETER(info);
2293 cmsUNUSED_PARAMETER(Stride);
2294
2295 return output;
2296
2297 }
2298
2299
2300 static
2301 cmsUInt8Number* Pack1WordReversed(register _cmsTRANSFORM* info,
2302 register cmsUInt16Number wOut[],
2303 register cmsUInt8Number* output,
2304 register cmsUInt32Number Stride)
2305 {
2306 *(cmsUInt16Number*) output = REVERSE_FLAVOR_16(wOut[0]);
2307 output+= 2;
2308
2309 cmsUNUSED_PARAMETER(info);
2310 cmsUNUSED_PARAMETER(Stride);
2311
2312 return output;
2313
2314 }
2315
2316 static
2317 cmsUInt8Number* Pack1WordBigEndian(register _cmsTRANSFORM* info,
2318 register cmsUInt16Number wOut[],
2319 register cmsUInt8Number* output,
2320 register cmsUInt32Number Stride)
2321 {
2322 *(cmsUInt16Number*) output = CHANGE_ENDIAN(wOut[0]);
2323 output+= 2;
2324
2325 cmsUNUSED_PARAMETER(info);
2326 cmsUNUSED_PARAMETER(Stride);
2327
2328 return output;
2329
2330 }
2331
2332
2333 static
2334 cmsUInt8Number* Pack1WordSkip1(register _cmsTRANSFORM* info,
2335 register cmsUInt16Number wOut[],
2336 register cmsUInt8Number* output,
2337 register cmsUInt32Number Stride)
2338 {
2339 *(cmsUInt16Number*) output = wOut[0];
2340 output+= 4;
2341
2342 cmsUNUSED_PARAMETER(info);
2343 cmsUNUSED_PARAMETER(Stride);
2344
2345 return output;
2346
2347 }
2348
2349 static
2350 cmsUInt8Number* Pack1WordSkip1SwapFirst(register _cmsTRANSFORM* info,
2351 register cmsUInt16Number wOut[],
2352 register cmsUInt8Number* output,
2353 register cmsUInt32Number Stride)
2354 {
2355 output += 2;
2356 *(cmsUInt16Number*) output = wOut[0];
2357 output+= 2;
2358
2359 cmsUNUSED_PARAMETER(info);
2360 cmsUNUSED_PARAMETER(Stride);
2361
2362 return output;
2363
2364 }
2365
2366
2367 // Unencoded Float values -- don't try optimize speed
2368 static
2369 cmsUInt8Number* PackLabDoubleFrom16(register _cmsTRANSFORM* info,
2370 register cmsUInt16Number wOut[],
2371 register cmsUInt8Number* output,
2372 register cmsUInt32Number Stride)
2373 {
2374
2375 if (T_PLANAR(info -> OutputFormat)) {
2376
2377 cmsCIELab Lab;
2378 cmsFloat64Number* Out = (cmsFloat64Number*) output;
2379 cmsLabEncoded2Float(&Lab, wOut);
2380
2381 Out[0] = Lab.L;
2382 Out[Stride] = Lab.a;
2383 Out[Stride*2] = Lab.b;
|