2421 int i, start = 0; 2422 2423 if (ExtraFirst) 2424 start = Extra; 2425 2426 for (i=0; i < nChan; i++) { 2427 2428 int index = DoSwap ? (nChan - i - 1) : i; 2429 2430 v = (cmsFloat64Number) wOut[index] / maximum; 2431 2432 if (Reverse) 2433 v = maximum - v; 2434 2435 if (Planar) 2436 ((cmsFloat64Number*) output)[(i + start) * Stride]= v; 2437 else 2438 ((cmsFloat64Number*) output)[i + start] = v; 2439 } 2440 2441 if (!ExtraFirst) { 2442 output += Extra * sizeof(cmsFloat64Number); 2443 } 2444 2445 if (Extra == 0 && SwapFirst) { 2446 2447 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number)); 2448 *swap1 = v; 2449 } 2450 2451 if (T_PLANAR(info -> OutputFormat)) 2452 return output + sizeof(cmsFloat64Number); 2453 else 2454 return output + nChan * sizeof(cmsFloat64Number); 2455 2456 } 2457 2458 2459 static 2460 cmsUInt8Number* PackFloatFrom16(register _cmsTRANSFORM* info, 2461 register cmsUInt16Number wOut[], 2462 register cmsUInt8Number* output, 2463 register cmsUInt32Number Stride) 2464 { 2465 int nChan = T_CHANNELS(info -> OutputFormat); 2466 int DoSwap = T_DOSWAP(info ->OutputFormat); 2467 int Reverse = T_FLAVOR(info ->OutputFormat); 2468 int Extra = T_EXTRA(info -> OutputFormat); 2469 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2470 int Planar = T_PLANAR(info -> OutputFormat); 2471 int ExtraFirst = DoSwap ^ SwapFirst; 2472 cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35 : 65535.0; 2473 cmsFloat64Number v = 0; 2474 cmsFloat32Number* swap1 = (cmsFloat32Number*) output; 2475 int i, start = 0; 2476 2477 if (ExtraFirst) 2478 start = Extra; 2479 2480 for (i=0; i < nChan; i++) { 2481 2482 int index = DoSwap ? (nChan - i - 1) : i; 2483 2484 v = (cmsFloat64Number) wOut[index] / maximum; 2485 2486 if (Reverse) 2487 v = maximum - v; 2488 2489 if (Planar) 2490 ((cmsFloat32Number*) output)[(i + start ) * Stride]= (cmsFloat32Number) v; 2491 else 2492 ((cmsFloat32Number*) output)[i + start] = (cmsFloat32Number) v; 2493 } 2494 2495 if (!ExtraFirst) { 2496 output += Extra * sizeof(cmsFloat32Number); 2497 } 2498 2499 if (Extra == 0 && SwapFirst) { 2500 2501 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat32Number)); 2502 *swap1 = (cmsFloat32Number) v; 2503 } 2504 2505 if (T_PLANAR(info -> OutputFormat)) 2506 return output + sizeof(cmsFloat32Number); 2507 else 2508 return output + nChan * sizeof(cmsFloat32Number); 2509 } 2510 2511 2512 2513 // -------------------------------------------------------------------------------------------------------- 2514 2515 static 2516 cmsUInt8Number* PackFloatsFromFloat(_cmsTRANSFORM* info, 2517 cmsFloat32Number wOut[], 2518 cmsUInt8Number* output, 2519 cmsUInt32Number Stride) 2520 { 2521 int nChan = T_CHANNELS(info -> OutputFormat); 2522 int DoSwap = T_DOSWAP(info ->OutputFormat); 2523 int Reverse = T_FLAVOR(info ->OutputFormat); 2524 int Extra = T_EXTRA(info -> OutputFormat); 2525 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2526 int Planar = T_PLANAR(info -> OutputFormat); 2527 int ExtraFirst = DoSwap ^ SwapFirst; 2528 cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0; 2529 cmsFloat32Number* swap1 = (cmsFloat32Number*) output; 2530 cmsFloat64Number v = 0; 2531 int i, start = 0; 2532 2533 if (ExtraFirst) 2534 start = Extra; 2535 2536 for (i=0; i < nChan; i++) { 2537 2538 int index = DoSwap ? (nChan - i - 1) : i; 2539 2540 v = wOut[index] * maximum; 2541 2542 if (Reverse) 2543 v = maximum - v; 2544 2545 if (Planar) 2546 ((cmsFloat32Number*) output)[(i + start)* Stride]= (cmsFloat32Number) v; 2547 else 2548 ((cmsFloat32Number*) output)[i + start] = (cmsFloat32Number) v; 2549 } 2550 2551 if (!ExtraFirst) { 2552 output += Extra * sizeof(cmsFloat32Number); 2553 } 2554 2555 if (Extra == 0 && SwapFirst) { 2556 2557 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat32Number)); 2558 *swap1 = (cmsFloat32Number) v; 2559 } 2560 2561 if (T_PLANAR(info -> OutputFormat)) 2562 return output + sizeof(cmsFloat32Number); 2563 else 2564 return output + nChan * sizeof(cmsFloat32Number); 2565 } 2566 2567 static 2568 cmsUInt8Number* PackDoublesFromFloat(_cmsTRANSFORM* info, 2569 cmsFloat32Number wOut[], 2570 cmsUInt8Number* output, 2571 cmsUInt32Number Stride) 2572 { 2573 int nChan = T_CHANNELS(info -> OutputFormat); 2574 int DoSwap = T_DOSWAP(info ->OutputFormat); 2575 int Reverse = T_FLAVOR(info ->OutputFormat); 2576 int Extra = T_EXTRA(info -> OutputFormat); 2577 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2578 int Planar = T_PLANAR(info -> OutputFormat); 2579 int ExtraFirst = DoSwap ^ SwapFirst; 2580 cmsFloat64Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0 : 1.0; 2581 cmsFloat64Number v = 0; 2582 cmsFloat64Number* swap1 = (cmsFloat64Number*) output; 2583 int i, start = 0; 2584 2585 if (ExtraFirst) 2586 start = Extra; 2587 2588 for (i=0; i < nChan; i++) { 2589 2590 int index = DoSwap ? (nChan - i - 1) : i; 2591 2592 v = wOut[index] * maximum; 2593 2594 if (Reverse) 2595 v = maximum - v; 2596 2597 if (Planar) 2598 ((cmsFloat64Number*) output)[(i + start) * Stride] = v; 2599 else 2600 ((cmsFloat64Number*) output)[i + start] = v; 2601 } 2602 2603 if (!ExtraFirst) { 2604 output += Extra * sizeof(cmsFloat64Number); 2605 } 2606 2607 if (Extra == 0 && SwapFirst) { 2608 2609 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number)); 2610 *swap1 = v; 2611 } 2612 2613 2614 if (T_PLANAR(info -> OutputFormat)) 2615 return output + sizeof(cmsFloat64Number); 2616 else 2617 return output + nChan * sizeof(cmsFloat64Number); 2618 2619 } 2620 2621 2622 2623 2624 2625 static 2626 cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info, 2627 cmsFloat32Number wOut[], 2628 cmsUInt8Number* output, 2629 cmsUInt32Number Stride) 2630 { 2631 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2632 2633 if (T_PLANAR(Info -> OutputFormat)) { 2634 2635 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0); 2636 Out[Stride] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0); 2637 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0); 2833 if (Extra == 0 && SwapFirst) { 2834 cmsFloat32Number tmp = wIn[0]; 2835 2836 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number)); 2837 wIn[nChan-1] = tmp; 2838 } 2839 2840 if (T_PLANAR(info -> InputFormat)) 2841 return accum + sizeof(cmsUInt16Number); 2842 else 2843 return accum + (nChan + Extra) * sizeof(cmsUInt16Number); 2844 } 2845 2846 2847 static 2848 cmsUInt8Number* PackHalfFrom16(register _cmsTRANSFORM* info, 2849 register cmsUInt16Number wOut[], 2850 register cmsUInt8Number* output, 2851 register cmsUInt32Number Stride) 2852 { 2853 int nChan = T_CHANNELS(info -> OutputFormat); 2854 int DoSwap = T_DOSWAP(info ->OutputFormat); 2855 int Reverse = T_FLAVOR(info ->OutputFormat); 2856 int Extra = T_EXTRA(info -> OutputFormat); 2857 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2858 int Planar = T_PLANAR(info -> OutputFormat); 2859 int ExtraFirst = DoSwap ^ SwapFirst; 2860 cmsFloat32Number maximum = IsInkSpace(info ->OutputFormat) ? 655.35F : 65535.0F; 2861 cmsFloat32Number v = 0; 2862 cmsUInt16Number* swap1 = (cmsUInt16Number*) output; 2863 int i, start = 0; 2864 2865 if (ExtraFirst) 2866 start = Extra; 2867 2868 for (i=0; i < nChan; i++) { 2869 2870 int index = DoSwap ? (nChan - i - 1) : i; 2871 2872 v = (cmsFloat32Number) wOut[index] / maximum; 2873 2874 if (Reverse) 2875 v = maximum - v; 2876 2877 if (Planar) 2878 ((cmsUInt16Number*) output)[(i + start ) * Stride]= _cmsFloat2Half(v); 2879 else 2880 ((cmsUInt16Number*) output)[i + start] = _cmsFloat2Half(v); 2881 } 2882 2883 if (!ExtraFirst) { 2884 output += Extra * sizeof(cmsUInt16Number); 2885 } 2886 2887 if (Extra == 0 && SwapFirst) { 2888 2889 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number)); 2890 *swap1 = _cmsFloat2Half(v); 2891 } 2892 2893 if (T_PLANAR(info -> OutputFormat)) 2894 return output + sizeof(cmsUInt16Number); 2895 else 2896 return output + nChan * sizeof(cmsUInt16Number); 2897 } 2898 2899 2900 2901 static 2902 cmsUInt8Number* PackHalfFromFloat(_cmsTRANSFORM* info, 2903 cmsFloat32Number wOut[], 2904 cmsUInt8Number* output, 2905 cmsUInt32Number Stride) 2906 { 2907 int nChan = T_CHANNELS(info -> OutputFormat); 2908 int DoSwap = T_DOSWAP(info ->OutputFormat); 2909 int Reverse = T_FLAVOR(info ->OutputFormat); 2910 int Extra = T_EXTRA(info -> OutputFormat); 2911 int SwapFirst = T_SWAPFIRST(info -> OutputFormat); 2912 int Planar = T_PLANAR(info -> OutputFormat); 2913 int ExtraFirst = DoSwap ^ SwapFirst; 2914 cmsFloat32Number maximum = IsInkSpace(info ->OutputFormat) ? 100.0F : 1.0F; 2915 cmsUInt16Number* swap1 = (cmsUInt16Number*) output; 2916 cmsFloat32Number v = 0; 2917 int i, start = 0; 2918 2919 if (ExtraFirst) 2920 start = Extra; 2921 2922 for (i=0; i < nChan; i++) { 2923 2924 int index = DoSwap ? (nChan - i - 1) : i; 2925 2926 v = wOut[index] * maximum; 2927 2928 if (Reverse) 2929 v = maximum - v; 2930 2931 if (Planar) 2932 ((cmsUInt16Number*) output)[(i + start)* Stride]= _cmsFloat2Half( v ); 2933 else 2934 ((cmsUInt16Number*) output)[i + start] = _cmsFloat2Half( v ); 2935 } 2936 2937 if (!ExtraFirst) { 2938 output += Extra * sizeof(cmsUInt16Number); 2939 } 2940 2941 if (Extra == 0 && SwapFirst) { 2942 2943 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsUInt16Number)); 2944 *swap1 = (cmsUInt16Number) _cmsFloat2Half( v ); 2945 } 2946 2947 if (T_PLANAR(info -> OutputFormat)) 2948 return output + sizeof(cmsUInt16Number); 2949 else 2950 return output + nChan * sizeof(cmsUInt16Number); 2951 } 2952 2953 #endif 2954 2955 // ---------------------------------------------------------------------------------------------------------------- 2956 2957 2958 static cmsFormatters16 InputFormatters16[] = { 2959 2960 // Type Mask Function 2961 // ---------------------------- ------------------------------------ ---------------------------- 2962 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleTo16}, 2963 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleTo16}, 2964 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatTo16}, 2965 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatTo16}, 2966 { TYPE_GRAY_DBL, 0, UnrollDouble1Chan}, 2967 { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2968 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollDoubleTo16}, 2969 { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2970 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollFloatTo16}, | 2421 int i, start = 0; 2422 2423 if (ExtraFirst) 2424 start = Extra; 2425 2426 for (i=0; i < nChan; i++) { 2427 2428 int index = DoSwap ? (nChan - i - 1) : i; 2429 2430 v = (cmsFloat64Number) wOut[index] / maximum; 2431 2432 if (Reverse) 2433 v = maximum - v; 2434 2435 if (Planar) 2436 ((cmsFloat64Number*) output)[(i + start) * Stride]= v; 2437 else 2438 ((cmsFloat64Number*) output)[i + start] = v; 2439 } 2440 2441 2442 if (Extra == 0 && SwapFirst) { 2443 2444 memmove(swap1 + 1, swap1, (nChan-1)* sizeof(cmsFloat64Number)); 2445 *swap1 = v; 2446 } 2447 2448 if (T_PLANAR(info -> OutputFormat)) 2449 return output + sizeof(cmsFloat64Number); 2450 else 2451 return output + (nChan + Extra) * sizeof(cmsFloat64Number); 2452 2453 } 2454 2455 2456 static 2457 cmsUInt8Number* PackFloatFrom16(register _cmsTRANSFORM* info, 2458 register cmsUInt16Number wOut[], 2459 register cmsUInt8Number* output, 2460 register cmsUInt32Number Stride) 2461 { 2462 int nChan = T_CHANNELS(info->OutputFormat); 2463 int DoSwap = T_DOSWAP(info->OutputFormat); 2464 int Reverse = T_FLAVOR(info->OutputFormat); 2465 int Extra = T_EXTRA(info->OutputFormat); 2466 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2467 int Planar = T_PLANAR(info->OutputFormat); 2468 int ExtraFirst = DoSwap ^ SwapFirst; 2469 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 655.35 : 65535.0; 2470 cmsFloat64Number v = 0; 2471 cmsFloat32Number* swap1 = (cmsFloat32Number*)output; 2472 int i, start = 0; 2473 2474 if (ExtraFirst) 2475 start = Extra; 2476 2477 for (i = 0; i < nChan; i++) { 2478 2479 int index = DoSwap ? (nChan - i - 1) : i; 2480 2481 v = (cmsFloat64Number)wOut[index] / maximum; 2482 2483 if (Reverse) 2484 v = maximum - v; 2485 2486 if (Planar) 2487 ((cmsFloat32Number*)output)[(i + start) * Stride] = (cmsFloat32Number)v; 2488 else 2489 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v; 2490 } 2491 2492 2493 if (Extra == 0 && SwapFirst) { 2494 2495 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number)); 2496 *swap1 = (cmsFloat32Number)v; 2497 } 2498 2499 if (T_PLANAR(info->OutputFormat)) 2500 return output + sizeof(cmsFloat32Number); 2501 else 2502 return output + (nChan + Extra) * sizeof(cmsFloat32Number); 2503 } 2504 2505 2506 2507 // -------------------------------------------------------------------------------------------------------- 2508 2509 static 2510 cmsUInt8Number* PackFloatsFromFloat(_cmsTRANSFORM* info, 2511 cmsFloat32Number wOut[], 2512 cmsUInt8Number* output, 2513 cmsUInt32Number Stride) 2514 { 2515 int nChan = T_CHANNELS(info->OutputFormat); 2516 int DoSwap = T_DOSWAP(info->OutputFormat); 2517 int Reverse = T_FLAVOR(info->OutputFormat); 2518 int Extra = T_EXTRA(info->OutputFormat); 2519 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2520 int Planar = T_PLANAR(info->OutputFormat); 2521 int ExtraFirst = DoSwap ^ SwapFirst; 2522 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0; 2523 cmsFloat32Number* swap1 = (cmsFloat32Number*)output; 2524 cmsFloat64Number v = 0; 2525 int i, start = 0; 2526 2527 if (ExtraFirst) 2528 start = Extra; 2529 2530 for (i = 0; i < nChan; i++) { 2531 2532 int index = DoSwap ? (nChan - i - 1) : i; 2533 2534 v = wOut[index] * maximum; 2535 2536 if (Reverse) 2537 v = maximum - v; 2538 2539 if (Planar) 2540 ((cmsFloat32Number*)output)[(i + start)* Stride] = (cmsFloat32Number)v; 2541 else 2542 ((cmsFloat32Number*)output)[i + start] = (cmsFloat32Number)v; 2543 } 2544 2545 2546 if (Extra == 0 && SwapFirst) { 2547 2548 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat32Number)); 2549 *swap1 = (cmsFloat32Number)v; 2550 } 2551 2552 if (T_PLANAR(info->OutputFormat)) 2553 return output + sizeof(cmsFloat32Number); 2554 else 2555 return output + (nChan + Extra) * sizeof(cmsFloat32Number); 2556 } 2557 2558 static 2559 cmsUInt8Number* PackDoublesFromFloat(_cmsTRANSFORM* info, 2560 cmsFloat32Number wOut[], 2561 cmsUInt8Number* output, 2562 cmsUInt32Number Stride) 2563 { 2564 int nChan = T_CHANNELS(info->OutputFormat); 2565 int DoSwap = T_DOSWAP(info->OutputFormat); 2566 int Reverse = T_FLAVOR(info->OutputFormat); 2567 int Extra = T_EXTRA(info->OutputFormat); 2568 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2569 int Planar = T_PLANAR(info->OutputFormat); 2570 int ExtraFirst = DoSwap ^ SwapFirst; 2571 cmsFloat64Number maximum = IsInkSpace(info->OutputFormat) ? 100.0 : 1.0; 2572 cmsFloat64Number v = 0; 2573 cmsFloat64Number* swap1 = (cmsFloat64Number*)output; 2574 int i, start = 0; 2575 2576 if (ExtraFirst) 2577 start = Extra; 2578 2579 for (i = 0; i < nChan; i++) { 2580 2581 int index = DoSwap ? (nChan - i - 1) : i; 2582 2583 v = wOut[index] * maximum; 2584 2585 if (Reverse) 2586 v = maximum - v; 2587 2588 if (Planar) 2589 ((cmsFloat64Number*)output)[(i + start) * Stride] = v; 2590 else 2591 ((cmsFloat64Number*)output)[i + start] = v; 2592 } 2593 2594 if (Extra == 0 && SwapFirst) { 2595 2596 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsFloat64Number)); 2597 *swap1 = v; 2598 } 2599 2600 2601 if (T_PLANAR(info->OutputFormat)) 2602 return output + sizeof(cmsFloat64Number); 2603 else 2604 return output + (nChan + Extra) * sizeof(cmsFloat64Number); 2605 2606 } 2607 2608 2609 2610 2611 2612 static 2613 cmsUInt8Number* PackLabFloatFromFloat(_cmsTRANSFORM* Info, 2614 cmsFloat32Number wOut[], 2615 cmsUInt8Number* output, 2616 cmsUInt32Number Stride) 2617 { 2618 cmsFloat32Number* Out = (cmsFloat32Number*) output; 2619 2620 if (T_PLANAR(Info -> OutputFormat)) { 2621 2622 Out[0] = (cmsFloat32Number) (wOut[0] * 100.0); 2623 Out[Stride] = (cmsFloat32Number) (wOut[1] * 255.0 - 128.0); 2624 Out[Stride*2] = (cmsFloat32Number) (wOut[2] * 255.0 - 128.0); 2820 if (Extra == 0 && SwapFirst) { 2821 cmsFloat32Number tmp = wIn[0]; 2822 2823 memmove(&wIn[0], &wIn[1], (nChan-1) * sizeof(cmsFloat32Number)); 2824 wIn[nChan-1] = tmp; 2825 } 2826 2827 if (T_PLANAR(info -> InputFormat)) 2828 return accum + sizeof(cmsUInt16Number); 2829 else 2830 return accum + (nChan + Extra) * sizeof(cmsUInt16Number); 2831 } 2832 2833 2834 static 2835 cmsUInt8Number* PackHalfFrom16(register _cmsTRANSFORM* info, 2836 register cmsUInt16Number wOut[], 2837 register cmsUInt8Number* output, 2838 register cmsUInt32Number Stride) 2839 { 2840 int nChan = T_CHANNELS(info->OutputFormat); 2841 int DoSwap = T_DOSWAP(info->OutputFormat); 2842 int Reverse = T_FLAVOR(info->OutputFormat); 2843 int Extra = T_EXTRA(info->OutputFormat); 2844 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2845 int Planar = T_PLANAR(info->OutputFormat); 2846 int ExtraFirst = DoSwap ^ SwapFirst; 2847 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 655.35F : 65535.0F; 2848 cmsFloat32Number v = 0; 2849 cmsUInt16Number* swap1 = (cmsUInt16Number*)output; 2850 int i, start = 0; 2851 2852 if (ExtraFirst) 2853 start = Extra; 2854 2855 for (i = 0; i < nChan; i++) { 2856 2857 int index = DoSwap ? (nChan - i - 1) : i; 2858 2859 v = (cmsFloat32Number)wOut[index] / maximum; 2860 2861 if (Reverse) 2862 v = maximum - v; 2863 2864 if (Planar) 2865 ((cmsUInt16Number*)output)[(i + start) * Stride] = _cmsFloat2Half(v); 2866 else 2867 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v); 2868 } 2869 2870 2871 if (Extra == 0 && SwapFirst) { 2872 2873 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number)); 2874 *swap1 = _cmsFloat2Half(v); 2875 } 2876 2877 if (T_PLANAR(info->OutputFormat)) 2878 return output + sizeof(cmsUInt16Number); 2879 else 2880 return output + (nChan + Extra) * sizeof(cmsUInt16Number); 2881 } 2882 2883 2884 2885 static 2886 cmsUInt8Number* PackHalfFromFloat(_cmsTRANSFORM* info, 2887 cmsFloat32Number wOut[], 2888 cmsUInt8Number* output, 2889 cmsUInt32Number Stride) 2890 { 2891 int nChan = T_CHANNELS(info->OutputFormat); 2892 int DoSwap = T_DOSWAP(info->OutputFormat); 2893 int Reverse = T_FLAVOR(info->OutputFormat); 2894 int Extra = T_EXTRA(info->OutputFormat); 2895 int SwapFirst = T_SWAPFIRST(info->OutputFormat); 2896 int Planar = T_PLANAR(info->OutputFormat); 2897 int ExtraFirst = DoSwap ^ SwapFirst; 2898 cmsFloat32Number maximum = IsInkSpace(info->OutputFormat) ? 100.0F : 1.0F; 2899 cmsUInt16Number* swap1 = (cmsUInt16Number*)output; 2900 cmsFloat32Number v = 0; 2901 int i, start = 0; 2902 2903 if (ExtraFirst) 2904 start = Extra; 2905 2906 for (i = 0; i < nChan; i++) { 2907 2908 int index = DoSwap ? (nChan - i - 1) : i; 2909 2910 v = wOut[index] * maximum; 2911 2912 if (Reverse) 2913 v = maximum - v; 2914 2915 if (Planar) 2916 ((cmsUInt16Number*)output)[(i + start)* Stride] = _cmsFloat2Half(v); 2917 else 2918 ((cmsUInt16Number*)output)[i + start] = _cmsFloat2Half(v); 2919 } 2920 2921 2922 if (Extra == 0 && SwapFirst) { 2923 2924 memmove(swap1 + 1, swap1, (nChan - 1)* sizeof(cmsUInt16Number)); 2925 *swap1 = (cmsUInt16Number)_cmsFloat2Half(v); 2926 } 2927 2928 if (T_PLANAR(info->OutputFormat)) 2929 return output + sizeof(cmsUInt16Number); 2930 else 2931 return output + (nChan + Extra)* sizeof(cmsUInt16Number); 2932 } 2933 2934 #endif 2935 2936 // ---------------------------------------------------------------------------------------------------------------- 2937 2938 2939 static cmsFormatters16 InputFormatters16[] = { 2940 2941 // Type Mask Function 2942 // ---------------------------- ------------------------------------ ---------------------------- 2943 { TYPE_Lab_DBL, ANYPLANAR|ANYEXTRA, UnrollLabDoubleTo16}, 2944 { TYPE_XYZ_DBL, ANYPLANAR|ANYEXTRA, UnrollXYZDoubleTo16}, 2945 { TYPE_Lab_FLT, ANYPLANAR|ANYEXTRA, UnrollLabFloatTo16}, 2946 { TYPE_XYZ_FLT, ANYPLANAR|ANYEXTRA, UnrollXYZFloatTo16}, 2947 { TYPE_GRAY_DBL, 0, UnrollDouble1Chan}, 2948 { FLOAT_SH(1)|BYTES_SH(0), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2949 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollDoubleTo16}, 2950 { FLOAT_SH(1)|BYTES_SH(4), ANYCHANNELS|ANYPLANAR|ANYSWAPFIRST|ANYFLAVOR| 2951 ANYSWAP|ANYEXTRA|ANYSPACE, UnrollFloatTo16}, |