Basic adaptations for changes to libdcp1 colour conversion handling.

diff --git a/TO_PORT b/TO_PORT
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..db911a5821b2ed09f4e1542fb8080747b0f0610e 100644 (file)
--- a/TO_PORT
+++ b/TO_PORT
@@ -0,0 +1,2 @@
+xEBOt3J2vVMY8hF5
+d462b1588e875007d640fb012ab223d69dd5fcb3

diff --git a/src/lib/colour_conversion.cc b/src/lib/colour_conversion.cc
index 6dd4ab87675008abee80a9f517049e351ce75f16..32bc3c1a5c31c6803ce087883ebb580698e025ef 100644 (file)
--- a/src/lib/colour_conversion.cc
+++ b/src/lib/colour_conversion.cc
@@ -23,6 +23,8 @@
 #include "md5_digester.h"
 #include <dcp/colour_matrix.h>
 #include <dcp/raw_convert.h>
 #include "md5_digester.h"
 #include <dcp/colour_matrix.h>
 #include <dcp/raw_convert.h>

+#include <dcp/gamma_transfer_function.h>
+#include <dcp/modified_gamma_transfer_function.h>

 #include <libcxml/cxml.h>
 #include <libxml++/libxml++.h>
 
 #include <libcxml/cxml.h>
 #include <libxml++/libxml++.h>
 


@@ -34,60 +36,52 @@ using std::cout;
 using std::vector;
 using boost::shared_ptr;
 using boost::optional;
 using std::vector;
 using boost::shared_ptr;
 using boost::optional;

+using boost::dynamic_pointer_cast;

 using dcp::raw_convert;
 
 ColourConversion::ColourConversion ()
 using dcp::raw_convert;
 
 ColourConversion::ColourConversion ()

-       : input_gamma (2.4)
-       , input_gamma_linearised (true)
-       , matrix (3, 3)
-       , output_gamma (2.6)
+       : dcp::ColourConversion (dcp::ColourConversion::srgb_to_xyz)

 {
 {

-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       matrix (i, j) = dcp::colour_matrix::srgb_to_xyz[i][j];
-               }
-       }
+       

 }
 
 }
 

-ColourConversion::ColourConversion (double i, bool il, double const m[3][3], double o)
-       : input_gamma (i)
-       , input_gamma_linearised (il)
-       , matrix (3, 3)
-       , output_gamma (o)
+ColourConversion::ColourConversion (dcp::ColourConversion conversion_)
+       : dcp::ColourConversion (conversion_)

 {
 {

-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       matrix (i, j) = m[i][j];
-               }
-       }
+       

 }
 
 ColourConversion::ColourConversion (cxml::NodePtr node)
 }
 
 ColourConversion::ColourConversion (cxml::NodePtr node)

-       : matrix (3, 3)

 {
 {

-       input_gamma = node->number_child<double> ("InputGamma");
-       input_gamma_linearised = node->bool_child ("InputGammaLinearised");
-
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       matrix (i, j) = 0;
-               }
+       shared_ptr<dcp::TransferFunction> in;
+       
+       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 (in_node->number_child<double> ("Gamma")));
+       } else if (in_type == "ModifiedGamma") {
+               _in.reset (new dcp::ModifiedGammaTransferFunction (
+                                 in_node->number_child<double> ("Power"),
+                                 in_node->number_child<double> ("Threshold"),
+                                 in_node->number_child<double> ("A"),
+                                 in_node->number_child<double> ("B")
+                                 ));

        }
 
        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");
        }
 
        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 ());
+               _matrix(ti, tj) = raw_convert<double> ((*i)->content ());

        }
 
        }
 

