X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Faudio_mapping.cc;h=1db827046946a8008d54bff21597d4fd1d201bff;hb=9cacbd6bb24d04c1b4d2b1eae313687dda4fe63b;hp=b85ea731402046347a58738be6d5bb550df7fdd3;hpb=3cc96e5cc65456f4aeb4625f56087da33da47b48;p=dcpomatic.git diff --git a/src/lib/audio_mapping.cc b/src/lib/audio_mapping.cc index b85ea7314..74b33aa35 100644 --- a/src/lib/audio_mapping.cc +++ b/src/lib/audio_mapping.cc @@ -1,131 +1,290 @@ /* - Copyright (C) 2013 Carl Hetherington + Copyright (C) 2013-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + 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 "audio_mapping.h" +#include "audio_processor.h" +#include "constants.h" +#include "dcpomatic_assert.h" +#include "digester.h" +#include +#include +#include +LIBDCP_DISABLE_WARNINGS +#include +LIBDCP_ENABLE_WARNINGS +#include +#include + using std::list; using std::cout; using std::make_pair; using std::pair; using std::string; -using boost::shared_ptr; -using boost::lexical_cast; -using boost::dynamic_pointer_cast; +using std::min; +using std::vector; +using std::abs; +using std::shared_ptr; +using std::dynamic_pointer_cast; +using boost::optional; +using dcp::raw_convert; -void -AudioMapping::add (Channel c, libdcp::Channel d) + +/** Create an empty AudioMapping. + * @param input_channels Number of input channels. + * @param output_channels Number of output channels. + */ +AudioMapping::AudioMapping (int input_channels, int output_channels) { - _content_to_dcp.push_back (make_pair (c, d)); + setup (input_channels, output_channels); } -/* XXX: this is grotty */ -int -AudioMapping::dcp_channels () const + +void +AudioMapping::setup (int input_channels, int output_channels) { - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - if (((int) i->second) > 2) { - return 6; - } + _gain.resize(input_channels); + for (int i = 0; i < input_channels; ++i) { + _gain[i].resize(output_channels); } - return 2; + make_zero (); } -list -AudioMapping::dcp_to_content (libdcp::Channel d) const + +void +AudioMapping::make_zero () { - 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); + for (auto& input: _gain) { + for (auto& output: input) { + output = 0; } } - - return c; } -list -AudioMapping::content_channels () const + +struct ChannelRegex { - 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); + ChannelRegex (string regex_, int channel_) + : regex (regex_) + , channel (channel_) + {} + + string regex; + int channel; +}; + + +void +AudioMapping::make_default (AudioProcessor const * processor, optional filename) +{ + static ChannelRegex const regex[] = { + ChannelRegex(".*[\\._-]L[\\._-].*", 0), + ChannelRegex(".*[\\._-]R[\\._-].*", 1), + ChannelRegex(".*[\\._-]C[\\._-].*", 2), + ChannelRegex(".*[\\._-]Lfe[\\._-].*", 3), + ChannelRegex(".*[\\._-]LFE[\\._-].*", 3), + ChannelRegex(".*[\\._-]Lss[\\._-].*", 4), + ChannelRegex(".*[\\._-]Lsr[\\._-].*", 6), + ChannelRegex(".*[\\._-]Lrs[\\._-].*", 6), + ChannelRegex(".*[\\._-]Ls[\\._-].*", 4), + ChannelRegex(".*[\\._-]Rss[\\._-].*", 5), + ChannelRegex(".*[\\._-]Rsr[\\._-].*", 7), + ChannelRegex(".*[\\._-]Rrs[\\._-].*", 7), + ChannelRegex(".*[\\._-]Rs[\\._-].*", 5), + }; + + static int const regexes = sizeof(regex) / sizeof(*regex); + + if (processor) { + processor->make_audio_mapping_default (*this); + } else { + make_zero (); + if (input_channels() == 1) { + bool guessed = false; + + /* See if we can guess where this stream should go */ + if (filename) { + for (int i = 0; i < regexes; ++i) { + boost::regex e (regex[i].regex, boost::regex::icase); + if (boost::regex_match(filename->filename().string(), e) && regex[i].channel < output_channels()) { + set (0, regex[i].channel, 1); + guessed = true; + } + } + } + + if (!guessed) { + /* If we have no idea, just put it on centre */ + set (0, static_cast(dcp::Channel::CENTRE), 1); + } + } else { + /* 1:1 mapping */ + for (int i = 0; i < min (input_channels(), output_channels()); ++i) { + set (i, i, 1); + } } } - - return c; } -list -AudioMapping::content_to_dcp (Channel c) const + +AudioMapping::AudioMapping (cxml::ConstNodePtr node, int state_version) { - 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); + 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 */ + for (auto i: node->node_children ("Map")) { + set (i->number_child("ContentIndex"), i->number_child("DCP"), 1); + } + } else { + for (auto i: node->node_children("Gain")) { + if (state_version < 32) { + set ( + i->number_attribute("Content"), + i->number_attribute("DCP"), + raw_convert(i->content()) + ); + } else { + set ( + i->number_attribute("Input"), + i->number_attribute("Output"), + raw_convert(i->content()) + ); + } } } +} - return d; + +void +AudioMapping::set (dcp::Channel input_channel, int output_channel, float g) +{ + set (static_cast(input_channel), output_channel, g); } + void -AudioMapping::as_xml (xmlpp::Node* node) const +AudioMapping::set (int input_channel, dcp::Channel output_channel, float g) { - for (list >::const_iterator i = _content_to_dcp.begin(); i != _content_to_dcp.end(); ++i) { - xmlpp::Node* t = node->add_child ("Map"); - shared_ptr c = i->first.content.lock (); - t->add_child ("Content")->add_child_text (c->file().string ()); - t->add_child ("ContentIndex")->add_child_text (lexical_cast (i->first.index)); - t->add_child ("DCP")->add_child_text (lexical_cast (i->second)); - } + set (input_channel, static_cast(output_channel), g); } + void -AudioMapping::set_from_xml (ContentList const & content, shared_ptr node) +AudioMapping::set (int input_channel, int output_channel, float g) +{ + DCPOMATIC_ASSERT (input_channel < int(_gain.size())); + DCPOMATIC_ASSERT (output_channel < int(_gain[0].size())); + _gain[input_channel][output_channel] = g; +} + + +float +AudioMapping::get (int input_channel, dcp::Channel output_channel) const +{ + return get (input_channel, static_cast(output_channel)); +} + + +float +AudioMapping::get (int input_channel, int output_channel) const { - list > const c = node->node_children ("Map"); - for (list >::const_iterator i = c.begin(); i != c.end(); ++i) { - string const c = (*i)->string_child ("Content"); - ContentList::const_iterator j = content.begin (); - while (j != content.end() && (*j)->file().string() != c) { - ++j; + 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 +{ + auto const input = input_channels(); + auto const output = output_channels(); + + node->add_child("InputChannels")->add_child_text(raw_convert(input)); + node->add_child("OutputChannels")->add_child_text(raw_convert(output)); + + for (int c = 0; c < input; ++c) { + for (int d = 0; d < output; ++d) { + auto 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))); } + } +} + - if (j == content.end ()) { - continue; +/** @return a string which is unique for a given AudioMapping configuration, for + * differentiation between different AudioMappings. + */ +string +AudioMapping::digest () const +{ + Digester digester; + digester.add(input_channels()); + digester.add(output_channels()); + for (auto const& input: _gain) { + for (auto output: input) { + digester.add(output); } + } - shared_ptr ac = dynamic_pointer_cast (*j); - assert (ac); + return digester.get (); +} + + +list +AudioMapping::mapped_output_channels () const +{ + static float const minus_96_db = 0.000015849; - add (AudioMapping::Channel (ac, (*i)->number_child ("ContentIndex")), static_cast ((*i)->number_child ("DCP"))); + list mapped; + + for (auto const& i: _gain) { + for (auto j: dcp::used_audio_channels()) { + if (abs(i[static_cast(j)]) > minus_96_db) { + mapped.push_back (static_cast(j)); + } + } } + + mapped.sort (); + mapped.unique (); + + return mapped; } -bool -operator== (AudioMapping::Channel const & a, AudioMapping::Channel const & b) + +void +AudioMapping::unmap_all () { - shared_ptr sa = a.content.lock (); - shared_ptr sb = b.content.lock (); - return sa == sb && a.index == b.index; + for (auto& i: _gain) { + for (auto& j: i) { + j = 0; + } + } }