src/share/native/sun/java2d/cmm/lcms/cmspack.c

Print this page




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},