-       output_gamma = node->number_child<double> ("OutputGamma");
+       _out.reset (new dcp::GammaTransferFunction (node->number_child<double> ("OutputGamma")));

 }
 
 boost::optional<ColourConversion>
 ColourConversion::from_xml (cxml::NodePtr node)
 {
 }
 
 boost::optional<ColourConversion>
 ColourConversion::from_xml (cxml::NodePtr node)
 {

-       if (!node->optional_node_child ("InputGamma")) {
+       if (!node->optional_node_child ("InputTransferFunction")) {

                return boost::optional<ColourConversion> ();
        }
 
                return boost::optional<ColourConversion> ();
        }
 


@@ -97,9 +91,21 @@ ColourConversion::from_xml (cxml::NodePtr node)
 void
 ColourConversion::as_xml (xmlpp::Node* node) const
 {
 void
 ColourConversion::as_xml (xmlpp::Node* node) const
 {

-       node->add_child("InputGamma")->add_child_text (raw_convert<string> (input_gamma));
-       node->add_child("InputGammaLinearised")->add_child_text (input_gamma_linearised ? "1" : "0");
+       xmlpp::Node* in_node = node->add_child ("InputTransferFunction");
+       if (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_in)) {
+               shared_ptr<const dcp::GammaTransferFunction> tf = dynamic_pointer_cast<const dcp::GammaTransferFunction> (_in);
+               in_node->add_child("Type")->add_child_text ("Gamma");
+               in_node->add_child("Gamma")->add_child_text (raw_convert<string> (tf->gamma ()));
+       } else if (dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (_in)) {
+               shared_ptr<const dcp::ModifiedGammaTransferFunction> tf = dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (_in);
+               in_node->add_child("Type")->add_child_text ("ModifiedGamma");
+               in_node->add_child("Power")->add_child_text (raw_convert<string> (tf->power ()));
+               in_node->add_child("Threshold")->add_child_text (raw_convert<string> (tf->threshold ()));
+               in_node->add_child("A")->add_child_text (raw_convert<string> (tf->A ()));
+               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");
        for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 3; ++j) {
                        xmlpp::Element* m = node->add_child("Matrix");


@@ -109,7 +115,7 @@ ColourConversion::as_xml (xmlpp::Node* node) const
                }
        }
 
                }
        }
 

-       node->add_child("OutputGamma")->add_child_text (raw_convert<string> (output_gamma));
+       node->add_child("OutputGamma")->add_child_text (raw_convert<string> (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_out)->gamma ()));

 }
 
 optional<size_t>
 }
 
 optional<size_t>


@@ -132,15 +138,26 @@ string
 ColourConversion::identifier () const
 {
        MD5Digester digester;
 ColourConversion::identifier () const
 {
        MD5Digester digester;

-       
-       digester.add (input_gamma);
-       digester.add (input_gamma_linearised);
+
+       if (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_in)) {
+               shared_ptr<const dcp::GammaTransferFunction> tf = dynamic_pointer_cast<const dcp::GammaTransferFunction> (_in);
+               digester.add (tf->gamma ());
+       } else if (dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (_in)) {
+               shared_ptr<const dcp::ModifiedGammaTransferFunction> tf = dynamic_pointer_cast<const dcp::ModifiedGammaTransferFunction> (_in);
+               digester.add (tf->power ());
+               digester.add (tf->threshold ());
+               digester.add (tf->A ());
+               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));
                }
        }
        for (int i = 0; i < 3; ++i) {
                for (int j = 0; j < 3; ++j) {
                        digester.add (matrix (i, j));
                }
        }

-       digester.add (output_gamma);
+
+       digester.add (dynamic_pointer_cast<const dcp::GammaTransferFunction> (_out)->gamma ());

        
        return digester.get ();
 }
        
        return digester.get ();
 }


@@ -151,9 +168,9 @@ PresetColourConversion::PresetColourConversion ()
 
 }
 
 
 }
 

-PresetColourConversion::PresetColourConversion (string n, double i, bool il, double const m[3][3], double o)
+PresetColourConversion::PresetColourConversion (string n, dcp::ColourConversion conversion_)

        : name (n)
        : name (n)

-       , conversion (i, il, m, o)
+       , conversion (conversion_)

 {
 
 }
 {
 
 }


@@ -171,32 +188,10 @@ PresetColourConversion::as_xml (xmlpp::Node* node) const
        node->add_child("Name")->add_child_text (name);
 }
 
        node->add_child("Name")->add_child_text (name);
 }
 

