Merge branch '2.0' of ssh://main.carlh.net/home/carl/git/dcpomatic into 2.0
authorCarl Hetherington <cth@carlh.net>
Thu, 23 Apr 2015 16:55:08 +0000 (17:55 +0100)
committerCarl Hetherington <cth@carlh.net>
Thu, 23 Apr 2015 16:55:08 +0000 (17:55 +0100)
18 files changed:
ChangeLog
TO_PORT
cscript
src/lib/colour_conversion.cc
src/lib/config.cc
src/lib/image.cc
src/lib/image.h
src/lib/j2k_image_proxy.cc
src/lib/player.cc
src/lib/player_video.cc
src/lib/writer.cc
src/tools/dcpomatic.cc
src/wx/colour_conversion_editor.cc
src/wx/colour_conversion_editor.h
src/wx/film_viewer.cc
test/colour_conversion_test.cc
test/image_test.cc
test/make_black_test.cc

index 05a1738a0389031152b2e01dc3bb3d7da1782a91..183ebc3418afb41b62c099eb441af600614da073 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2015-04-22  c.hetherington  <cth@carlh.net>
+
+       * Add P3 colour conversion preset.
+
+       * Hand-apply all changes relating to colour specification
+       as chromaticity.
+
 2015-04-20  Carl Hetherington  <cth@carlh.net>
 
        * Hand-apply 47770097cf6a5d7dbbdded8977da5f3de53dfd33;
diff --git a/TO_PORT b/TO_PORT
index bb325e1d4a3f6a0fb527b90a6870b34eaee6a4f5..8b137891791fe96927ad78e64b0aad7bded08bdc 100644 (file)
--- a/TO_PORT
+++ b/TO_PORT
@@ -1,3 +1 @@
-Colour conversion fixes between 1.78.1 and 1.78.2
-b6df85a81f9dadb6ce778aaf3290cd39221b6170
 
diff --git a/cscript b/cscript
index 6b221e41646357727e8000726c851f43ce9f1e72..f3387e78a3c8b35693d7606654b1b2828ec67c94 100644 (file)
--- a/cscript
+++ b/cscript
@@ -156,7 +156,7 @@ def make_control(debian_version, bits, filename, debug):
 
 def dependencies(target):
     return (('ffmpeg-cdist', 'f69bb08'),
-            ('libdcp', 'df47103'),
+            ('libdcp', 'fa1dddf'),
             ('libsub', 'f66b11f'))
 
 def build(target, options):
index 4bf84281ddbf47dedd626e9cdfb589800a020c21..3c076b030ed19ee7d483f130287b8e73c3303270 100644 (file)
@@ -22,6 +22,7 @@
 #include "util.h"
 #include "md5_digester.h"
 #include "raw_convert.h"
+#include <dcp/chromaticity.h>
 #include <dcp/colour_matrix.h>
 #include <dcp/gamma_transfer_function.h>
 #include <dcp/modified_gamma_transfer_function.h>
