X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Faudio_mapping.cc;h=b436d757988a3e054657d627b6d9258fde308380;hb=a306df9145d16046e51e8b7ff5222e341e98fdbd;hp=d0aa33657fb383c9fbddcdde996186a9485e4b92;hpb=a0856e3fbef17f24073b01cb96be6bbcb229ecbc;p=dcpomatic.git diff --git a/src/lib/audio_mapping.cc b/src/lib/audio_mapping.cc index d0aa33657..b436d7579 100644 --- a/src/lib/audio_mapping.cc +++ b/src/lib/audio_mapping.cc @@ -1,118 +1,191 @@ -/* -*- c-basic-offset: 8; default-tab-width: 8; -*- */ - /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2015 Carl Hetherington + + This file is part of DCP-o-matic. - This program is free software; you can redistribute it and/or modify + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ -#include -#include -#include #include "audio_mapping.h" +#include "util.h" +#include "digester.h" +#include "raw_convert.h" +#include +#include +#include using std::list; using std::cout; using std::make_pair; using std::pair; using std::string; +using std::min; +using std::vector; +using std::abs; using boost::shared_ptr; -using boost::lexical_cast; using boost::dynamic_pointer_cast; AudioMapping::AudioMapping () + : _input_channels (0) + , _output_channels (0) { } -/** Create a default AudioMapping for a given channel count. - * @param c Number of channels. +/** Create an empty AudioMapping. + * @param input_channels Number of input channels. + * @param output_channels Number of output channels. */ -AudioMapping::AudioMapping (int c) +AudioMapping::AudioMapping (int input_channels, int output_channels) { - if (c == 1) { - /* Mono -> Centre */ - add (0, libdcp::CENTRE); - } else { - /* 1:1 mapping */ - for (int i = 0; i < c; ++i) { - add (i, static_cast (i)); + setup (input_channels, output_channels); +} + +void +AudioMapping::setup (int input_channels, int output_channels) +{ + _input_channels = input_channels; + _output_channels = output_channels; + + _gain.resize (_input_channels); + for (int i = 0; i < _input_channels; ++i) { + _gain[i].resize (_output_channels); + } + + make_zero (); +} + +void +AudioMapping::make_zero () +{ + for (int i = 0; i < _input_channels; ++i) { + for (int j = 0; j < _output_channels; ++j) { + _gain[i][j] = 0; } } } -AudioMapping::AudioMapping (shared_ptr node) +AudioMapping::AudioMapping (cxml::ConstNodePtr node, int state_version) { - list > const c = node->node_children ("Map"); - for (list >::const_iterator i = c.begin(); i != c.end(); ++i) { - add ((*i)->number_child ("ContentIndex"), static_cast ((*i)->number_child ("DCP"))); + if (state_version < 32) { + setup (node->number_child ("ContentChannels"), MAX_DCP_AUDIO_CHANNELS); + } else { + setup (node->number_child ("InputChannels"), node->number_child ("OutputChannels")); + } + + if (state_version <= 5) { + /* Old-style: on/off mapping */ + list const c = node->node_children ("Map"); + for (list::const_iterator i = c.begin(); i != c.end(); ++i) { + set ((*i)->number_child ("ContentIndex"), static_cast ((*i)->number_child ("DCP")), 1); + } + } else { + list const c = node->node_children ("Gain"); + for (list::const_iterator i = c.begin(); i != c.end(); ++i) { + if (state_version < 32) { + set ( + (*i)->number_attribute ("Content"), + static_cast ((*i)->number_attribute ("DCP")), + raw_convert ((*i)->content ()) + ); + } else { + set ( + (*i)->number_attribute ("Input"), + (*i)->number_attribute ("Output"), + raw_convert ((*i)->content ()) + ); + } + } } } void -AudioMapping::add (int c, libdcp::Channel d) +AudioMapping::set (int input_channel, int output_channel, float g) { - _content_to_dcp.push_back (make_pair (c, d)); + _gain[input_channel][output_channel] = g; } -list -AudioMapping::dcp_to_content (libdcp::Channel d) const +float +AudioMapping::get (int input_channel, int output_channel) const +{ + DCPOMATIC_ASSERT (input_channel < int (_gain.size())); + DCPOMATIC_ASSERT (output_channel < int (_gain[0].size())); + return _gain[input_channel][output_channel]; +} + +void +AudioMapping::as_xml (xmlpp::Node* node) const { - list c; - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - if (i->second == d) { - c.push_back (i->first); + node->add_child ("InputChannels")->add_child_text (raw_convert (_input_channels)); + node->add_child ("OutputChannels")->add_child_text (raw_convert (_output_channels)); + + for (int c = 0; c < _input_channels; ++c) { + for (int d = 0; d < _output_channels; ++d) { + xmlpp::Element* t = node->add_child ("Gain"); + t->set_attribute ("Input", raw_convert (c)); + t->set_attribute ("Output", raw_convert (d)); + t->add_child_text (raw_convert (get (c, d))); } } - - return c; } -list -AudioMapping::content_channels () const +/** @return a string which is unique for a given AudioMapping configuration, for + * differentiation between different AudioMappings. + */ +string +AudioMapping::digest () const { - list c; - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - if (find (c.begin(), c.end(), i->first) == c.end ()) { - c.push_back (i->first); + Digester digester; + digester.add (_input_channels); + digester.add (_output_channels); + for (int i = 0; i < _input_channels; ++i) { + for (int j = 0; j < _output_channels; ++j) { + digester.add (_gain[i][j]); } } - return c; + return digester.get (); } -list -AudioMapping::content_to_dcp (int c) const +list +AudioMapping::mapped_output_channels () const { - list d; - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - if (i->first == c) { - d.push_back (i->second); + static float const minus_96_db = 0.000015849; + + list mapped; + + for (vector >::const_iterator i = _gain.begin(); i != _gain.end(); ++i) { + for (size_t j = 0; j < i->size(); ++j) { + if (abs ((*i)[j]) > minus_96_db) { + mapped.push_back (j); + } } } - return d; + mapped.sort (); + mapped.unique (); + + return mapped; } void -AudioMapping::as_xml (xmlpp::Node* node) const +AudioMapping::unmap_all () { - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - xmlpp::Node* t = node->add_child ("Map"); - t->add_child ("ContentIndex")->add_child_text (lexical_cast (i->first)); - t->add_child ("DCP")->add_child_text (lexical_cast (i->second)); + for (vector >::iterator i = _gain.begin(); i != _gain.end(); ++i) { + for (vector::iterator j = i->begin(); j != i->end(); ++j) { + *j = 0; + } } }