-static bool
-about_equal (double a, double b)
-{
-       static const double eps = 1e-6;
-       return fabs (a - b) < eps;
-}
-

 bool
 operator== (ColourConversion const & a, ColourConversion const & b)
 {
 bool
 operator== (ColourConversion const & a, ColourConversion const & b)
 {

-       if (
-               !about_equal (a.input_gamma, b.input_gamma) ||
-               a.input_gamma_linearised != b.input_gamma_linearised ||
-               !about_equal (a.output_gamma, b.output_gamma)) {
-               return false;
-       }
-
-       for (int i = 0; i < 3; ++i) {
-               for (int j = 0; j < 3; ++j) {
-                       if (!about_equal (a.matrix (i, j), b.matrix (i, j))) {
-                               return false;
-                       }
-               }
-       }
-
-       return true;
+       return a.about_equal (b, 1e-6);

 }
 
 bool
 }
 
 bool

diff --git a/src/lib/colour_conversion.h b/src/lib/colour_conversion.h
index dbc6c9d9d970ac11f22e5a7ab4744d8f0e26f5f4..bf883a07c32413f3bd28071ee287882ea6cc0a08 100644 (file)
--- a/src/lib/colour_conversion.h
+++ b/src/lib/colour_conversion.h
@@ -25,20 +25,19 @@
 #undef check
 #endif
 
 #undef check
 #endif
 

+#include <dcp/colour_conversion.h>

 #include <libcxml/cxml.h>
 #include <boost/utility.hpp>
 #include <libcxml/cxml.h>
 #include <boost/utility.hpp>

-#include <boost/optional.hpp>
-#include <boost/numeric/ublas/matrix.hpp>

 
 namespace xmlpp {
        class Node;
 }
 
 
 namespace xmlpp {
        class Node;
 }
 

-class ColourConversion
+class ColourConversion : public dcp::ColourConversion

 {
 public:
        ColourConversion ();
 {
 public:
        ColourConversion ();

-       ColourConversion (double, bool, double const matrix[3][3], double);
+       ColourConversion (dcp::ColourConversion);

        ColourConversion (cxml::NodePtr);
 
        virtual void as_xml (xmlpp::Node *) const;
        ColourConversion (cxml::NodePtr);
 
        virtual void as_xml (xmlpp::Node *) const;


@@ -47,18 +46,13 @@ public:
        boost::optional<size_t> preset () const;
 
        static boost::optional<ColourConversion> from_xml (cxml::NodePtr);
        boost::optional<size_t> preset () const;
 
        static boost::optional<ColourConversion> from_xml (cxml::NodePtr);

-
-       double input_gamma;
-       bool input_gamma_linearised;
-       boost::numeric::ublas::matrix<double> matrix;
-       double output_gamma;

 };
 
 class PresetColourConversion
 {
 public:
        PresetColourConversion ();
 };
 
 class PresetColourConversion
 {
 public:
        PresetColourConversion ();

-       PresetColourConversion (std::string, double, bool, double const matrix[3][3], double);
+       PresetColourConversion (std::string, dcp::ColourConversion);

        PresetColourConversion (cxml::NodePtr);
 
        void as_xml (xmlpp::Node *) const;
        PresetColourConversion (cxml::NodePtr);
 
        void as_xml (xmlpp::Node *) const;

diff --git a/src/lib/config.cc b/src/lib/config.cc
index c571376f0f35536c062652a662cdc47bf86295c8..485ecbad7326a6348d8bc8ea4df6a5238419e47f 100644 (file)
--- a/src/lib/config.cc
+++ b/src/lib/config.cc
@@ -85,9 +85,8 @@ Config::Config ()
        _allowed_dcp_frame_rates.push_back (50);
        _allowed_dcp_frame_rates.push_back (60);
 
        _allowed_dcp_frame_rates.push_back (50);
        _allowed_dcp_frame_rates.push_back (60);
 

-       _colour_conversions.push_back (PresetColourConversion (_("sRGB"), 2.4, true, dcp::colour_matrix::srgb_to_xyz, 2.6));
-       _colour_conversions.push_back (PresetColourConversion (_("sRGB non-linearised"), 2.4, false, dcp::colour_matrix::srgb_to_xyz, 2.6));
-       _colour_conversions.push_back (PresetColourConversion (_("Rec. 709"), 2.2, false, dcp::colour_matrix::rec709_to_xyz, 2.6));
+       _colour_conversions.push_back (PresetColourConversion (_("sRGB"), dcp::ColourConversion::srgb_to_xyz));
+       _colour_conversions.push_back (PresetColourConversion (_("Rec. 709"), dcp::ColourConversion::rec709_to_xyz));

 
        reset_kdm_email ();
 }
 
        reset_kdm_email ();
 }


