X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Frgb_xyz.cc;h=a3f7b424d49e7c5a7300581c8a646733febc8fd3;hb=7fb85beb1e4b655da0463d7d9c95b1181f5a6f00;hp=72ee38c1c5802a91d0ea5a5d3aae392c78779d7b;hpb=2f0e6ee9d883abbbc31aca0d1cc80e89eb9b0af2;p=libdcp.git diff --git a/src/rgb_xyz.cc b/src/rgb_xyz.cc index 72ee38c1..a3f7b424 100644 --- a/src/rgb_xyz.cc +++ b/src/rgb_xyz.cc @@ -20,9 +20,11 @@ #include "rgb_xyz.h" #include "argb_frame.h" #include "xyz_frame.h" -#include "gamma_lut.h" #include "image.h" #include "colour_matrix.h" +#include "colour_conversion.h" +#include "transfer_function.h" +#include "dcp_assert.h" #include using std::min; @@ -32,20 +34,17 @@ using namespace dcp; #define DCI_COEFFICIENT (48.0 / 52.37) -/** Convert an openjpeg XYZ image to RGB. +/** Convert an openjpeg XYZ image to RGBA. * @param xyz_frame Frame in XYZ. - * @param lut_in Input Gamma LUT to use. - * @param lut_out Output Gamma LUT to use. * @return RGB image. */ shared_ptr -dcp::xyz_to_rgb ( +dcp::xyz_to_rgba ( boost::shared_ptr xyz_frame, - boost::shared_ptr lut_in, - boost::shared_ptr lut_out + ColourConversion const & conversion ) { - int const max_colour = pow (2, lut_out->bit_depth()) - 1; + int const max_colour = pow (2, 12) - 1; struct { double x, y, z; @@ -60,19 +59,22 @@ dcp::xyz_to_rgb ( int* xyz_z = xyz_frame->data (2); shared_ptr argb_frame (new ARGBFrame (xyz_frame->size ())); - uint8_t* argb = argb_frame->data (); + double const * lut_in = conversion.in()->lut (16); + double const * lut_out = conversion.out()->lut (12); + boost::numeric::ublas::matrix matrix = conversion.matrix (); + for (int y = 0; y < xyz_frame->size().height; ++y) { uint8_t* argb_line = argb; for (int x = 0; x < xyz_frame->size().width; ++x) { - assert (*xyz_x >= 0 && *xyz_y >= 0 && *xyz_z >= 0 && *xyz_x < 4096 && *xyz_y < 4096 && *xyz_z < 4096); + DCP_ASSERT (*xyz_x >= 0 && *xyz_y >= 0 && *xyz_z >= 0 && *xyz_x < 4096 && *xyz_y < 4096 && *xyz_z < 4096); /* In gamma LUT */ - s.x = lut_in->lut()[*xyz_x++]; - s.y = lut_in->lut()[*xyz_y++]; - s.z = lut_in->lut()[*xyz_z++]; + s.x = lut_in[*xyz_x++]; + s.y = lut_in[*xyz_y++]; + s.z = lut_in[*xyz_z++]; /* DCI companding */ s.x /= DCI_COEFFICIENT; @@ -80,9 +82,9 @@ dcp::xyz_to_rgb ( s.z /= DCI_COEFFICIENT; /* XYZ to RGB */ - d.r = ((s.x * colour_matrix::xyz_to_rgb[0][0]) + (s.y * colour_matrix::xyz_to_rgb[0][1]) + (s.z * colour_matrix::xyz_to_rgb[0][2])); - d.g = ((s.x * colour_matrix::xyz_to_rgb[1][0]) + (s.y * colour_matrix::xyz_to_rgb[1][1]) + (s.z * colour_matrix::xyz_to_rgb[1][2])); - d.b = ((s.x * colour_matrix::xyz_to_rgb[2][0]) + (s.y * colour_matrix::xyz_to_rgb[2][1]) + (s.z * colour_matrix::xyz_to_rgb[2][2])); + d.r = ((s.x * matrix(0, 0)) + (s.y * matrix(0, 1)) + (s.z * matrix(0, 2))); + d.g = ((s.x * matrix(1, 0)) + (s.y * matrix(1, 1)) + (s.z * matrix(1, 2))); + d.b = ((s.x * matrix(2, 0)) + (s.y * matrix(2, 1)) + (s.z * matrix(2, 2))); d.r = min (d.r, 1.0); d.r = max (d.r, 0.0); @@ -94,9 +96,9 @@ dcp::xyz_to_rgb ( d.b = max (d.b, 0.0); /* Out gamma LUT */ - *argb_line++ = lut_out->lut()[(int) (d.b * max_colour)] * 0xff; - *argb_line++ = lut_out->lut()[(int) (d.g * max_colour)] * 0xff; - *argb_line++ = lut_out->lut()[(int) (d.r * max_colour)] * 0xff; + *argb_line++ = lut_out[int(rint(d.b * max_colour))] * 0xff; + *argb_line++ = lut_out[int(rint(d.g * max_colour))] * 0xff; + *argb_line++ = lut_out[int(rint(d.r * max_colour))] * 0xff; *argb_line++ = 0xff; } @@ -106,17 +108,85 @@ dcp::xyz_to_rgb ( return argb_frame; } +/** Convert an openjpeg XYZ image to RGB. + * @param xyz_frame Frame in XYZ. + * @param conversion Colour conversion to use. + * @param buffer Buffer to write RGB data to; rgb will be packed RGB + * 16:16:16, 48bpp, 16R, 16G, 16B, with the 2-byte value for each + * R/G/B component stored as little-endian; i.e. AV_PIX_FMT_RGB48LE. + */ +void +dcp::xyz_to_rgb ( + boost::shared_ptr xyz_frame, + ColourConversion const & conversion, + uint16_t* buffer + ) +{ + struct { + double x, y, z; + } s; + + struct { + double r, g, b; + } d; + + /* These should be 12-bit values from 0-4095 */ + int* xyz_x = xyz_frame->data (0); + int* xyz_y = xyz_frame->data (1); + int* xyz_z = xyz_frame->data (2); + + double const * lut_in = conversion.in()->lut (12); + double const * lut_out = conversion.out()->lut (16); + boost::numeric::ublas::matrix matrix = conversion.matrix (); + + for (int y = 0; y < xyz_frame->size().height; ++y) { + uint16_t* buffer_line = buffer; + for (int x = 0; x < xyz_frame->size().width; ++x) { + + DCP_ASSERT (*xyz_x >= 0 && *xyz_y >= 0 && *xyz_z >= 0 && *xyz_x < 4096 && *xyz_y < 4096 && *xyz_z < 4096); + + /* In gamma LUT */ + s.x = lut_in[*xyz_x++]; + s.y = lut_in[*xyz_y++]; + s.z = lut_in[*xyz_z++]; + + /* DCI companding */ + s.x /= DCI_COEFFICIENT; + s.y /= DCI_COEFFICIENT; + s.z /= DCI_COEFFICIENT; + + /* XYZ to RGB */ + d.r = ((s.x * matrix(0, 0)) + (s.y * matrix(0, 1)) + (s.z * matrix(0, 2))); + d.g = ((s.x * matrix(1, 0)) + (s.y * matrix(1, 1)) + (s.z * matrix(1, 2))); + d.b = ((s.x * matrix(2, 0)) + (s.y * matrix(2, 1)) + (s.z * matrix(2, 2))); + + d.r = min (d.r, 1.0); + d.r = max (d.r, 0.0); + + d.g = min (d.g, 1.0); + d.g = max (d.g, 0.0); + + d.b = min (d.b, 1.0); + d.b = max (d.b, 0.0); + + *buffer_line++ = rint(lut_out[int(rint(d.r * 65535))] * 65535); + *buffer_line++ = rint(lut_out[int(rint(d.g * 65535))] * 65535); + *buffer_line++ = rint(lut_out[int(rint(d.b * 65535))] * 65535); + } + + buffer += xyz_frame->size().width * 3; + } +} + +/** rgb must be packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, with the 2-byte value for each R/G/B component stored as little-endian; + * i.e. AV_PIX_FMT_RGB48LE. + */ shared_ptr dcp::rgb_to_xyz ( boost::shared_ptr rgb, - boost::shared_ptr lut_in, - boost::shared_ptr lut_out, - double const colour_matrix[3][3] + ColourConversion const & conversion ) { - assert (lut_in->bit_depth() == 12); - assert (lut_out->bit_depth() == 16); - shared_ptr xyz (new XYZFrame (rgb->size ())); struct { @@ -127,42 +197,38 @@ dcp::rgb_to_xyz ( double x, y, z; } d; + double const * lut_in = conversion.in()->lut (12); + double const * lut_out = conversion.out()->lut (16); + boost::numeric::ublas::matrix matrix = conversion.matrix (); + int jn = 0; for (int y = 0; y < rgb->size().height; ++y) { - uint8_t* p = rgb->data()[0] + y * rgb->stride()[0]; + uint16_t* p = reinterpret_cast (rgb->data()[0] + y * rgb->stride()[0]); for (int x = 0; x < rgb->size().width; ++x) { - /* In gamma LUT (converting 8-bit input to 12-bit) */ - s.r = lut_in->lut()[*p++ << 4]; - s.g = lut_in->lut()[*p++ << 4]; - s.b = lut_in->lut()[*p++ << 4]; - + /* In gamma LUT (converting 16-bit to 12-bit) */ + s.r = lut_in[*p++ >> 4]; + s.g = lut_in[*p++ >> 4]; + s.b = lut_in[*p++ >> 4]; + /* RGB to XYZ Matrix */ - d.x = ((s.r * colour_matrix[0][0]) + - (s.g * colour_matrix[0][1]) + - (s.b * colour_matrix[0][2])); - - d.y = ((s.r * colour_matrix[1][0]) + - (s.g * colour_matrix[1][1]) + - (s.b * colour_matrix[1][2])); - - d.z = ((s.r * colour_matrix[2][0]) + - (s.g * colour_matrix[2][1]) + - (s.b * colour_matrix[2][2])); + d.x = ((s.r * matrix(0, 0)) + (s.g * matrix(0, 1)) + (s.b * matrix(0, 2))); + d.y = ((s.r * matrix(1, 0)) + (s.g * matrix(1, 1)) + (s.b * matrix(1, 2))); + d.z = ((s.r * matrix(2, 0)) + (s.g * matrix(2, 1)) + (s.b * matrix(2, 2))); /* DCI companding */ d.x = d.x * DCI_COEFFICIENT * 65535; d.y = d.y * DCI_COEFFICIENT * 65535; d.z = d.z * DCI_COEFFICIENT * 65535; - assert (d.x >= 0 && d.x < 65536); - assert (d.y >= 0 && d.y < 65536); - assert (d.z >= 0 && d.z < 65536); + DCP_ASSERT (d.x >= 0 && d.x < 65536); + DCP_ASSERT (d.y >= 0 && d.y < 65536); + DCP_ASSERT (d.z >= 0 && d.z < 65536); /* Out gamma LUT */ - xyz->data(0)[jn] = lut_out->lut()[(int) d.x] * 4096; - xyz->data(1)[jn] = lut_out->lut()[(int) d.y] * 4096; - xyz->data(2)[jn] = lut_out->lut()[(int) d.z] * 4096; + xyz->data(0)[jn] = lut_out[int(rint(d.x))] * 4095; + xyz->data(1)[jn] = lut_out[int(rint(d.y))] * 4095; + xyz->data(2)[jn] = lut_out[int(rint(d.z))] * 4095; ++jn; } @@ -170,3 +236,27 @@ dcp::rgb_to_xyz ( return xyz; } + + +/** Image must be packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, with the 2-byte value for each R/G/B component stored as little-endian; + * i.e. AV_PIX_FMT_RGB48LE. + */ +shared_ptr +dcp::xyz_to_xyz (shared_ptr xyz_16) +{ + shared_ptr xyz_12 (new XYZFrame (xyz_16->size ())); + + int jn = 0; + for (int y = 0; y < xyz_16->size().height; ++y) { + uint16_t* p = reinterpret_cast (xyz_16->data()[0] + y * xyz_16->stride()[0]); + for (int x = 0; x < xyz_16->size().width; ++x) { + /* Truncate 16-bit to 12-bit */ + xyz_12->data(0)[jn] = *p++ >> 4; + xyz_12->data(1)[jn] = *p++ >> 4; + xyz_12->data(2)[jn] = *p++ >> 4; + ++jn; + } + } + + return xyz_12; +}