@@ -61,10 +62,9 @@ ColourConversion::ColourConversion (cxml::NodePtr node, int version)
                cxml::ConstNodePtr in_node = node->node_child ("InputTransferFunction");
                string in_type = in_node->string_child ("Type");
                if (in_type == "Gamma") {
-                       _in.reset (new dcp::GammaTransferFunction (false, in_node->number_child<double> ("Gamma")));
+                       _in.reset (new dcp::GammaTransferFunction (in_node->number_child<double> ("Gamma")));
                } else if (in_type == "ModifiedGamma") {
                        _in.reset (new dcp::ModifiedGammaTransferFunction (
-                                          false,
                                           in_node->number_child<double> ("Power"),
                                           in_node->number_child<double> ("Threshold"),
                                           in_node->number_child<double> ("A"),
@@ -77,20 +77,46 @@ ColourConversion::ColourConversion (cxml::NodePtr node, int version)
                /* Version 1.x */
                
                if (node->bool_child ("InputGammaLinearised")) {
-                       _in.reset (new dcp::ModifiedGammaTransferFunction (false, node->number_child<float> ("InputGamma"), 0.04045, 0.055, 12.92));
+                       _in.reset (new dcp::ModifiedGammaTransferFunction (node->number_child<float> ("InputGamma"), 0.04045, 0.055, 12.92));
                } else {
-                       _in.reset (new dcp::GammaTransferFunction (false, node->number_child<float> ("InputGamma")));
+                       _in.reset (new dcp::GammaTransferFunction (node->number_child<float> ("InputGamma")));
                }
        }
 
+       _yuv_to_rgb = static_cast<dcp::YUVToRGB> (node->optional_number_child<int>("YUVToRGB").get_value_or (dcp::YUV_TO_RGB_REC601));
+       
        list<cxml::NodePtr> m = node->node_children ("Matrix");
-       for (list<cxml::NodePtr>::iterator i = m.begin(); i != m.end(); ++i) {
-               int const ti = (*i)->number_attribute<int> ("i");
-               int const tj = (*i)->number_attribute<int> ("j");
-               _matrix(ti, tj) = raw_convert<double> ((*i)->content ());
-       }
+       if (!m.empty ()) {
+               /* Read in old <Matrix> nodes and convert them to chromaticities */
+               boost::numeric::ublas::matrix<double> C (3, 3);
+               for (list<cxml::NodePtr>::iterator i = m.begin(); i != m.end(); ++i) {
+                       int const ti = (*i)->number_attribute<int> ("i");
+                       int const tj = (*i)->number_attribute<int> ("j");
+                       C(ti, tj) = raw_convert<double> ((*i)->content ());
+               }
+
+               double const rd = C(0, 0) + C(1, 0) + C(2, 0);
+               _red = dcp::Chromaticity (C(0, 0) / rd, C(1, 0) / rd);
+               double const gd = C(0, 1) + C(1, 1) + C(2, 1);
+               _green = dcp::Chromaticity (C(0, 1) / gd, C(1, 1) / gd);
+               double const bd = C(0, 2) + C(1, 2) + C(2, 2);
+               _blue = dcp::Chromaticity (C(0, 2) / bd, C(1, 2) / bd);
+               double const wd = C(0, 0) + C(0, 1) + C(0, 2) + C(1, 0) + C(1, 1) + C(1, 2) + C(2, 0) + C(2, 1) + C(2, 2);
+               _white = dcp::Chromaticity ((C(0, 0) + C(0, 1) + C(0, 2)) / wd, (C(1, 0) + C(1, 1) + C(1, 2)) / wd);
+       } else {
+               /* New-style chromaticities */
+               _red = dcp::Chromaticity (node->number_child<double> ("RedX"), node->number_child<double> ("RedY"));
+               _green = dcp::Chromaticity (node->number_child<double> ("GreenX"), node->number_child<double> ("GreenY"));
+               _blue = dcp::Chromaticity (node->number_child<double> ("BlueX"), node->number_child<double> ("BlueY"));
+               _white = dcp::Chromaticity (node->number_child<double> ("WhiteX"), node->number_child<double> ("WhiteY"));
+               if (node->optional_node_child ("AdjustedWhiteX")) {
+                       _adjusted_white = dcp::Chromaticity (
+                               node->number_child<double> ("AdjustedWhiteX"), node->number_child<double> ("AdjustedWhiteY")
+                               );
+               }
+       }       
        
-       _out.reset (new dcp::GammaTransferFunction (true, node->number_child<double> ("OutputGamma")));
+       _out.reset (new dcp::GammaTransferFunction (node->number_child<double> ("OutputGamma")));
 }
 
 boost::optional<ColourConversion>
@@ -120,14 +146,17 @@ ColourConversion::as_xml (xmlpp::Node* node) const
                in_node->add_child("B")->add_child_text (raw_convert<string> (tf->B ()));
        }
 
-       boost::numeric::ublas::matrix<double> matrix = _matrix;
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       xmlpp::Element* m = node->add_child("Matrix");
-                       m->set_attribute ("i", raw_convert<string> (i));
-                       m->set_attribute ("j", raw_convert<string> (j));
-                       m->add_child_text (raw_convert<string> (matrix (i, j)));
-               }
+       node->add_child("RedX")->add_child_text (raw_convert<string> (_red.x));
+       node->add_child("RedY")->add_child_text (raw_convert<string> (_red.y));
+       node->add_child("GreenX")->add_child_text (raw_convert<string> (_green.x));
+       node->add_child("GreenY")->add_child_text (raw_convert<string> (_green.y));
+       node->add_child("BlueX")->add_child_text (raw_convert<string> (_blue.x));
+       node->add_child("BlueY")->add_child_text (raw_convert<string> (_blue.y));
+       node->add_child("WhiteX")->add_child_text (raw_convert<string> (_white.x));
+       node->add_child("WhiteY")->add_child_text (raw_convert<string> (_white.y));
+       if (_adjusted_white) {
+               node->add_child("AdjustedWhiteX")->add_child_text (raw_convert<string> (_adjusted_white.get().x));
+               node->add_child("AdjustedWhiteY")->add_child_text (raw_convert<string> (_adjusted_white.get().y));
        }
 
        node->add_child("OutputGamma")->add_child_text (raw_convert<string> (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_out)->gamma ()));
@@ -165,11 +194,18 @@ ColourConversion::identifier () const
                digester.add (tf->B ());
        }
 
-       boost::numeric::ublas::matrix<double> matrix = _matrix;
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       digester.add (matrix (i, j));
-               }
+       digester.add (_red.x);
+       digester.add (_red.y);
+       digester.add (_green.x);
+       digester.add (_green.y);
+       digester.add (_blue.x);
+       digester.add (_blue.y);
+       digester.add (_white.x);
+       digester.add (_white.y);
+
+       if (_adjusted_white) {
+               digester.add (_adjusted_white.get().x);
+               digester.add (_adjusted_white.get().y);
        }
 
        digester.add (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_out)->gamma ());
index c75eaa0f5dce59b23d2c535a97a56d9d1fc2a9e9..ab57c1afcc89aea6674b929b0727d13a2b9ad7b7 100644 (file)
@@ -83,6 +83,7 @@ Config::set_defaults ()
        _win32_console = false;
 #endif   
 