@@ -177,16 +176,15 @@ Config::read ()
        if (!cc.empty ()) {
                _colour_conversions.clear ();
        }
        if (!cc.empty ()) {
                _colour_conversions.clear ();
        }

-       
-       for (list<cxml::NodePtr>::iterator i = cc.begin(); i != cc.end(); ++i) {
-               _colour_conversions.push_back (PresetColourConversion (*i));
-       }

 
 

-       if (!version) {
-               /* Loading version 0 (before Rec. 709 was added as a preset).
-                  Add it in.
-               */
-               _colour_conversions.push_back (PresetColourConversion (_("Rec. 709"), 2.2, false, dcp::colour_matrix::rec709_to_xyz, 2.6));
+       try {
+               for (list<cxml::NodePtr>::iterator i = cc.begin(); i != cc.end(); ++i) {
+                       _colour_conversions.push_back (PresetColourConversion (*i));
+               }
+       } catch (cxml::Error) {
+               /* Probably failed to load an old-style ColourConversion tag; just give up */
+               _colour_conversions.push_back (PresetColourConversion (_("sRGB"), dcp::ColourConversion::srgb_to_xyz));
+               _colour_conversions.push_back (PresetColourConversion (_("Rec. 709"), dcp::ColourConversion::rec709_to_xyz));

        }
 
        list<cxml::NodePtr> cin = f.node_children ("Cinema");
        }
 
        list<cxml::NodePtr> cin = f.node_children ("Cinema");

diff --git a/src/lib/dcp_video.cc b/src/lib/dcp_video.cc
index 62340a4683eda8dbdeede0d3facbd6aedb6942c6..cca199b05f793d56e3ba6001856421e0ddf72995 100644 (file)
--- a/src/lib/dcp_video.cc
+++ b/src/lib/dcp_video.cc
@@ -41,7 +41,6 @@
 #include "player_video.h"
 #include "encoded_data.h"
 #include <libcxml/cxml.h>
 #include "player_video.h"
 #include "encoded_data.h"
 #include <libcxml/cxml.h>

-#include <dcp/gamma_lut.h>

 #include <dcp/xyz_frame.h>
 #include <dcp/rgb_xyz.h>
 #include <dcp/colour_matrix.h>
 #include <dcp/xyz_frame.h>
 #include <dcp/rgb_xyz.h>
 #include <dcp/colour_matrix.h>


