From 6154d5f85664a26e9490c9120bef5e742af94490 Mon Sep 17 00:00:00 2001 From: Carl Hetherington Date: Sun, 28 Dec 2014 01:00:25 +0000 Subject: [PATCH] Basic adaptations for changes to libdcp1 colour conversion handling. --- TO_PORT | 2 + src/lib/colour_conversion.cc | 119 ++++++++++++++-------------- src/lib/colour_conversion.h | 14 +--- src/lib/config.cc | 22 +++--- src/lib/dcp_video.cc | 19 +---- src/lib/video_content.cc | 2 +- src/wx/colour_conversion_editor.cc | 121 ++++++++++++++++++++++++----- src/wx/colour_conversion_editor.h | 7 +- test/colour_conversion_test.cc | 81 +++++++++++++++++-- 9 files changed, 254 insertions(+), 133 deletions(-) diff --git a/TO_PORT b/TO_PORT index e69de29bb..db911a582 100644 --- 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 6dd4ab876..32bc3c1a5 100644 --- a/src/lib/colour_conversion.cc +++ b/src/lib/colour_conversion.cc @@ -23,6 +23,8 @@ #include "md5_digester.h" #include #include +#include +#include #include #include @@ -34,60 +36,52 @@ using std::cout; using std::vector; using boost::shared_ptr; using boost::optional; +using boost::dynamic_pointer_cast; 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) - : matrix (3, 3) { - input_gamma = node->number_child ("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 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 ("Gamma"))); + } else if (in_type == "ModifiedGamma") { + _in.reset (new dcp::ModifiedGammaTransferFunction ( + in_node->number_child ("Power"), + in_node->number_child ("Threshold"), + in_node->number_child ("A"), + in_node->number_child ("B") + )); } list m = node->node_children ("Matrix"); for (list::iterator i = m.begin(); i != m.end(); ++i) { int const ti = (*i)->number_attribute ("i"); int const tj = (*i)->number_attribute ("j"); - matrix(ti, tj) = raw_convert ((*i)->content ()); + _matrix(ti, tj) = raw_convert ((*i)->content ()); } - output_gamma = node->number_child ("OutputGamma"); + _out.reset (new dcp::GammaTransferFunction (node->number_child ("OutputGamma"))); } boost::optional ColourConversion::from_xml (cxml::NodePtr node) { - if (!node->optional_node_child ("InputGamma")) { + if (!node->optional_node_child ("InputTransferFunction")) { return boost::optional (); } @@ -97,9 +91,21 @@ ColourConversion::from_xml (cxml::NodePtr node) void ColourConversion::as_xml (xmlpp::Node* node) const { - node->add_child("InputGamma")->add_child_text (raw_convert (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 (_in)) { + shared_ptr tf = dynamic_pointer_cast (_in); + in_node->add_child("Type")->add_child_text ("Gamma"); + in_node->add_child("Gamma")->add_child_text (raw_convert (tf->gamma ())); + } else if (dynamic_pointer_cast (_in)) { + shared_ptr tf = dynamic_pointer_cast (_in); + in_node->add_child("Type")->add_child_text ("ModifiedGamma"); + in_node->add_child("Power")->add_child_text (raw_convert (tf->power ())); + in_node->add_child("Threshold")->add_child_text (raw_convert (tf->threshold ())); + in_node->add_child("A")->add_child_text (raw_convert (tf->A ())); + in_node->add_child("B")->add_child_text (raw_convert (tf->B ())); + } + boost::numeric::ublas::matrix matrix = _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 (output_gamma)); + node->add_child("OutputGamma")->add_child_text (raw_convert (dynamic_pointer_cast (_out)->gamma ())); } optional @@ -132,15 +138,26 @@ string ColourConversion::identifier () const { MD5Digester digester; - - digester.add (input_gamma); - digester.add (input_gamma_linearised); + + if (dynamic_pointer_cast (_in)) { + shared_ptr tf = dynamic_pointer_cast (_in); + digester.add (tf->gamma ()); + } else if (dynamic_pointer_cast (_in)) { + shared_ptr tf = dynamic_pointer_cast (_in); + digester.add (tf->power ()); + digester.add (tf->threshold ()); + digester.add (tf->A ()); + digester.add (tf->B ()); + } + + boost::numeric::ublas::matrix matrix = _matrix; 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 (_out)->gamma ()); 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) - , 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); } -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) { - 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 diff --git a/src/lib/colour_conversion.h b/src/lib/colour_conversion.h index dbc6c9d9d..bf883a07c 100644 --- a/src/lib/colour_conversion.h +++ b/src/lib/colour_conversion.h @@ -25,20 +25,19 @@ #undef check #endif +#include #include #include -#include -#include namespace xmlpp { class Node; } -class ColourConversion +class ColourConversion : public dcp::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; @@ -47,18 +46,13 @@ public: boost::optional preset () const; static boost::optional from_xml (cxml::NodePtr); - - double input_gamma; - bool input_gamma_linearised; - boost::numeric::ublas::matrix matrix; - double output_gamma; }; 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; diff --git a/src/lib/config.cc b/src/lib/config.cc index c571376f0..485ecbad7 100644 --- 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); - _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 (); } @@ -177,16 +176,15 @@ Config::read () if (!cc.empty ()) { _colour_conversions.clear (); } - - for (list::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::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 cin = f.node_children ("Cinema"); diff --git a/src/lib/dcp_video.cc b/src/lib/dcp_video.cc index 62340a468..cca199b05 100644 --- 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 -#include #include #include #include @@ -114,25 +113,9 @@ DCPVideo::encode_locally () shared_ptr xyz; if (_frame->colour_conversion()) { - ColourConversion conversion = _frame->colour_conversion().get (); - shared_ptr 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), - 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)); diff --git a/src/lib/video_content.cc b/src/lib/video_content.cc index 1a03c2af2..5cf4704ea 100644 --- 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); - _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) { diff --git a/src/wx/colour_conversion_editor.cc b/src/wx/colour_conversion_editor.cc index 129c6f2ea..e11c09f17 100644 --- a/src/wx/colour_conversion_editor.cc +++ b/src/wx/colour_conversion_editor.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2014 Carl Hetherington 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 -#include -#include #include "lib/colour_conversion.h" #include "lib/safe_stringstream.h" #include "wx_util.h" #include "colour_conversion_editor.h" +#include +#include +#include +#include +#include +#include using std::string; using std::cout; using boost::shared_ptr; +using boost::dynamic_pointer_cast; using boost::lexical_cast; +using dcp::raw_convert; ColourConversionEditor::ColourConversionEditor (wxWindow* parent) : wxPanel (parent, wxID_ANY) @@ -41,15 +46,35 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent) 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; - _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; + 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); @@ -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_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)); + _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)); @@ -105,40 +137,72 @@ ColourConversionEditor::ColourConversionEditor (wxWindow* parent) 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 (conversion.in ())) { + shared_ptr tf = dynamic_pointer_cast (conversion.in ()); + _input_gamma_linearised->SetValue (false); + set_spin_ctrl (_input_gamma, tf->gamma ()); + } else if (dynamic_pointer_cast (conversion.in ())) { + shared_ptr tf = dynamic_pointer_cast (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 matrix = conversion.matrix (); 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 (conversion.out ())->gamma ()); } 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 ( + new dcp::ModifiedGammaTransferFunction ( + _input_power->GetValue (), + raw_convert (wx_to_std (_input_threshold->GetValue ())), + raw_convert (wx_to_std (_input_A->GetValue ())), + raw_convert (wx_to_std (_input_B->GetValue ())) + ) + ) + ); + } else { + conversion.set_in ( + shared_ptr ( + new dcp::GammaTransferFunction ( + _input_gamma->GetValue () + ) + ) + ); + } + + boost::numeric::ublas::matrix 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 ()) { - conversion.matrix (i, j) = 0; + matrix (i, j) = 0; } else { - conversion.matrix (i, j) = lexical_cast (v); + matrix (i, j) = raw_convert (v); } } } - - conversion.output_gamma = _output_gamma->GetValue (); + + conversion.set_matrix (matrix); + + conversion.set_out (shared_ptr (new dcp::GammaTransferFunction (_output_gamma->GetValue ()))); return conversion; } @@ -146,6 +210,13 @@ ColourConversionEditor::get () const 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 (); } @@ -170,3 +241,11 @@ ColourConversionEditor::set_spin_ctrl (wxSpinCtrlDouble* control, double 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 ed22104e2..317171aa4 100644 --- a/src/wx/colour_conversion_editor.h +++ b/src/wx/colour_conversion_editor.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2014 Carl Hetherington 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 set_text_ctrl (wxTextCtrl *, double); void set_spin_ctrl (wxSpinCtrlDouble *, double); std::map _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; diff --git a/test/colour_conversion_test.cc b/test/colour_conversion_test.cc index 7de169dd3..eb3e3c294 100644 --- a/test/colour_conversion_test.cc +++ b/test/colour_conversion_test.cc @@ -18,20 +18,85 @@ */ /** @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 -#include #include "lib/colour_conversion.h" +#include +#include +#include +#include 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"), + "\n" + "\n" + " \n" + " ModifiedGamma\n" + " 2.400000095367432\n" + " 0.04044999927282333\n" + " 0.05499999970197678\n" + " 12.92000007629395\n" + " \n" + " 0.4124564\n" + " 0.3575761\n" + " 0.1804375\n" + " 0.2126729\n" + " 0.7151522\n" + " 0.072175\n" + " 0.0193339\n" + " 0.119192\n" + " 0.9503041\n" + " 2.599999904632568\n" + "\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"), + "\n" + "\n" + " \n" + " ModifiedGamma\n" + " 2.400000095367432\n" + " 0.08100000023841858\n" + " 0.0989999994635582\n" + " 4.5\n" + " \n" + " 0.4124564\n" + " 0.3575761\n" + " 0.1804375\n" + " 0.2126729\n" + " 0.7151522\n" + " 0.072175\n" + " 0.0193339\n" + " 0.119192\n" + " 0.9503041\n" + " 2.599999904632568\n" + "\n" + ); } -- 2.30.2