+       _allowed_dcp_frame_rates.clear ();
        _allowed_dcp_frame_rates.push_back (24);
        _allowed_dcp_frame_rates.push_back (25);
        _allowed_dcp_frame_rates.push_back (30);
@@ -90,8 +91,11 @@ Config::set_defaults ()
        _allowed_dcp_frame_rates.push_back (50);
        _allowed_dcp_frame_rates.push_back (60);
 
+       _colour_conversions.clear ();
        _colour_conversions.push_back (PresetColourConversion (_("sRGB"), dcp::ColourConversion::srgb_to_xyz ()));
+       _colour_conversions.push_back (PresetColourConversion (_("Rec. 601"), dcp::ColourConversion::rec601_to_xyz ()));
        _colour_conversions.push_back (PresetColourConversion (_("Rec. 709"), dcp::ColourConversion::rec709_to_xyz ()));
+       _colour_conversions.push_back (PresetColourConversion (_("P3 (from SMPTE RP 431-2)"), dcp::ColourConversion::p3_to_xyz ()));
 
        set_kdm_email_to_default ();
 }
index 177219813131cb0b387eec74efdf441917fe57e8..bba5eeda1a0241d213dae5b30c804022f98de7ba 100644 (file)
@@ -87,7 +87,9 @@ Image::components () const
 
 /** Crop this image, scale it to `inter_size' and then place it in a black frame of `out_size' */
 shared_ptr<Image>