@@ -114,25 +113,9 @@ DCPVideo::encode_locally ()
        shared_ptr<dcp::XYZFrame> xyz;
 
        if (_frame->colour_conversion()) {
        shared_ptr<dcp::XYZFrame> xyz;
 
        if (_frame->colour_conversion()) {

-               ColourConversion conversion = _frame->colour_conversion().get ();
-               shared_ptr<dcp::GammaLUT> in_lut = dcp::GammaLUT::cache.get (
-                       12, conversion.input_gamma, conversion.input_gamma_linearised
-                       );
-               
-               /* XXX: dcp should probably use boost */
-               
-               double matrix[3][3];
-               for (int i = 0; i < 3; ++i) {
-                       for (int j = 0; j < 3; ++j) {
-                               matrix[i][j] = conversion.matrix (i, j);
-                       }
-               }
-               

                xyz = dcp::rgb_to_xyz (
                        _frame->image (AV_PIX_FMT_RGB48LE, _burn_subtitles),
                xyz = dcp::rgb_to_xyz (
                        _frame->image (AV_PIX_FMT_RGB48LE, _burn_subtitles),

-                       in_lut,
-                       dcp::GammaLUT::cache.get (16, 1 / conversion.output_gamma, false),
-                       matrix
+                       _frame->colour_conversion().get()

                        );
        } else {
                xyz = dcp::xyz_to_xyz (_frame->image (AV_PIX_FMT_RGB48LE, _burn_subtitles));
                        );
        } else {
                xyz = dcp::xyz_to_xyz (_frame->image (AV_PIX_FMT_RGB48LE, _burn_subtitles));

diff --git a/src/lib/video_content.cc b/src/lib/video_content.cc
index 1a03c2af2b04da6748a8f42845ca78569e019919..5cf4704ea73585f4bcb306cfcfa82d7dec861e12 100644 (file)
--- a/src/lib/video_content.cc
+++ b/src/lib/video_content.cc
@@ -208,7 +208,7 @@ VideoContent::set_default_colour_conversion (bool signal)
 {
        {
                boost::mutex::scoped_lock lm (_mutex);
 {
        {
                boost::mutex::scoped_lock lm (_mutex);

-               _colour_conversion = PresetColourConversion (_("sRGB"), 2.4, true, dcp::colour_matrix::srgb_to_xyz, 2.6).conversion;
+               _colour_conversion = ColourConversion (dcp::ColourConversion::srgb_to_xyz);

        }
 
        if (signal) {
        }
 
        if (signal) {

diff --git a/src/wx/colour_conversion_editor.cc b/src/wx/colour_conversion_editor.cc
index 129c6f2ea46e44c9483953e8bc0ac9a3dc79605a..e11c09f1761ea18e038a1d2313fda63666eb960c 100644 (file)
--- a/src/wx/colour_conversion_editor.cc
+++ b/src/wx/colour_conversion_editor.cc
@@ -1,5 +1,5 @@
 /*
 /*

-    Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2013-2014 Carl Hetherington <cth@carlh.net>

 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by


@@ -17,18 +17,23 @@
 
 */
 
 
 */
 

-#include <boost/lexical_cast.hpp>
-#include <wx/spinctrl.h>
-#include <wx/gbsizer.h>

 #include "lib/colour_conversion.h"
 #include "lib/safe_stringstream.h"
 #include "wx_util.h"
 #include "colour_conversion_editor.h"
 #include "lib/colour_conversion.h"
 #include "lib/safe_stringstream.h"
 #include "wx_util.h"
 #include "colour_conversion_editor.h"

+#include <dcp/gamma_transfer_function.h>
+#include <dcp/modified_gamma_transfer_function.h>
+#include <dcp/raw_convert.h>
+#include <wx/spinctrl.h>
+#include <wx/gbsizer.h>
+#include <boost/lexical_cast.hpp>

 
 using std::string;
 using std::cout;
 using boost::shared_ptr;
 
 using std::string;
 using std::cout;
 using boost::shared_ptr;

+using boost::dynamic_pointer_cast;

 using boost::lexical_cast;
 using boost::lexical_cast;

+using dcp::raw_convert;

 
 ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
        : wxPanel (parent, wxID_ANY)
 
 ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
        : wxPanel (parent, wxID_ANY)


@@ -41,15 +46,35 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
 
        int r = 0;
 
 
        int r = 0;
 

+       _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;
+

        add_label_to_grid_bag_sizer (table, this, _("Input gamma"), true, wxGBPosition (r, 0));
        _input_gamma = new wxSpinCtrlDouble (this);
        table->Add (_input_gamma, wxGBPosition (r, 1));
        ++r;
 
        add_label_to_grid_bag_sizer (table, this, _("Input gamma"), true, wxGBPosition (r, 0));
        _input_gamma = new wxSpinCtrlDouble (this);
        table->Add (_input_gamma, wxGBPosition (r, 1));
        ++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));
+       add_label_to_grid_bag_sizer (table, this, _("Input power"), true, wxGBPosition (r, 0));
+       _input_power = new wxSpinCtrlDouble (this);
+       table->Add (_input_power, wxGBPosition (r, 1));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("Input threshold"), true, wxGBPosition (r, 0));
+       _input_threshold = new wxTextCtrl (this, wxID_ANY, wxT (""));
+       table->Add (_input_threshold, wxGBPosition (r, 1));
+       ++r;
+
+       add_label_to_grid_bag_sizer (table, this, _("Input A value"), true, wxGBPosition (r, 0));
+       _input_A = new wxTextCtrl (this, wxID_ANY, wxT (""));
+       table->Add (_input_A, wxGBPosition (r, 1));

        ++r;
 
        ++r;
 

+       add_label_to_grid_bag_sizer (table, this, _("Input B value"), true, wxGBPosition (r, 0));
+       _input_B = new wxTextCtrl (this, wxID_ANY, wxT (""));
+       table->Add (_input_B, wxGBPosition (r, 1));
+       ++r;
+       

         wxClientDC dc (parent);
         wxSize size = dc.GetTextExtent (wxT ("-0.12345678901"));
         size.SetHeight (-1);
         wxClientDC dc (parent);
         wxSize size = dc.GetTextExtent (wxT ("-0.12345678901"));
         size.SetHeight (-1);


@@ -88,12 +113,19 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
        _input_gamma->SetRange (0.1, 4.0);
        _input_gamma->SetDigits (2);
        _input_gamma->SetIncrement (0.1);
        _input_gamma->SetRange (0.1, 4.0);
        _input_gamma->SetDigits (2);
        _input_gamma->SetIncrement (0.1);

+       _input_power->SetRange (0.1, 4.0);
+       _input_power->SetDigits (2);
+       _input_power->SetIncrement (0.1);

        _output_gamma->SetRange (0.1, 4.0);
        _output_gamma->SetDigits (2);
        _output_gamma->SetIncrement (0.1);
 
        _input_gamma->Bind (wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, boost::bind (&ColourConversionEditor::changed, this, _input_gamma));
        _input_gamma_linearised->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&ColourConversionEditor::changed, this));
        _output_gamma->SetRange (0.1, 4.0);
        _output_gamma->SetDigits (2);
        _output_gamma->SetIncrement (0.1);
 
        _input_gamma->Bind (wxEVT_COMMAND_SPINCTRLDOUBLE_UPDATED, boost::bind (&ColourConversionEditor::changed, this, _input_gamma));
        _input_gamma_linearised->Bind (wxEVT_COMMAND_CHECKBOX_CLICKED, boost::bind (&ColourConversionEditor::changed, this));

+       _input_power->Bind (wxEVT_COMMAND_TEXT_UPDATED, boost::bind (&ColourConversionEditor::changed, this));
+       _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));
        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));


