1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 // This file is available under and governed by the GNU General Public
  26 // License version 2 only, as published by the Free Software Foundation.
  27 // However, the following notice accompanied the original version of this
  28 // file:
  29 //
  30 //---------------------------------------------------------------------------------
  31 //
  32 //  Little Color Management System
  33 //  Copyright (c) 1998-2017 Marti Maria Saguer
  34 //
  35 // Permission is hereby granted, free of charge, to any person obtaining
  36 // a copy of this software and associated documentation files (the "Software"),
  37 // to deal in the Software without restriction, including without limitation
  38 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  39 // and/or sell copies of the Software, and to permit persons to whom the Software
  40 // is furnished to do so, subject to the following conditions:
  41 //
  42 // The above copyright notice and this permission notice shall be included in
  43 // all copies or substantial portions of the Software.
  44 //
  45 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  46 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  47 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  48 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  49 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  50 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  51 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  52 //
  53 //---------------------------------------------------------------------------------
  54 //
  55 
  56 #include "lcms2_internal.h"
  57 
  58 // Alpha copy ------------------------------------------------------------------------------------------------------------------
  59 




  60 // Floor to byte, taking care of saturation
  61 cmsINLINE cmsUInt8Number _cmsQuickSaturateByte(cmsFloat64Number d)
  62 {
  63        d += 0.5;
  64        if (d <= 0) return 0;
  65        if (d >= 255.0) return 255;
  66 
  67        return (cmsUInt8Number) _cmsQuickFloorWord(d);
  68 }
  69 
  70 
  71 // Return the size in bytes of a given formatter
  72 static
  73 cmsUInt32Number trueBytesSize(cmsUInt32Number Format)
  74 {
  75     cmsUInt32Number fmt_bytes = T_BYTES(Format);
  76 
  77     // For double, the T_BYTES field returns zero
  78     if (fmt_bytes == 0)
  79         return sizeof(double);
  80 
  81     // Otherwise, it is already correct for all formats
  82     return fmt_bytes;
  83 }
  84 
  85 
  86 // Several format converters
  87 
  88 typedef void(*cmsFormatterAlphaFn)(void* dst, const void* src);
  89 
  90 
  91 // From 8
  92 
  93 static
  94 void copy8(void* dst, const void* src)
  95 {
  96        memmove(dst, src, 1);
  97 }
  98 
  99 static
 100 void from8to16(void* dst, const void* src)
 101 {
 102        cmsUInt8Number n = *(cmsUInt8Number*)src;
 103        *(cmsUInt16Number*) dst = FROM_8_TO_16(n);
 104 }
 105 
 106 static







 107 void from8toFLT(void* dst, const void* src)
 108 {
 109        *(cmsFloat32Number*)dst = (*(cmsUInt8Number*)src) / 255.0f;
 110 }
 111 
 112 static
 113 void from8toDBL(void* dst, const void* src)
 114 {
 115        *(cmsFloat64Number*)dst = (*(cmsUInt8Number*)src) / 255.0;
 116 }
 117 
 118 static
 119 void from8toHLF(void* dst, const void* src)
 120 {
 121 #ifndef CMS_NO_HALF_SUPPORT
 122        cmsFloat32Number n = (*(cmsUInt8Number*)src) / 255.0f;
 123        *(cmsUInt16Number*)dst = _cmsFloat2Half(n);
 124 #else
 125     cmsUNUSED_PARAMETER(dst);
 126     cmsUNUSED_PARAMETER(src);
 127 #endif
 128 }
 129 
 130 // From 16
 131 
 132 static
 133 void from16to8(void* dst, const void* src)
 134 {
 135        cmsUInt16Number n = *(cmsUInt16Number*)src;
 136        *(cmsUInt8Number*) dst = FROM_16_TO_8(n);
 137 }
 138 
 139 static







 140 void copy16(void* dst, const void* src)
 141 {
 142        memmove(dst, src, 2);
 143 }
 144 








 145 void from16toFLT(void* dst, const void* src)
 146 {
 147        *(cmsFloat32Number*)dst = (*(cmsUInt16Number*)src) / 65535.0f;
 148 }
 149 







 150 void from16toDBL(void* dst, const void* src)
 151 {
 152        *(cmsFloat64Number*)dst = (*(cmsUInt16Number*)src) / 65535.0f;
 153 }
 154 
 155 static






 156 void from16toHLF(void* dst, const void* src)
 157 {
 158 #ifndef CMS_NO_HALF_SUPPORT
 159        cmsFloat32Number n = (*(cmsUInt16Number*)src) / 65535.0f;
 160        *(cmsUInt16Number*)dst = _cmsFloat2Half(n);
 161 #else
 162     cmsUNUSED_PARAMETER(dst);
 163     cmsUNUSED_PARAMETER(src);
 164 #endif
 165 }
 166 











 167 // From Float
 168 
 169 static
 170 void fromFLTto8(void* dst, const void* src)
 171 {
 172        cmsFloat32Number n = *(cmsFloat32Number*)src;
 173        *(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0f);
 174 }
 175 
 176 static
 177 void fromFLTto16(void* dst, const void* src)
 178 {
 179        cmsFloat32Number n = *(cmsFloat32Number*)src;
 180        *(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
 181 }
 182 
 183 static









 184 void copy32(void* dst, const void* src)
 185 {
 186        memmove(dst, src, sizeof(cmsFloat32Number));
 187 }
 188 
 189 static
 190 void fromFLTtoDBL(void* dst, const void* src)
 191 {
 192        cmsFloat32Number n = *(cmsFloat32Number*)src;
 193        *(cmsFloat64Number*)dst = (cmsFloat64Number)n;
 194 }
 195 
 196 static
 197 void fromFLTtoHLF(void* dst, const void* src)
 198 {
 199 #ifndef CMS_NO_HALF_SUPPORT
 200        cmsFloat32Number n = *(cmsFloat32Number*)src;
 201        *(cmsUInt16Number*)dst = _cmsFloat2Half(n);
 202 #else
 203     cmsUNUSED_PARAMETER(dst);
 204     cmsUNUSED_PARAMETER(src);
 205 #endif
 206 }
 207 
 208 
 209 // From HALF
 210 
 211 static
 212 void fromHLFto8(void* dst, const void* src)
 213 {
 214 #ifndef CMS_NO_HALF_SUPPORT
 215        cmsFloat32Number n = _cmsHalf2Float(*(cmsUInt16Number*)src);
 216        *(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0f);
 217 #else
 218     cmsUNUSED_PARAMETER(dst);
 219     cmsUNUSED_PARAMETER(src);
 220 #endif
 221 
 222 }
 223 
 224 static
 225 void fromHLFto16(void* dst, const void* src)
 226 {
 227 #ifndef CMS_NO_HALF_SUPPORT
 228        cmsFloat32Number n = _cmsHalf2Float(*(cmsUInt16Number*)src);
 229        *(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
 230 #else
 231     cmsUNUSED_PARAMETER(dst);
 232     cmsUNUSED_PARAMETER(src);
 233 #endif
 234 }
 235 
 236 static













 237 void fromHLFtoFLT(void* dst, const void* src)
 238 {
 239 #ifndef CMS_NO_HALF_SUPPORT
 240        *(cmsFloat32Number*)dst = _cmsHalf2Float(*(cmsUInt16Number*)src);
 241 #else
 242     cmsUNUSED_PARAMETER(dst);
 243     cmsUNUSED_PARAMETER(src);
 244 #endif
 245 }
 246 
 247 static
 248 void fromHLFtoDBL(void* dst, const void* src)
 249 {
 250 #ifndef CMS_NO_HALF_SUPPORT
 251        *(cmsFloat64Number*)dst = (cmsFloat64Number)_cmsHalf2Float(*(cmsUInt16Number*)src);
 252 #else
 253     cmsUNUSED_PARAMETER(dst);
 254     cmsUNUSED_PARAMETER(src);
 255 #endif
 256 }
 257 
 258 // From double
 259 static
 260 void fromDBLto8(void* dst, const void* src)
 261 {
 262        cmsFloat64Number n = *(cmsFloat64Number*)src;
 263        *(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0);
 264 }
 265 
 266 static
 267 void fromDBLto16(void* dst, const void* src)
 268 {
 269        cmsFloat64Number n = *(cmsFloat64Number*)src;
 270        *(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
 271 }
 272 
 273 static








 274 void fromDBLtoFLT(void* dst, const void* src)
 275 {
 276        cmsFloat64Number n = *(cmsFloat64Number*)src;
 277        *(cmsFloat32Number*)dst = (cmsFloat32Number) n;
 278 }
 279 
 280 static
 281 void fromDBLtoHLF(void* dst, const void* src)
 282 {
 283 #ifndef CMS_NO_HALF_SUPPORT
 284        cmsFloat32Number n = (cmsFloat32Number) *(cmsFloat64Number*)src;
 285        *(cmsUInt16Number*)dst = _cmsFloat2Half(n);
 286 #else
 287     cmsUNUSED_PARAMETER(dst);
 288     cmsUNUSED_PARAMETER(src);
 289 #endif
 290 }
 291 
 292 static
 293 void copy64(void* dst, const void* src)
 294 {
 295        memmove(dst, src, sizeof(cmsFloat64Number));
 296 }
 297 
 298 
 299 // Returns the position (x or y) of the formatter in the table of functions
 300 static
 301 int FormatterPos(cmsUInt32Number frm)
 302 {
 303     cmsUInt32Number  b = T_BYTES(frm);
 304 
 305     if (b == 0 && T_FLOAT(frm))
 306         return 4; // DBL
 307 #ifndef CMS_NO_HALF_SUPPORT
 308     if (b == 2 && T_FLOAT(frm))
 309         return 2; // HLF
 310 #endif
 311     if (b == 4 && T_FLOAT(frm))
 312         return 3; // FLT
 313     if (b == 2 && !T_FLOAT(frm))




 314         return 1; // 16

 315     if (b == 1 && !T_FLOAT(frm))
 316         return 0; // 8
 317 
 318     return -1; // not recognized
 319 }
 320 
 321 // Obtains a alpha-to-alpha funmction formatter
 322 static
 323 cmsFormatterAlphaFn _cmsGetFormatterAlpha(cmsContext id, cmsUInt32Number in, cmsUInt32Number out)
 324 {
 325 static cmsFormatterAlphaFn FormattersAlpha[5][5] = {
 326 
 327        /* from 8 */  { copy8,      from8to16,   from8toHLF,   from8toFLT,   from8toDBL   },
 328        /* from 16*/  { from16to8,  copy16,      from16toHLF,  from16toFLT,  from16toDBL  },
 329        /* from HLF*/ { fromHLFto8, fromHLFto16, copy16,       fromHLFtoFLT, fromHLFtoDBL },
 330        /* from FLT*/ { fromFLTto8, fromFLTto16, fromFLTtoHLF, copy32,       fromFLTtoDBL },
 331        /* from DBL*/ { fromDBLto8, fromDBLto16, fromDBLtoHLF, fromDBLtoFLT, copy64 }};

 332 
 333         int in_n  = FormatterPos(in);
 334         int out_n = FormatterPos(out);
 335 
 336         if (in_n < 0 || out_n < 0 || in_n > 4 || out_n > 4) {
 337 
 338                cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized alpha channel width");
 339                return NULL;
 340         }
 341 
 342         return FormattersAlpha[in_n][out_n];
 343 }
 344 
 345 
 346 
 347 // This function computes the distance from each component to the next one in bytes.
 348 static
 349 void ComputeIncrementsForChunky(cmsUInt32Number Format,
 350                                 cmsUInt32Number ComponentStartingOrder[],
 351                                 cmsUInt32Number ComponentPointerIncrements[])
 352 {
 353        cmsUInt32Number channels[cmsMAXCHANNELS];
 354        cmsUInt32Number extra = T_EXTRA(Format);
 355        cmsUInt32Number nchannels = T_CHANNELS(Format);
 356        cmsUInt32Number total_chans = nchannels + extra;
 357        cmsUInt32Number i;
 358        cmsUInt32Number channelSize = trueBytesSize(Format);
 359        cmsUInt32Number pixelSize = channelSize * total_chans;
 360 
 361            // Sanity check
 362            if (total_chans <= 0 || total_chans >= cmsMAXCHANNELS)
 363                    return;
 364 
 365         memset(channels, 0, sizeof(channels));
 366 
 367        // Separation is independent of starting point and only depends on channel size
 368        for (i = 0; i < extra; i++)
 369               ComponentPointerIncrements[i] = pixelSize;
 370 
 371        // Handle do swap
 372        for (i = 0; i < total_chans; i++)
 373        {
 374               if (T_DOSWAP(Format)) {
 375                      channels[i] = total_chans - i - 1;
 376               }
 377               else {
 378                      channels[i] = i;
 379               }
 380        }
 381 
 382        // Handle swap first (ROL of positions), example CMYK -> KCMY | 0123 -> 3012
 383        if (T_SWAPFIRST(Format) && total_chans > 1) {
 384 
 385               cmsUInt32Number tmp = channels[0];
 386               for (i = 0; i < total_chans-1; i++)
 387                      channels[i] = channels[i + 1];
 388 
 389               channels[total_chans - 1] = tmp;
 390        }
 391 
 392        // Handle size
 393        if (channelSize > 1)
 394               for (i = 0; i < total_chans; i++) {
 395                      channels[i] *= channelSize;
 396               }
 397 
 398        for (i = 0; i < extra; i++)
 399               ComponentStartingOrder[i] = channels[i + nchannels];
 400 }
 401 
 402 
 403 
 404 //  On planar configurations, the distance is the stride added to any non-negative
 405 static
 406 void ComputeIncrementsForPlanar(cmsUInt32Number Format,
 407                                 cmsUInt32Number BytesPerPlane,
 408                                 cmsUInt32Number ComponentStartingOrder[],
 409                                 cmsUInt32Number ComponentPointerIncrements[])
 410 {
 411        cmsUInt32Number channels[cmsMAXCHANNELS];
 412        cmsUInt32Number extra = T_EXTRA(Format);
 413        cmsUInt32Number nchannels = T_CHANNELS(Format);
 414        cmsUInt32Number total_chans = nchannels + extra;
 415        cmsUInt32Number i;
 416        cmsUInt32Number channelSize = trueBytesSize(Format);
 417 
 418        // Sanity check
 419        if (total_chans <= 0 || total_chans >= cmsMAXCHANNELS)
 420            return;
 421 
 422        memset(channels, 0, sizeof(channels));
 423 
 424        // Separation is independent of starting point and only depends on channel size
 425        for (i = 0; i < extra; i++)
 426               ComponentPointerIncrements[i] = channelSize;
 427 
 428        // Handle do swap
 429        for (i = 0; i < total_chans; i++)
 430        {
 431               if (T_DOSWAP(Format)) {
 432                      channels[i] = total_chans - i - 1;
 433               }
 434               else {
 435                      channels[i] = i;
 436               }
 437        }
 438 
 439        // Handle swap first (ROL of positions), example CMYK -> KCMY | 0123 -> 3012
 440        if (T_SWAPFIRST(Format) && total_chans > 0) {
 441 
 442               cmsUInt32Number tmp = channels[0];
 443               for (i = 0; i < total_chans - 1; i++)
 444                      channels[i] = channels[i + 1];
 445 
 446               channels[total_chans - 1] = tmp;
 447        }
 448 
 449        // Handle size
 450        for (i = 0; i < total_chans; i++) {
 451               channels[i] *= BytesPerPlane;
 452        }
 453 
 454        for (i = 0; i < extra; i++)
 455               ComponentStartingOrder[i] = channels[i + nchannels];
 456 }
 457 
 458 
 459 
 460 // Dispatcher por chunky and planar RGB
 461 static
 462 void  ComputeComponentIncrements(cmsUInt32Number Format,
 463                                  cmsUInt32Number BytesPerPlane,
 464                                  cmsUInt32Number ComponentStartingOrder[],
 465                                  cmsUInt32Number ComponentPointerIncrements[])
 466 {
 467        if (T_PLANAR(Format)) {
 468 
 469               ComputeIncrementsForPlanar(Format,  BytesPerPlane, ComponentStartingOrder, ComponentPointerIncrements);
 470        }
 471        else {
 472               ComputeIncrementsForChunky(Format,  ComponentStartingOrder, ComponentPointerIncrements);
 473        }
 474 
 475 }
 476 
 477 
 478 
 479 // Handles extra channels copying alpha if requested by the flags
 480 void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
 481                                                void* out,
 482                                                cmsUInt32Number PixelsPerLine,
 483                                                cmsUInt32Number LineCount,
 484                                                const cmsStride* Stride)
 485 {
 486     cmsUInt32Number i, j, k;
 487     cmsUInt32Number nExtra;
 488     cmsUInt32Number SourceStartingOrder[cmsMAXCHANNELS];
 489     cmsUInt32Number SourceIncrements[cmsMAXCHANNELS];
 490     cmsUInt32Number DestStartingOrder[cmsMAXCHANNELS];
 491     cmsUInt32Number DestIncrements[cmsMAXCHANNELS];
 492 
 493     cmsFormatterAlphaFn copyValueFn;
 494 
 495     // Make sure we need some copy
 496     if (!(p->dwOriginalFlags & cmsFLAGS_COPY_ALPHA))
 497         return;
 498 
 499     // Exit early if in-place color-management is occurring - no need to copy extra channels to themselves.
 500     if (p->InputFormat == p->OutputFormat && in == out)
 501         return;
 502 
 503     // Make sure we have same number of alpha channels. If not, just return as this should be checked at transform creation time.
 504     nExtra = T_EXTRA(p->InputFormat);
 505     if (nExtra != T_EXTRA(p->OutputFormat))
 506         return;
 507 
 508     // Anything to do?
 509     if (nExtra == 0)
 510         return;
 511 
 512     // Compute the increments
 513     ComputeComponentIncrements(p->InputFormat, Stride->BytesPerPlaneIn, SourceStartingOrder, SourceIncrements);
 514     ComputeComponentIncrements(p->OutputFormat, Stride->BytesPerPlaneOut, DestStartingOrder, DestIncrements);
 515 
 516     // Check for conversions 8, 16, half, float, dbl
 517     copyValueFn = _cmsGetFormatterAlpha(p->ContextID, p->InputFormat, p->OutputFormat);


 518 
 519     if (nExtra == 1) { // Optimized routine for copying a single extra channel quickly
 520 
 521         cmsUInt8Number* SourcePtr;
 522         cmsUInt8Number* DestPtr;
 523 
 524         cmsUInt32Number SourceStrideIncrement = 0;
 525         cmsUInt32Number DestStrideIncrement = 0;
 526 
 527         // The loop itself
 528         for (i = 0; i < LineCount; i++) {
 529 
 530             // Prepare pointers for the loop
 531             SourcePtr = (cmsUInt8Number*)in + SourceStartingOrder[0] + SourceStrideIncrement;
 532             DestPtr = (cmsUInt8Number*)out + DestStartingOrder[0] + DestStrideIncrement;
 533 
 534             for (j = 0; j < PixelsPerLine; j++) {
 535 
 536                 copyValueFn(DestPtr, SourcePtr);
 537 
 538                 SourcePtr += SourceIncrements[0];
 539                 DestPtr += DestIncrements[0];
 540             }
 541 
 542             SourceStrideIncrement += Stride->BytesPerLineIn;
 543             DestStrideIncrement += Stride->BytesPerLineOut;
 544         }
 545 
 546     }
 547     else { // General case with more than one extra channel
 548 
 549         cmsUInt8Number* SourcePtr[cmsMAXCHANNELS];
 550         cmsUInt8Number* DestPtr[cmsMAXCHANNELS];
 551 
 552         cmsUInt32Number SourceStrideIncrements[cmsMAXCHANNELS];
 553         cmsUInt32Number DestStrideIncrements[cmsMAXCHANNELS];
 554 
 555         memset(SourceStrideIncrements, 0, sizeof(SourceStrideIncrements));
 556         memset(DestStrideIncrements, 0, sizeof(DestStrideIncrements));
 557 
 558         // The loop itself
 559         for (i = 0; i < LineCount; i++) {
 560 
 561             // Prepare pointers for the loop
 562             for (j = 0; j < nExtra; j++) {
 563 
 564                 SourcePtr[j] = (cmsUInt8Number*)in + SourceStartingOrder[j] + SourceStrideIncrements[j];
 565                 DestPtr[j] = (cmsUInt8Number*)out + DestStartingOrder[j] + DestStrideIncrements[j];
 566             }
 567 
 568             for (j = 0; j < PixelsPerLine; j++) {
 569 
 570                 for (k = 0; k < nExtra; k++) {
 571 
 572                     copyValueFn(DestPtr[k], SourcePtr[k]);
 573 
 574                     SourcePtr[k] += SourceIncrements[k];
 575                     DestPtr[k] += DestIncrements[k];
 576                 }
 577             }
 578 
 579             for (j = 0; j < nExtra; j++) {
 580 
 581                 SourceStrideIncrements[j] += Stride->BytesPerLineIn;
 582                 DestStrideIncrements[j] += Stride->BytesPerLineOut;
 583             }
 584         }
 585     }
 586 }
 587 
 588 
--- EOF ---