-Image::crop_scale_window (Crop crop, dcp::Size inter_size, dcp::Size out_size, AVPixelFormat out_format, bool out_aligned) const
+Image::crop_scale_window (
+       Crop crop, dcp::Size inter_size, dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool out_aligned
+       ) const
 {
        /* Empirical testing suggests that sws_scale() will crash if
           the input image is not aligned.
@@ -115,6 +117,19 @@ Image::crop_scale_window (Crop crop, dcp::Size inter_size, dcp::Size out_size, A
                throw StringError (N_("Could not allocate SwsContext"));
        }
 
+       DCPOMATIC_ASSERT (yuv_to_rgb < dcp::YUV_TO_RGB_COUNT);
+       int const lut[dcp::YUV_TO_RGB_COUNT] = {
+               SWS_CS_ITU601,
+               SWS_CS_ITU709
+       };
+
+       sws_setColorspaceDetails (
+               scale_context,
+               sws_getCoefficients (lut[yuv_to_rgb]), 0,
+               sws_getCoefficients (lut[yuv_to_rgb]), 0,
+               0, 1 << 16, 1 << 16
+               );
+       
        /* Prepare input data pointers with crop */
        uint8_t* scale_in_data[components()];
        for (int c = 0; c < components(); ++c) {
@@ -142,7 +157,7 @@ Image::crop_scale_window (Crop crop, dcp::Size inter_size, dcp::Size out_size, A
 }
 
 shared_ptr<Image>
-Image::scale (dcp::Size out_size, AVPixelFormat out_format, bool out_aligned) const
+Image::scale (dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, bool out_aligned) const
 {
        /* Empirical testing suggests that sws_scale() will crash if
           the input image is not aligned.
@@ -157,6 +172,19 @@ Image::scale (dcp::Size out_size, AVPixelFormat out_format, bool out_aligned) co
                SWS_BICUBIC, 0, 0, 0
                );
 
+       DCPOMATIC_ASSERT (yuv_to_rgb < dcp::YUV_TO_RGB_COUNT);
+       int const lut[dcp::YUV_TO_RGB_COUNT] = {
+               SWS_CS_ITU601,
+               SWS_CS_ITU709
+       };
+
+       sws_setColorspaceDetails (
+               scale_context,
+               sws_getCoefficients (lut[yuv_to_rgb]), 0,
+               sws_getCoefficients (lut[yuv_to_rgb]), 0,
+               0, 1 << 16, 1 << 16
+               );
+       
        sws_scale (
                scale_context,
                data(), stride(),
index 2e90a89e92ed9701b19c3c4a80c0e67e10687297..5c3931102af776c259965bf7fb9487a02370d193 100644 (file)
@@ -27,6 +27,7 @@
 #include "position.h"
 #include "position_image.h"
 #include "types.h"
+#include <dcp/colour_conversion.h>
 extern "C" {
 #include <libavcodec/avcodec.h>
 #include <libavfilter/avfilter.h>
@@ -57,10 +58,9 @@ public:
        int line_factor (int) const;
        int lines (int) const;
 
-       boost::shared_ptr<Image> scale (dcp::Size, AVPixelFormat, bool aligned) const;
+       boost::shared_ptr<Image> scale (dcp::Size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat, bool aligned) const;
        boost::shared_ptr<Image> crop (Crop c, bool aligned) const;
-
-       boost::shared_ptr<Image> crop_scale_window (Crop c, dcp::Size, dcp::Size, AVPixelFormat, bool aligned) const;
+       boost::shared_ptr<Image> crop_scale_window (Crop c, dcp::Size, dcp::Size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat, bool aligned) const;
        
        void make_black ();
        void make_transparent ();
index 16b88616946df8811b419aa94b88e42d22e1ebab..59106098a8351a1634f3e2023816856b9137a681 100644 (file)
@@ -82,9 +82,9 @@ J2KImageProxy::image (optional<dcp::NoteHandler> note) const
        shared_ptr<Image> image (new Image (PIX_FMT_RGB48LE, _size, true));
 
        if (_mono) {
-               dcp::xyz_to_rgb (_mono->xyz_image (), dcp::ColourConversion::xyz_to_srgb(), image->data()[0], image->stride()[0], note);
+               dcp::xyz_to_rgb (_mono->xyz_image (), dcp::ColourConversion::srgb_to_xyz(), image->data()[0], image->stride()[0], note);
        } else {
-               dcp::xyz_to_rgb (_stereo->xyz_image (_eye.get ()), dcp::ColourConversion::xyz_to_srgb(), image->data()[0], image->stride()[0], note);
+               dcp::xyz_to_rgb (_stereo->xyz_image (_eye.get ()), dcp::ColourConversion::srgb_to_xyz(), image->data()[0], image->stride()[0], note);
        }
 
        return image;
index e3c85ee56ef40ef6f1ae0cb370656bc96697a53d..495d20533b3eb15947f8a199b34901700d07b5f3 100644 (file)
@@ -280,6 +280,7 @@ Player::transform_image_subtitles (list<ImageSubtitle> subs) const
                        PositionImage (
                                i->image->scale (
                                        scaled_size,
+                                       dcp::YUV_TO_RGB_REC601,
                                        i->image->pixel_format (),
                                        true
                                        ),
index aad75889fc6a4a4e9f0dedf339f4db88d9dfc012..81e01329a5b641ac1869d2f158b645375d364bd1 100644 (file)
@@ -110,8 +110,13 @@ PlayerVideo::image (AVPixelFormat pixel_format, bool burn_subtitle, dcp::NoteHan
        default:
                break;
        }
+
+       dcp::YUVToRGB yuv_to_rgb = dcp::YUV_TO_RGB_REC601;
+       if (_colour_conversion) {
+               yuv_to_rgb = _colour_conversion.get().yuv_to_rgb();
+       }
                
-       shared_ptr<Image> out = im->crop_scale_window (total_crop, _inter_size, _out_size, pixel_format, true);
+       shared_ptr<Image> out = im->crop_scale_window (total_crop, _inter_size, _out_size, yuv_to_rgb, pixel_format, true);
 
        if (burn_subtitle && _subtitle.image) {
                out->alpha_blend (_subtitle.image, _subtitle.position);
index e8a4ac10b4f2192b43140b662aee72ad95d21e7e..4270a42a7684a76f2f64a34392e26e28bffb501f 100644 (file)
@@ -92,9 +92,6 @@ Writer::Writer (shared_ptr<const Film> f, weak_ptr<Job> j)
        shared_ptr<Job> job = _job.lock ();
        DCPOMATIC_ASSERT (job);
 
-       job->sub (_("Checking existing image data"));
-       check_existing_picture_mxf ();
-
        /* Create our picture asset in a subdirectory, named according to those
           film's parameters which affect the video output.  We will hard-link
           it into the DCP later.
@@ -106,6 +103,9 @@ Writer::Writer (shared_ptr<const Film> f, weak_ptr<Job> j)
                _picture_mxf.reset (new dcp::MonoPictureMXF (dcp::Fraction (_film->video_frame_rate (), 1)));
        }
 
+       job->sub (_("Checking existing image data"));
+       check_existing_picture_mxf ();
+
        _picture_mxf->set_size (_film->frame_size ());
 
        if (_film->encrypted ()) {
@@ -438,9 +438,7 @@ Writer::finish ()
        }
        
        /* Hard-link the video MXF into the DCP */
-       boost::filesystem::path video_from;
-       video_from /= _film->internal_video_mxf_dir();
-       video_from /= _film->internal_video_mxf_filename();
+       boost::filesystem::path video_from = _picture_mxf->file ();
        
        boost::filesystem::path video_to;
        video_to /= _film->dir (_film->dcp_name());
@@ -594,12 +592,9 @@ void
 Writer::check_existing_picture_mxf ()
 {
        /* Try to open the existing MXF */
-       boost::filesystem::path p;
-       p /= _film->internal_video_mxf_dir ();
-       p /= _film->internal_video_mxf_filename ();
-       FILE* mxf = fopen_boost (p, "rb");
+       FILE* mxf = fopen_boost (_picture_mxf->file(), "rb");
        if (!mxf) {
-               LOG_GENERAL ("Could not open existing MXF at %1 (errno=%2)", p.string(), errno);
+               LOG_GENERAL ("Could not open existing MXF at %1 (errno=%2)", _picture_mxf->file().string(), errno);
                return;
        }
 
index 16506e411fbacd46520a22e4a2de4ee7eb9d19d9..3151b5e1168d8f05b8d9794724c1b620adcc1643 100644 (file)
@@ -127,9 +127,9 @@ enum {
        ID_file_save,
        ID_file_properties,
        ID_file_history,
-       ID_edit_restore_default_preferences,
        /* Allow spare IDs after _history for the recent files list */
-       ID_content_scale_to_fit_width = 100,
+       ID_edit_restore_default_preferences = 100,
+       ID_content_scale_to_fit_width,
        ID_content_scale_to_fit_height,
        ID_jobs_make_dcp,
        ID_jobs_make_kdms,
index 3ea144e1de5acd784d5d56ba3283e5abe1214e01..482e403095ab94879660e89c8415b3c327cf0b1a 100644 (file)
@@ -45,6 +45,8 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
 
        int r = 0;
 
+       subhead (table, this, _("Input gamma correction"), r);
+
        _input_gamma_linearised = new wxCheckBox (this, wxID_ANY, _("Linearise input gamma curve for low values"));
        table->Add (_input_gamma_linearised, wxGBPosition (r, 0), wxGBSpan (1, 2));
        ++r;
@@ -88,17 +90,99 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
 
         validator.SetIncludes (list);
 
-       add_label_to_grid_bag_sizer (table, this, _("Matrix"), true, wxGBPosition (r, 0));
-       wxFlexGridSizer* matrix_sizer = new wxFlexGridSizer (3, DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
+
+       /* YUV to RGB conversion */
+
+       subhead (table, this, _("YUV to RGB conversion"), r);
+       
+       add_label_to_grid_bag_sizer (table, this, _("YUV to RGB matrix"), true, wxGBPosition (r, 0));
+       _yuv_to_rgb = new wxChoice (this, wxID_ANY);
+       _yuv_to_rgb->Append (_("Rec. 601"));
+       _yuv_to_rgb->Append (_("Rec. 709"));
+       table->Add (_yuv_to_rgb, wxGBPosition (r, 1));
+       ++r;
+
+       /* RGB to XYZ conversion */
+
+       subhead (table, this, _("RGB to XYZ conversion"), r);
+
+       add_label_to_grid_bag_sizer (table, this, _("x"), false, wxGBPosition (r, 1));
+       add_label_to_grid_bag_sizer (table, this, _("y"), false, wxGBPosition (r, 2));
+       add_label_to_grid_bag_sizer (table, this, _("Matrix"), false, wxGBPosition (r, 3));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("Red chromaticity"), true, wxGBPosition (r, 0));
+       _red_x = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_red_x, wxGBPosition (r, 1));
+       _red_y = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_red_y, wxGBPosition (r, 2));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("Green chromaticity"), true, wxGBPosition (r, 0));
+       _green_x = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_green_x, wxGBPosition (r, 1));
+       _green_y = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_green_y, wxGBPosition (r, 2));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("Blue chromaticity"), true, wxGBPosition (r, 0));
+       _blue_x = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_blue_x, wxGBPosition (r, 1));
+       _blue_y = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_blue_y, wxGBPosition (r, 2));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("White point"), true, wxGBPosition (r, 0));
+       _white_x = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_white_x, wxGBPosition (r, 1));
+       _white_y = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_white_y, wxGBPosition (r, 2));
+       ++r;
+
+        size = dc.GetTextExtent (wxT ("0.12345678"));
+        size.SetHeight (-1);
+       
+       wxFlexGridSizer* rgb_to_xyz_sizer = new wxFlexGridSizer (3, DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
        for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 3; ++j) {
-                       _matrix[i][j] = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
-                       matrix_sizer->Add (_matrix[i][j]);
+                       _rgb_to_xyz[i][j] = new wxStaticText (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0);
+                       rgb_to_xyz_sizer->Add (_rgb_to_xyz[i][j]);
                }
        }