@@ -105,40 +137,72 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent)
 void
 ColourConversionEditor::set (ColourConversion conversion)
 {
 void
 ColourConversionEditor::set (ColourConversion conversion)
 {

-       set_spin_ctrl (_input_gamma, conversion.input_gamma);
-       _input_gamma_linearised->SetValue (conversion.input_gamma_linearised);
+       if (dynamic_pointer_cast<const dcp::GammaTransferFunction> (conversion.in ())) {
+               shared_ptr<const dcp::GammaTransferFunction> tf = dynamic_pointer_cast<const dcp::GammaTransferFunction> (conversion.in ());
+               _input_gamma_linearised->SetValue (false);
+               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 */
+               _input_gamma->SetValue (2.2);
+               _input_gamma_linearised->SetValue (true);
+               set_spin_ctrl (_input_power, tf->power ());
+               set_text_ctrl (_input_threshold, tf->threshold ());
+               set_text_ctrl (_input_A, tf->A ());
+               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) {
        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 << conversion.matrix (i, j);
-                       _matrix[i][j]->SetValue (std_to_wx (s.str ()));
+                       set_text_ctrl (_matrix[i][j], matrix(i, j));

                }
        }
                }
        }

-       set_spin_ctrl (_output_gamma, conversion.output_gamma);
+       
+       set_spin_ctrl (_output_gamma, dynamic_pointer_cast<const dcp::GammaTransferFunction> (conversion.out ())->gamma ());

 }
 
 ColourConversion
 ColourConversionEditor::get () const
 {
        ColourConversion conversion;
 }
 
 ColourConversion
 ColourConversionEditor::get () const
 {
        ColourConversion conversion;

-       
-       conversion.input_gamma = _input_gamma->GetValue ();
-       conversion.input_gamma_linearised = _input_gamma_linearised->GetValue ();

 
 

+       if (_input_gamma_linearised->GetValue ()) {
+               conversion.set_in (
+                       shared_ptr<dcp::ModifiedGammaTransferFunction> (
+                               new dcp::ModifiedGammaTransferFunction (
+                                       _input_power->GetValue (),
+                                       raw_convert<double> (wx_to_std (_input_threshold->GetValue ())),
+                                       raw_convert<double> (wx_to_std (_input_A->GetValue ())),
+                                       raw_convert<double> (wx_to_std (_input_B->GetValue ()))
+                                       )
+                               )
+                       );
+       } else {
+               conversion.set_in (
+                       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 ()) {
        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 ()) {

-                               conversion.matrix (i, j) = 0;
+                               matrix (i, j) = 0;

                        } else {
                        } else {

-                               conversion.matrix (i, j) = lexical_cast<double> (v);
+                               matrix (i, j) = raw_convert<double> (v);

                        }
                }
        }
                        }
                }
        }

