Fix founding difference in pdfium_test on AdobeCMYK_to_sRGB

core/fxcodec/codec/fx_codec_icc.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxcodec/codec/codec_int.h"
 #include "core/fxcodec/fx_codec.h"
 #include "third_party/lcms2-2.6/include/lcms2.h"
 
@@ skipping 1645 matching lines @@
 void AdobeCMYK_to_sRGB(FX_FLOAT c,
                        FX_FLOAT m,
                        FX_FLOAT y,
                        FX_FLOAT k,
                        FX_FLOAT& R,
                        FX_FLOAT& G,
                        FX_FLOAT& B) {
   // Convert to uint8_t with round-to-nearest. Avoid using FXSYS_round because
   // it is incredibly expensive with VC++ (tested on VC++ 2015) because round()
   // is very expensive.
-  // Adding 0.5f and truncating can round the wrong direction in some edge
-  // cases but these do not matter in this context. For instance, the float that
-  // is one ULP (unit in the last place) before 0.5 should round to zero but
-  // this will round it to one. These edge cases are never hit in this function
-  // due to the very limited precision of the input integers.
-  // This method also doesn't handle negative or extremely large numbers, but
-  // those are not needed here.
-  uint8_t c1 = int(c * 255.f + 0.5f);
-  uint8_t m1 = int(m * 255.f + 0.5f);
-  uint8_t y1 = int(y * 255.f + 0.5f);
-  uint8_t k1 = int(k * 255.f + 0.5f);
+  // The 'magic' value of 0.49999997f, the float that precedes 0.5f, was chosen
+  // because it gives identical results to FXSYS_round(). Using the constant
+  // 0.5f gives different results (1 instead of 0) for one value, 0.0019607842.
+  // That value is close to the cusp but zero is the correct answer, and
+  // getting the same answer as before is desirable.
+  // All floats from 0.0 to 1.0 were tested and now give the same results.
+  const float rounding_offset = 0.49999997f;
+  uint8_t c1 = int(c * 255.f + rounding_offset);
+  uint8_t m1 = int(m * 255.f + rounding_offset);
+  uint8_t y1 = int(y * 255.f + rounding_offset);
+  uint8_t k1 = int(k * 255.f + rounding_offset);
 
   ASSERT(c1 == FXSYS_round(c * 255));
   ASSERT(m1 == FXSYS_round(m * 255));
   ASSERT(y1 == FXSYS_round(y * 255));
   ASSERT(k1 == FXSYS_round(k * 255));
 
   uint8_t r, g, b;
   AdobeCMYK_to_sRGB1(c1, m1, y1, k1, r, g, b);
   // Multiply by a constant rather than dividing because division is much
   // more expensive.
   R = r * (1.0f / 255);
   G = g * (1.0f / 255);
   B = b * (1.0f / 255);
 }