X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Faudio_analysis.cc;h=1863e38eeae85bf633c79151dc335fd4e3d9be09;hp=0cf08c5bdf1b42078f571b0b6105a99572d7e66c;hb=3828baf56467224f5d44049bf1e7a7ed11f43a05;hpb=51b4acfbaf0e2cd8b87bb675e023d9e940febc89 diff --git a/src/lib/audio_analysis.cc b/src/lib/audio_analysis.cc index 0cf08c5bd..1863e38ee 100644 --- a/src/lib/audio_analysis.cc +++ b/src/lib/audio_analysis.cc @@ -1,95 +1,98 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2015 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 "audio_analysis.h" +#include "cross.h" +#include "util.h" +#include "raw_convert.h" +#include "playlist.h" +#include "audio_content.h" +#include +#include +#include #include #include -#include -#include -#include -#include "audio_analysis.h" +#include +#include +#include using std::ostream; using std::istream; using std::string; -using std::ofstream; -using std::ifstream; using std::vector; using std::cout; using std::max; using std::list; - -AudioPoint::AudioPoint () -{ - for (int i = 0; i < COUNT; ++i) { - _data[i] = 0; - } -} - -AudioPoint::AudioPoint (istream& s) -{ - for (int i = 0; i < COUNT; ++i) { - s >> _data[i]; - } -} - -void -AudioPoint::write (ostream& s) const -{ - for (int i = 0; i < COUNT; ++i) { - s << _data[i] << "\n"; - } -} - +using boost::shared_ptr; +using boost::dynamic_pointer_cast; AudioAnalysis::AudioAnalysis (int channels) { _data.resize (channels); } -AudioAnalysis::AudioAnalysis (string filename) +AudioAnalysis::AudioAnalysis (boost::filesystem::path filename) { - ifstream f (filename.c_str ()); + cxml::Document f ("AudioAnalysis"); + f.read_file (filename); - int channels; - f >> channels; - _data.resize (channels); + BOOST_FOREACH (cxml::NodePtr i, f.node_children ("Channel")) { + vector channel; - for (int i = 0; i < channels; ++i) { - int points; - f >> points; - for (int j = 0; j < points; ++j) { - _data[i].push_back (AudioPoint (f)); + BOOST_FOREACH (cxml::NodePtr j, i->node_children ("Point")) { + channel.push_back (AudioPoint (j)); } + + _data.push_back (channel); } + + _sample_peak = f.optional_number_child ("Peak"); + if (!_sample_peak) { + /* New key */ + _sample_peak = f.optional_number_child ("SamplePeak"); + } + + if (f.optional_number_child ("PeakTime")) { + _sample_peak_time = DCPTime (f.number_child ("PeakTime")); + } else if (f.optional_number_child ("SamplePeakTime")) { + _sample_peak_time = DCPTime (f.number_child ("SamplePeakTime")); + } + + _true_peak = f.optional_number_child ("TruePeak"); + _integrated_loudness = f.optional_number_child ("IntegratedLoudness"); + _loudness_range = f.optional_number_child ("LoudnessRange"); + + _analysis_gain = f.optional_number_child ("AnalysisGain"); } void AudioAnalysis::add_point (int c, AudioPoint const & p) { - assert (c < channels ()); + DCPOMATIC_ASSERT (c < channels ()); _data[c].push_back (p); } AudioPoint AudioAnalysis::get_point (int c, int p) const { - assert (p < points (c)); + DCPOMATIC_ASSERT (p < points (c)); return _data[c][p]; } @@ -102,50 +105,58 @@ AudioAnalysis::channels () const int AudioAnalysis::points (int c) const { - assert (c < channels ()); + DCPOMATIC_ASSERT (c < channels ()); return _data[c].size (); } void -AudioAnalysis::write (string filename) +AudioAnalysis::write (boost::filesystem::path filename) { - string tmp = filename + ".tmp"; - - ofstream f (tmp.c_str ()); - f << _data.size() << "\n"; - for (vector >::iterator i = _data.begin(); i != _data.end(); ++i) { - f << i->size () << "\n"; - for (vector::iterator j = i->begin(); j != i->end(); ++j) { - j->write (f); + shared_ptr doc (new xmlpp::Document); + xmlpp::Element* root = doc->create_root_node ("AudioAnalysis"); + + BOOST_FOREACH (vector& i, _data) { + xmlpp::Element* channel = root->add_child ("Channel"); + BOOST_FOREACH (AudioPoint& j, i) { + j.as_xml (channel->add_child ("Point")); } } - f.close (); - boost::filesystem::rename (tmp, filename); + if (_sample_peak) { + root->add_child("SamplePeak")->add_child_text (raw_convert (_sample_peak.get ())); + root->add_child("SamplePeakTime")->add_child_text (raw_convert (_sample_peak_time.get().get ())); + } + + if (_true_peak) { + root->add_child("TruePeak")->add_child_text (raw_convert (_true_peak.get ())); + } + + if (_integrated_loudness) { + root->add_child("IntegratedLoudness")->add_child_text (raw_convert (_integrated_loudness.get ())); + } + + if (_loudness_range) { + root->add_child("LoudnessRange")->add_child_text (raw_convert (_loudness_range.get ())); + } + + if (_analysis_gain) { + root->add_child("AnalysisGain")->add_child_text (raw_convert (_analysis_gain.get ())); + } + + doc->write_to_file_formatted (filename.string ()); } float -AudioAnalysis::smooth (list const & data, AudioPoint::Type t) +AudioAnalysis::gain_correction (shared_ptr playlist) { - float val; - - switch (t) { - case AudioPoint::PEAK: - /* XXX: fall-off, or something...? */ - val = -200; - for (list::const_iterator i = data.begin(); i != data.end(); ++i) { - val = max (val, *i); - } - return val; - case AudioPoint::RMS: - val = 0; - for (list::const_iterator i = data.begin(); i != data.end(); ++i) { - val += pow (*i, 2); - } - return sqrt (val / data.size()); - default: - assert (false); + if (playlist->content().size() == 1 && analysis_gain ()) { + /* In this case we know that the analysis was of a single piece of content and + we know that content's gain when the analysis was run. Hence we can work out + what correction is now needed to make it look `right'. + */ + DCPOMATIC_ASSERT (playlist->content().front()->audio); + return playlist->content().front()->audio->gain() - analysis_gain().get (); } - return 0; + return 0.0f; }