-       
-       conversion.output_gamma = _output_gamma->GetValue ();
+
+       conversion.set_matrix (matrix);
+
+       conversion.set_out (shared_ptr<dcp::GammaTransferFunction> (new dcp::GammaTransferFunction (_output_gamma->GetValue ())));

 
        return conversion;
 }
 
        return conversion;
 }


@@ -146,6 +210,13 @@ ColourConversionEditor::get () const
 void
 ColourConversionEditor::changed ()
 {
 void
 ColourConversionEditor::changed ()
 {

+       bool const lin = _input_gamma_linearised->GetValue ();
+       _input_gamma->Enable (!lin);
+       _input_power->Enable (lin);
+       _input_threshold->Enable (lin);
+       _input_A->Enable (lin);
+       _input_B->Enable (lin);
+       

        Changed ();
 }
 
        Changed ();
 }
 


@@ -170,3 +241,11 @@ ColourConversionEditor::set_spin_ctrl (wxSpinCtrlDouble* control, double value)
        control->SetValue (value);
 }
 
        control->SetValue (value);
 }
 

+void
+ColourConversionEditor::set_text_ctrl (wxTextCtrl* control, double value)
+{
+       SafeStringStream s;
+       s.precision (7);
+       s << value;
+       control->SetValue (std_to_wx (s.str ()));
+}

diff --git a/src/wx/colour_conversion_editor.h b/src/wx/colour_conversion_editor.h
index ed22104e2addef25309d8bd635f5792b8f9f7fef..317171aa483129450c2d6f0539a0868f7389befa 100644 (file)
--- a/src/wx/colour_conversion_editor.h
+++ b/src/wx/colour_conversion_editor.h
@@ -1,5 +1,5 @@
 /*
 /*

-    Copyright (C) 2013 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2013-2014 Carl Hetherington <cth@carlh.net>

 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by


@@ -40,11 +40,16 @@ private:
        void changed ();
        void changed (wxSpinCtrlDouble *);
 
        void changed ();
        void changed (wxSpinCtrlDouble *);
 

+       void set_text_ctrl (wxTextCtrl *, double);

        void set_spin_ctrl (wxSpinCtrlDouble *, double);
 
        std::map<wxSpinCtrlDouble*, double> _last_spin_ctrl_value;
        
        wxSpinCtrlDouble* _input_gamma;
        void set_spin_ctrl (wxSpinCtrlDouble *, double);
 
        std::map<wxSpinCtrlDouble*, double> _last_spin_ctrl_value;
        
        wxSpinCtrlDouble* _input_gamma;

+       wxSpinCtrlDouble* _input_power;
+       wxTextCtrl* _input_threshold;
+       wxTextCtrl* _input_A;
+       wxTextCtrl* _input_B;

        wxCheckBox* _input_gamma_linearised;
        wxTextCtrl* _matrix[3][3];
        wxSpinCtrlDouble* _output_gamma;
        wxCheckBox* _input_gamma_linearised;
        wxTextCtrl* _matrix[3][3];
        wxSpinCtrlDouble* _output_gamma;

diff --git a/test/colour_conversion_test.cc b/test/colour_conversion_test.cc
index 7de169dd3e305ad23d76dbaf12b756ef80ccaebb..eb3e3c294f2432f19a1dce31384c920e422b1510 100644 (file)
--- a/test/colour_conversion_test.cc
+++ b/test/colour_conversion_test.cc
@@ -18,20 +18,85 @@
 */
 
 /** @file  test/colour_conversion_test.cc
 */
 
 /** @file  test/colour_conversion_test.cc

- *  @brief Basic test of identifier() for ColourConversion (i.e. a hash of the numbers)
+ *  @brief Various tests of ColourConversion.

  */
 
  */
 

-#include <boost/test/unit_test.hpp>
-#include <dcp/colour_matrix.h>

 #include "lib/colour_conversion.h"
 #include "lib/colour_conversion.h"

