test/rgb_xyz_test.cc

   1 /*
   2     Copyright (C) 2014-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libdcp is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 #include "rgb_xyz.h"
  36 #include "openjpeg_image.h"
  37 #include "colour_conversion.h"
  38 #include "stream_operators.h"
  39 #include <boost/bind.hpp>
  40 #include <boost/random.hpp>
  41 #include <boost/scoped_array.hpp>
  42 #include <boost/test/unit_test.hpp>
  43
  44
  45 using std::cout;
  46 using std::list;
  47 using std::make_shared;
  48 using std::max;
  49 using std::shared_ptr;
  50 using std::string;
  51 using boost::optional;
  52 using boost::scoped_array;
  53
  54
  55 static
  56 void
  57 rgb_xyz_test_case (std::function<void (uint16_t*)> write_pixel)
  58 {
  59         srand (0);
  60         dcp::Size const size (640, 480);
  61
  62         scoped_array<uint8_t> rgb (new uint8_t[size.width * size.height * 6]);
  63         for (int y = 0; y < size.height; ++y) {
  64                 uint16_t* p = reinterpret_cast<uint16_t*> (rgb.get() + y * size.width * 6);
  65                 for (int x = 0; x < size.width; ++x) {
  66                         write_pixel (p);
  67                         p += 3;
  68                 }
  69         }
  70
  71         auto xyz = dcp::rgb_to_xyz (rgb.get(), size, size.width * 6, dcp::ColourConversion::srgb_to_xyz());
  72
  73         for (int y = 0; y < size.height; ++y) {
  74                 uint16_t* p = reinterpret_cast<uint16_t*> (rgb.get() + y * size.width * 6);
  75                 for (int x = 0; x < size.width; ++x) {
  76
  77                         double cr = *p++ / 65535.0;
  78                         double cg = *p++ / 65535.0;
  79                         double cb = *p++ / 65535.0;
  80
  81                         /* Input gamma */
  82
  83                         if (cr < 0.04045) {
  84                                 cr /= 12.92;
  85                         } else {
  86                                 cr = pow ((cr + 0.055) / 1.055, 2.4);
  87                         }
  88
  89                         if (cg < 0.04045) {
  90                                 cg /= 12.92;
  91                         } else {
  92                                 cg = pow ((cg + 0.055) / 1.055, 2.4);
  93                         }
  94
  95                         if (cb < 0.04045) {
  96                                 cb /= 12.92;
  97                         } else {
  98                                 cb = pow ((cb + 0.055) / 1.055, 2.4);
  99                         }
 100
 101                         /* Matrix */
 102
 103                         double cx = cr * 0.4124564 + cg * 0.3575761 + cb * 0.1804375;
 104                         double cy = cr * 0.2126729 + cg * 0.7151522 + cb * 0.0721750;
 105                         double cz = cr * 0.0193339 + cg * 0.1191920 + cb * 0.9503041;
 106
 107                         /* Compand */
 108
 109                         cx *= 48 / 52.37;
 110                         cy *= 48 / 52.37;
 111                         cz *= 48 / 52.37;
 112
 113                         /* Output gamma */
 114
 115                         cx = pow (cx, 1 / 2.6);
 116                         cy = pow (cy, 1 / 2.6);
 117                         cz = pow (cz, 1 / 2.6);
 118
 119                         BOOST_REQUIRE_CLOSE (cx * 4095, xyz->data(0)[y * size.width + x], 1);
 120                         BOOST_REQUIRE_CLOSE (cy * 4095, xyz->data(1)[y * size.width + x], 1);
 121                         BOOST_REQUIRE_CLOSE (cz * 4095, xyz->data(2)[y * size.width + x], 1);
 122                 }
 123         }
 124 }
 125
 126
 127 /** Convert a test image from sRGB to XYZ and check that the transforms are right */
 128 BOOST_AUTO_TEST_CASE (rgb_xyz_test)
 129 {
 130         {
 131                 int counter = 0;
 132                 rgb_xyz_test_case ([&counter](uint16_t* p) {
 133                         p[0] = p[1] = p[2] = (counter << 4);
 134                         ++counter;
 135                         if (counter >= 4096) {
 136                                 counter = 0;
 137                         }
 138                 });
 139         }
 140
 141         boost::random::mt19937 rng(1);
 142         boost::random::uniform_int_distribution<> dist(0, 4095);
 143
 144         rgb_xyz_test_case ([&rng, &dist](uint16_t* p) {
 145                            p[0] = dist(rng) << 4;
 146                            p[1] = dist(rng) << 4;
 147                            p[2] = dist(rng) << 4;
 148                            });
 149 }
 150
 151
 152 static list<string> notes;
 153
 154 static void
 155 note_handler (dcp::NoteType n, string s)
 156 {
 157         BOOST_REQUIRE_EQUAL (n, dcp::NoteType::NOTE);
 158         notes.push_back (s);
 159 }
 160
 161 /** Check that xyz_to_rgb clamps XYZ values correctly */
 162 BOOST_AUTO_TEST_CASE (xyz_rgb_range_test)
 163 {
 164         auto xyz = make_shared<dcp::OpenJPEGImage>(dcp::Size(2, 2));
 165
 166         xyz->data(0)[0] = -4;
 167         xyz->data(0)[1] = 6901;
 168         xyz->data(0)[2] = 0;
 169         xyz->data(0)[3] = 4095;
 170         xyz->data(1)[0] = -4;
 171         xyz->data(1)[1] = 6901;
 172         xyz->data(1)[2] = 0;
 173         xyz->data(1)[3] = 4095;
 174         xyz->data(2)[0] = -4;
 175         xyz->data(2)[1] = 6901;
 176         xyz->data(2)[2] = 0;
 177         xyz->data(2)[3] = 4095;
 178
 179         scoped_array<uint8_t> rgb (new uint8_t[2 * 2 * 6]);
 180
 181         notes.clear ();
 182         dcp::xyz_to_rgb (
 183                 xyz, dcp::ColourConversion::srgb_to_xyz (), rgb.get(), 2 * 6, boost::optional<dcp::NoteHandler> (boost::bind (&note_handler, _1, _2))
 184                 );
 185
 186         /* The 6 out-of-range samples should have been noted */
 187         BOOST_REQUIRE_EQUAL (notes.size(), 6U);
 188         auto i = notes.begin ();
 189         BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
 190         BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
 191         BOOST_REQUIRE_EQUAL (*i++, "XYZ value -4 out of range");
 192         BOOST_REQUIRE_EQUAL (*i++, "XYZ value 6901 out of range");
 193         BOOST_REQUIRE_EQUAL (*i++, "XYZ value 6901 out of range");
 194         BOOST_REQUIRE_EQUAL (*i++, "XYZ value 6901 out of range");
 195
 196         /* And those samples should have been clamped, so check that they give the same result
 197            as inputs at the extremes (0 and 4095).
 198         */
 199
 200         auto buffer = reinterpret_cast<uint16_t*> (rgb.get ());
 201         BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 0], buffer[2 * 3 + 1]);
 202         BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 1], buffer[2 * 3 + 1]);
 203         BOOST_REQUIRE_EQUAL (buffer[0 * 3 + 2], buffer[2 * 3 + 2]);
 204
 205         BOOST_REQUIRE_EQUAL (buffer[1 * 3 + 0], buffer[3 * 3 + 0]);
 206         BOOST_REQUIRE_EQUAL (buffer[1 * 3 + 1], buffer[3 * 3 + 1]);
 207         BOOST_REQUIRE_EQUAL (buffer[1 * 3 + 2], buffer[3 * 3 + 2]);
 208 }
 209
 210 /** Convert an image from RGB to XYZ and back again */
 211 BOOST_AUTO_TEST_CASE (rgb_xyz_round_trip_test)
 212 {
 213         srand (0);
 214         dcp::Size const size (640, 480);
 215
 216         scoped_array<uint8_t> rgb (new uint8_t[size.width * size.height * 6]);
 217         for (int y = 0; y < size.height; ++y) {
 218                 uint16_t* p = reinterpret_cast<uint16_t*> (rgb.get() + y * size.width * 6);
 219                 for (int x = 0; x < size.width; ++x) {
 220                         /* Write a 12-bit random number for each component */
 221                         for (int c = 0; c < 3; ++c) {
 222                                 *p = (rand () & 0xfff) << 4;
 223                                 ++p;
 224                         }
 225                 }
 226         }
 227
 228         shared_ptr<dcp::OpenJPEGImage> xyz = dcp::rgb_to_xyz (rgb.get(), size, size.width * 6, dcp::ColourConversion::srgb_to_xyz ());
 229         scoped_array<uint8_t> back (new uint8_t[size.width * size.height * 6]);
 230         dcp::xyz_to_rgb (xyz, dcp::ColourConversion::srgb_to_xyz (), back.get(), size.width * 6);
 231
 232 #if 0
 233         uint16_t* p = reinterpret_cast<uint16_t*> (rgb.get ());
 234         uint16_t* q = reinterpret_cast<uint16_t*> (back.get ());
 235         for (int i = 0; i < (size.width * size.height); ++i) {
 236                 /* XXX: doesn't quite work */
 237                 // BOOST_REQUIRE_EQUAL (*p++, *q++);
 238         }
 239 #endif
 240 }