-       table->Add (matrix_sizer, wxGBPosition (r, 1));
+       table->Add (rgb_to_xyz_sizer, wxGBPosition (r - 4, 3), wxGBSpan (4, 1));
+
+       /* White point adjustment */
+
+        size = dc.GetTextExtent (wxT ("-0.12345678901"));
+        size.SetHeight (-1);
+
+       subhead (table, this, _("White point adjustment"), r);
+
+       _adjust_white = new wxCheckBox (this, wxID_ANY, _("Adjust white point to"));
+       table->Add (_adjust_white, wxGBPosition (r, 0));
+       _adjusted_white_x = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_adjusted_white_x, wxGBPosition (r, 1));
+       _adjusted_white_y = new wxTextCtrl (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0, validator);
+       table->Add (_adjusted_white_y, wxGBPosition (r, 2));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, wxT (""), false, wxGBPosition (r, 0));
        ++r;
 
+        size = dc.GetTextExtent (wxT ("0.12345678"));
+        size.SetHeight (-1);
+       
+       wxFlexGridSizer* bradford_sizer = new wxFlexGridSizer (3, DCPOMATIC_SIZER_X_GAP, DCPOMATIC_SIZER_Y_GAP);
+       for (int i = 0; i < 3; ++i) {
+               for (int j = 0; j < 3; ++j) {
+                       _bradford[i][j] = new wxStaticText (this, wxID_ANY, wxT (""), wxDefaultPosition, size, 0);
+                       bradford_sizer->Add (_bradford[i][j]);
+               }
+       }
+       table->Add (bradford_sizer, wxGBPosition (r - 2, 3), wxGBSpan (2, 1));
+
+       subhead (table, this, _("Output gamma correction"), r);
+       
        add_label_to_grid_bag_sizer (table, this, _("Output gamma"), true, wxGBPosition (r, 0));
        wxBoxSizer* output_sizer = new wxBoxSizer (wxHORIZONTAL);
        /// TRANSLATORS: this means the mathematical reciprocal operation, i.e. we are dividing 1 by the control that