+#include <dcp/colour_matrix.h>
+#include <dcp/gamma_transfer_function.h>
+#include <libxml++/libxml++.h>
+#include <boost/test/unit_test.hpp>

 
 using std::cout;
 
 using std::cout;

+using boost::shared_ptr;
+
+BOOST_AUTO_TEST_CASE (colour_conversion_test1)
+{
+       ColourConversion A (dcp::ColourConversion::srgb_to_xyz);
+       ColourConversion B (dcp::ColourConversion::rec709_to_xyz);
+
+       BOOST_CHECK_EQUAL (A.identifier(), "8b5a265a7c63c22a6a8fc871c64d6116");
+       BOOST_CHECK_EQUAL (B.identifier(), "bc82e69f700d0426f2ae1848d05ed006");
+}

 
 

-BOOST_AUTO_TEST_CASE (colour_conversion_test)
+BOOST_AUTO_TEST_CASE (colour_conversion_test2)

 {
 {

-       ColourConversion A (2.4, true, dcp::colour_matrix::srgb_to_xyz, 2.6);
-       ColourConversion B (2.4, false, dcp::colour_matrix::srgb_to_xyz, 2.6);
+       ColourConversion A (dcp::ColourConversion::srgb_to_xyz);
+       xmlpp::Document doc;
+       xmlpp::Element* root = doc.create_root_node ("Test");
+       A.as_xml (root);
+       BOOST_CHECK_EQUAL (
+               doc.write_to_string_formatted ("UTF-8"),
+               "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+               "<Test>\n"
+               "  <InputTransferFunction>\n"
+               "    <Type>ModifiedGamma</Type>\n"
+               "    <Power>2.400000095367432</Power>\n"
+               "    <Threshold>0.04044999927282333</Threshold>\n"
+               "    <A>0.05499999970197678</A>\n"
+               "    <B>12.92000007629395</B>\n"
+               "  </InputTransferFunction>\n"
+               "  <Matrix i=\"0\" j=\"0\">0.4124564</Matrix>\n"
+               "  <Matrix i=\"0\" j=\"1\">0.3575761</Matrix>\n"
+               "  <Matrix i=\"0\" j=\"2\">0.1804375</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"0\">0.2126729</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"1\">0.7151522</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"2\">0.072175</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"0\">0.0193339</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"1\">0.119192</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"2\">0.9503041</Matrix>\n"
+               "  <OutputGamma>2.599999904632568</OutputGamma>\n"
+               "</Test>\n"
+               );
+}

 
 

-       BOOST_CHECK_EQUAL (A.identifier(), "1e720d2d99add654d7816f3b72da815e");
-       BOOST_CHECK_EQUAL (B.identifier(), "18751a247b22682b725bf9c4caf71522");
+BOOST_AUTO_TEST_CASE (colour_conversion_test3)
+{
+       ColourConversion A (dcp::ColourConversion::rec709_to_xyz);
+       xmlpp::Document doc;
+       xmlpp::Element* root = doc.create_root_node ("Test");
+       A.as_xml (root);
+       BOOST_CHECK_EQUAL (
+               doc.write_to_string_formatted ("UTF-8"),
+               "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+               "<Test>\n"
+               "  <InputTransferFunction>\n"
+               "    <Type>ModifiedGamma</Type>\n"
+               "    <Power>2.400000095367432</Power>\n"
+               "    <Threshold>0.08100000023841858</Threshold>\n"
+               "    <A>0.0989999994635582</A>\n"
+               "    <B>4.5</B>\n"
+               "  </InputTransferFunction>\n"
+               "  <Matrix i=\"0\" j=\"0\">0.4124564</Matrix>\n"
+               "  <Matrix i=\"0\" j=\"1\">0.3575761</Matrix>\n"
+               "  <Matrix i=\"0\" j=\"2\">0.1804375</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"0\">0.2126729</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"1\">0.7151522</Matrix>\n"
+               "  <Matrix i=\"1\" j=\"2\">0.072175</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"0\">0.0193339</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"1\">0.119192</Matrix>\n"
+               "  <Matrix i=\"2\" j=\"2\">0.9503041</Matrix>\n"
+               "  <OutputGamma>2.599999904632568</OutputGamma>\n"
+               "</Test>\n"
+               );

 }
 }