@@ -106,7 +190,7 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
        add_label_to_sizer (output_sizer, this, _("1 / "), false);
        _output_gamma = new wxSpinCtrlDouble (this);
        output_sizer->Add (_output_gamma);
-       table->Add (output_sizer, wxGBPosition (r, 1));
+       table->Add (output_sizer, wxGBPosition (r, 1), wxGBSpan (1, 2));
        ++r;
 
        _input_gamma->SetRange (0.1, 4.0);
@@ -125,14 +209,30 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
        _input_threshold->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::changed, this));
        _input_A->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::changed, this));
        _input_B->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::changed, this));
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       _matrix[i][j]->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::changed, this));
-               }
-       }
+       _red_x->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _red_y->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _green_x->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _green_y->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _blue_x->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _blue_y->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _white_x->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _white_y->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::chromaticity_changed, this));
+       _adjust_white->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&ColourConversionEditor::adjusted_white_changed, this));
+       _adjusted_white_x->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::adjusted_white_changed, this));
+       _adjusted_white_y->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::adjusted_white_changed, this));
+       _yuv_to_rgb->Bind (wxEVT_COMMAND_CHOICE_SELECTED, boost::bind (&ColourConversionEditor::changed, this));
        _output_gamma->Bind (wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, boost::bind (&ColourConversionEditor::changed, this, _output_gamma));
 }
 
+void
+ColourConversionEditor::subhead (wxGridBagSizer* sizer, wxWindow* parent, wxString text, int& row) const
+{
+       wxStaticText* m = new wxStaticText (parent, wxID_ANY, wxT (""));
+       m->SetLabelMarkup ("<b>" + text + "</b>");
+       sizer->Add (m, wxGBPosition (row, 0), wxGBSpan (1, 3), wxALIGN_CENTER_VERTICAL | wxTOP, 12);
+       ++row;
+}
+
 void
 ColourConversionEditor::set (ColourConversion conversion)
 {
@@ -142,7 +242,7 @@ ColourConversionEditor::set (ColourConversion conversion)
                set_spin_ctrl (_input_gamma, tf->gamma ());
        } else if (dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (conversion.in ())) {
                shared_ptr<const dcp::ModifiedGammaTransferFunction> tf = dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (conversion.in ());
-               /* Arbitrary default */
+               /* Arbitrary default; not used in this case (greyed out) */
                _input_gamma->SetValue (2.2);
                _input_gamma_linearised->SetValue (true);
                set_spin_ctrl (_input_power, tf->power ());
@@ -151,12 +251,57 @@ ColourConversionEditor::set (ColourConversion conversion)
                set_text_ctrl (_input_B, tf->B ());
        }
 
-       boost::numeric::ublas::matrix<double> matrix = conversion.matrix ();
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       set_text_ctrl (_matrix[i][j], matrix(i, j));
-               }
+       _yuv_to_rgb->SetSelection (conversion.yuv_to_rgb ());
+
+       SafeStringStream s;
+       s.setf (std::ios::fixed, std::ios::floatfield);
+       s.precision (6);
+
+       s << conversion.red().x;
+       _red_x->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.red().y;
+       _red_y->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.green().x;
+       _green_x->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.green().y;
+       _green_y->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.blue().x;
+       _blue_x->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.blue().y;
+       _blue_y->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.white().x;
+       _white_x->SetValue (std_to_wx (s.str ()));
+
+       s.str ("");
+       s << conversion.white().y;
+       _white_y->SetValue (std_to_wx (s.str ()));
+
+       if (conversion.adjusted_white ()) {
+               _adjust_white->SetValue (true);
+               s.str ("");
+               s << conversion.adjusted_white().get().x;
+               _adjusted_white_x->SetValue (std_to_wx (s.str ()));
+               s.str ("");
+               s << conversion.adjusted_white().get().y;
+               _adjusted_white_y->SetValue (std_to_wx (s.str ()));
+       } else {
+               _adjust_white->SetValue (false);
        }
+
+       update_rgb_to_xyz ();
+       update_bradford ();
        
        set_spin_ctrl (_output_gamma, dynamic_pointer_cast<const dcp::GammaTransferFunction> (conversion.out ())->gamma ());
 }
@@ -170,7 +315,6 @@ ColourConversionEditor::get () const
                conversion.set_in (
                        shared_ptr<dcp::ModifiedGammaTransferFunction> (
                                new dcp::ModifiedGammaTransferFunction (
-                                       false,
                                        _input_power->GetValue (),
                                        raw_convert<double> (wx_to_std (_input_threshold->GetValue ())),
                                        raw_convert<double> (wx_to_std (_input_A->GetValue ())),
@@ -180,30 +324,37 @@ ColourConversionEditor::get () const
                        );
        } else {
                conversion.set_in (
-                       shared_ptr<dcp::GammaTransferFunction> (
-                               new dcp::GammaTransferFunction (
-                                       false,
-                                       _input_gamma->GetValue ()
-                                       )
-                               )
+                       shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (_input_gamma->GetValue ()))
                        );
        }
 
-       boost::numeric::ublas::matrix<double> matrix (3, 3);
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       string const v = wx_to_std (_matrix[i][j]->GetValue ());
-                       if (v.empty ()) {
-                               matrix (i, j) = 0;
-                       } else {
-                               matrix (i, j) = raw_convert<double> (v);
-                       }
-               }
+       conversion.set_yuv_to_rgb (static_cast<dcp::YUVToRGB> (_yuv_to_rgb->GetSelection ()));
+
+       conversion.set_red (
+               dcp::Chromaticity (raw_convert<double> (wx_to_std (_red_x->GetValue ())), raw_convert<double> (wx_to_std (_red_y->GetValue ())))
+               );
+       conversion.set_green (
+               dcp::Chromaticity (raw_convert<double> (wx_to_std (_green_x->GetValue ())), raw_convert<double> (wx_to_std (_green_y->GetValue ())))
+               );
+       conversion.set_blue (
+               dcp::Chromaticity (raw_convert<double> (wx_to_std (_blue_x->GetValue ())), raw_convert<double> (wx_to_std (_blue_y->GetValue ())))
+               );
+       conversion.set_white (
+               dcp::Chromaticity (raw_convert<double> (wx_to_std (_white_x->GetValue ())), raw_convert<double> (wx_to_std (_white_y->GetValue ())))
+               );
+
+       if (_adjust_white->GetValue ()) {
+               conversion.set_adjusted_white (
+                       dcp::Chromaticity (
+                               raw_convert<double> (wx_to_std (_adjusted_white_x->GetValue ())),
+                               raw_convert<double> (wx_to_std (_adjusted_white_y->GetValue ()))
+                               )
+                       );
+       } else {
+               conversion.unset_adjusted_white ();
        }
 
-       conversion.set_matrix (matrix);
-
-       conversion.set_out (shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (true, _output_gamma->GetValue ())));
+       conversion.set_out (shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (_output_gamma->GetValue ())));
 
        return conversion;
 }
@@ -221,6 +372,53 @@ ColourConversionEditor::changed ()
        Changed ();
 }
 
+void
+ColourConversionEditor::chromaticity_changed ()
+{
+       update_rgb_to_xyz ();
+       changed ();
+}
+
+void
+ColourConversionEditor::adjusted_white_changed ()
+{
+       update_bradford ();
+       changed ();
+}
+
+void
+ColourConversionEditor::update_bradford ()
+{
+       _adjusted_white_x->Enable (_adjust_white->GetValue ());
+       _adjusted_white_y->Enable (_adjust_white->GetValue ());
+       
+       boost::numeric::ublas::matrix<double> m = get().bradford ();
+       for (int i = 0; i < 3; ++i) {
+               for (int j = 0; j < 3; ++j) {
+                       SafeStringStream s;
+                       s.setf (std::ios::fixed, std::ios::floatfield);
+                       s.precision (7);
+                       s << m (i, j);
+                       _bradford[i][j]->SetLabel (std_to_wx (s.str ()));
+               }
+       }
+}
+
+void
+ColourConversionEditor::update_rgb_to_xyz ()
+{
+       boost::numeric::ublas::matrix<double> m = get().rgb_to_xyz ();
+       for (int i = 0; i < 3; ++i) {
+               for (int j = 0; j < 3; ++j) {
+                       SafeStringStream s;
+                       s.setf (std::ios::fixed, std::ios::floatfield);
+                       s.precision (7);
+                       s << m (i, j);
+                       _rgb_to_xyz[i][j]->SetLabel (std_to_wx (s.str ()));
+               }
+       }
+}
+
 void
 ColourConversionEditor::changed (wxSpinCtrlDouble* sc)
 {
index 317171aa483129450c2d6f0539a0868f7389befa..b7467a70a1341ba7f66dd11047abfae68396bfec 100644 (file)
@@ -39,6 +39,11 @@ public:
 private:
        void changed ();
        void changed (wxSpinCtrlDouble *);
+       void chromaticity_changed ();
+       void adjusted_white_changed ();
+       void update_rgb_to_xyz ();
+       void update_bradford ();
+       void subhead (wxGridBagSizer* sizer, wxWindow* parent, wxString text, int& row) const;
 
        void set_text_ctrl (wxTextCtrl *, double);
        void set_spin_ctrl (wxSpinCtrlDouble *, double);
@@ -51,7 +56,20 @@ private:
        wxTextCtrl* _input_A;
        wxTextCtrl* _input_B;
        wxCheckBox* _input_gamma_linearised;
-       wxTextCtrl* _matrix[3][3];
+       wxChoice* _yuv_to_rgb;
+       wxTextCtrl* _red_x;
+       wxTextCtrl* _red_y;
+       wxTextCtrl* _green_x;
+       wxTextCtrl* _green_y;
+       wxTextCtrl* _blue_x;
+       wxTextCtrl* _blue_y;
+       wxTextCtrl* _white_x;
+       wxTextCtrl* _white_y;
+       wxCheckBox* _adjust_white;
+       wxTextCtrl* _adjusted_white_x;
+       wxTextCtrl* _adjusted_white_y;
+       wxStaticText* _rgb_to_xyz[3][3];
+       wxStaticText* _bradford[3][3];
        wxSpinCtrlDouble* _output_gamma;
 };
 
index 26f135d48eed0b480e4736a6c01feda55b874132..a1cc5dfc4bd37dd1751523895291005069975909 100644 (file)
@@ -180,7 +180,13 @@ FilmViewer::get (DCPTime p, bool accurate)
        if (!pvf.empty ()) {
                try {
                        _frame = pvf.front()->image (PIX_FMT_RGB24, true, boost::bind (&Log::dcp_log, _film->log().get(), _1, _2));
-                       _frame = _frame->scale (_frame->size(), PIX_FMT_RGB24, false);
+
+                       dcp::YUVToRGB yuv_to_rgb = dcp::YUV_TO_RGB_REC601;
+                       if (pvf.front()->colour_conversion()) {
+                               yuv_to_rgb = pvf.front()->colour_conversion().get().yuv_to_rgb();
+                       }
+                       
+                       _frame = _frame->scale (_frame->size(), yuv_to_rgb, PIX_FMT_RGB24, false);
                        _position = pvf.front()->time ();
                        _inter_position = pvf.front()->inter_position ();
                        _inter_size = pvf.front()->inter_size ();
index 35beed519507ac6269f9d2b8a5a4add1ad9aabed..8c22eeda380f7421d129a79fe0b8f13b534f1b54 100644 (file)
@@ -36,7 +36,7 @@ BOOST_AUTO_TEST_CASE (colour_conversion_test1)
        ColourConversion B (dcp::ColourConversion::rec709_to_xyz ());
 
        BOOST_CHECK_EQUAL (A.identifier(), "751dd37378fb52502d356ec334a104c8");
-       BOOST_CHECK_EQUAL (B.identifier(), "149bc864d969ad7446fa18d62d1690b2");
+       BOOST_CHECK_EQUAL (B.identifier(), "621cf5bdd8de7e8adc3f4b8d77dc708a");
 }
 
 BOOST_AUTO_TEST_CASE (colour_conversion_test2)
@@ -82,7 +82,7 @@ BOOST_AUTO_TEST_CASE (colour_conversion_test3)
                "<Test>\n"
                "  <InputTransferFunction>\n"
                "    <Type>ModifiedGamma</Type>\n"
-               "    <Power>2.4</Power>\n"
+               "    <Power>2.222222222222222</Power>\n"
                "    <Threshold>0.081</Threshold>\n"
                "    <A>0.099</A>\n"
                "    <B>4.5</B>\n"
index b622b250db50eb6f6ff9ac82d8090dc3caa82991..9aca9878d813277c03785159b5a296e48112c9b3 100644 (file)
@@ -156,7 +156,7 @@ BOOST_AUTO_TEST_CASE (crop_image_test2)
        image = image->crop (crop, true);
 
        /* Convert it back to RGB to make comparison to black easier */
-       image = image->scale (image->size(), PIX_FMT_RGB24, true);
+       image = image->scale (image->size(), dcp::YUV_TO_RGB_REC601, PIX_FMT_RGB24, true);
 
        /* Check that its still black after the crop */
        uint8_t* p = image->data()[0];
@@ -250,13 +250,13 @@ crop_scale_window_single (AVPixelFormat in_format, dcp::Size in_size, Crop crop,
                                
        /* Convert using separate methods */
        boost::shared_ptr<Image> sep = test->crop (crop, true);
-       sep = sep->scale (inter_size, PIX_FMT_RGB24, true);
+       sep = sep->scale (inter_size, dcp::YUV_TO_RGB_REC601, PIX_FMT_RGB24, true);
        boost::shared_ptr<Image> sep_container (new Image (PIX_FMT_RGB24, out_size, true));
        sep_container->make_black ();
        sep_container->copy (sep, Position<int> ((out_size.width - inter_size.width) / 2, (out_size.height - inter_size.height) / 2));
 
        /* Convert using the all-in-one method */
-       shared_ptr<Image> all = test->crop_scale_window (crop, inter_size, out_size, PIX_FMT_RGB24, true);
+       shared_ptr<Image> all = test->crop_scale_window (crop, inter_size, out_size, dcp::YUV_TO_RGB_REC601, PIX_FMT_RGB24, true);
 
        /* Compare */
        BOOST_CHECK_EQUAL (sep_container->size().width, all->size().width);
index 913b6da10857ba1de2e4d2586899a5a2e7c2079c..b0243310bbacd2b9bfd9a23809195eab2763d212 100644 (file)
@@ -80,7 +80,7 @@ BOOST_AUTO_TEST_CASE (make_black_test)
        for (list<AVPixelFormat>::const_iterator i = pix_fmts.begin(); i != pix_fmts.end(); ++i) {
                boost::shared_ptr<Image> foo (new Image (*i, in_size, true));
                foo->make_black ();
-               boost::shared_ptr<Image> bar = foo->scale (out_size, PIX_FMT_RGB24, true);
+               boost::shared_ptr<Image> bar = foo->scale (out_size, dcp::YUV_TO_RGB_REC601, PIX_FMT_RGB24, true);
                
                uint8_t* p = bar->data()[0];
                for (int y = 0; y < bar->size().height; ++y) {