X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Faudio_analysis.cc;h=b16fa708ad85d74bad44d134b2302745b4d8602c;hp=9f92bdb503be802bcdee6aa400d0a1738b0defc3;hb=ac34066d5e448d1984d11a180be74e31b6e13b5c;hpb=0b6c6de07f9a3aa28c2e8ca8ef30340e3fa1bfc6 diff --git a/src/lib/audio_analysis.cc b/src/lib/audio_analysis.cc index 9f92bdb50..b16fa708a 100644 --- a/src/lib/audio_analysis.cc +++ b/src/lib/audio_analysis.cc @@ -1,162 +1,237 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-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 "audio_analysis.h" +#include "cross.h" +#include "util.h" +#include "playlist.h" +#include "audio_content.h" +#include "warnings.h" +#include +DCPOMATIC_DISABLE_WARNINGS +#include +DCPOMATIC_ENABLE_WARNINGS +#include #include #include -#include #include #include -#include -#include "audio_analysis.h" -#include "cross.h" +#include -using std::ostream; + +using std::cout; +using std::dynamic_pointer_cast; using std::istream; +using std::list; +using std::make_pair; +using std::make_shared; +using std::max; +using std::ostream; +using std::pair; +using std::shared_ptr; using std::string; 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 (FILE* f) -{ - for (int i = 0; i < COUNT; ++i) { - int n = fscanf (f, "%f", &_data[i]); - if (n != 1) { - _data[i] = 0; - } - } -} +using boost::optional; +using dcp::raw_convert; +using namespace dcpomatic; -AudioPoint::AudioPoint (AudioPoint const & other) -{ - for (int i = 0; i < COUNT; ++i) { - _data[i] = other._data[i]; - } -} -AudioPoint & -AudioPoint::operator= (AudioPoint const & other) -{ - if (this == &other) { - return *this; - } - - for (int i = 0; i < COUNT; ++i) { - _data[i] = other._data[i]; - } +int const AudioAnalysis::_current_state_version = 3; - return *this; -} - -void -AudioPoint::write (FILE* f) const -{ - for (int i = 0; i < COUNT; ++i) { - fprintf (f, "%f\n", _data[i]); - } -} - AudioAnalysis::AudioAnalysis (int channels) { _data.resize (channels); } + AudioAnalysis::AudioAnalysis (boost::filesystem::path filename) { - FILE* f = fopen_boost (filename, "r"); + cxml::Document f ("AudioAnalysis"); + f.read_file (filename); - int channels = 0; - fscanf (f, "%d", &channels); - _data.resize (channels); + if (f.optional_number_child("Version").get_value_or(1) < _current_state_version) { + /* Too old. Throw an exception so that this analysis is re-run. */ + throw OldFormatError ("Audio analysis file is too old"); + } - for (int i = 0; i < channels; ++i) { - int points; - fscanf (f, "%d", &points); - if (feof (f)) { - fclose (f); - return; - } - - for (int j = 0; j < points; ++j) { - _data[i].push_back (AudioPoint (f)); - if (feof (f)) { - fclose (f); - return; - } + for (auto i: f.node_children("Channel")) { + vector channel; + + for (auto j: i->node_children("Point")) { + channel.push_back (AudioPoint(j)); } + + _data.push_back (channel); + } + + for (auto i: f.node_children ("SamplePeak")) { + _sample_peak.push_back ( + PeakTime( + dcp::raw_convert(i->content()), DCPTime(i->number_attribute("Time")) + ) + ); } - fclose (f); + for (auto i: f.node_children("TruePeak")) { + _true_peak.push_back (dcp::raw_convert(i->content())); + } + + _integrated_loudness = f.optional_number_child("IntegratedLoudness"); + _loudness_range = f.optional_number_child("LoudnessRange"); + + _analysis_gain = f.optional_number_child("AnalysisGain"); + _samples_per_point = f.number_child("SamplesPerPoint"); + _sample_rate = f.number_child("SampleRate"); + + _leqm = f.optional_number_child("Leqm"); } + 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]; } + int AudioAnalysis::channels () const { return _data.size (); } + int AudioAnalysis::points (int c) const { - assert (c < channels ()); + DCPOMATIC_ASSERT (c < channels()); return _data[c].size (); } + void AudioAnalysis::write (boost::filesystem::path filename) { - boost::filesystem::path tmp = filename; - tmp.replace_extension (".tmp"); + auto doc = make_shared(); + xmlpp::Element* root = doc->create_root_node ("AudioAnalysis"); + + root->add_child("Version")->add_child_text(raw_convert(_current_state_version)); + + for (auto& i: _data) { + auto channel = root->add_child ("Channel"); + for (auto& j: i) { + j.as_xml (channel->add_child ("Point")); + } + } + + for (size_t i = 0; i < _sample_peak.size(); ++i) { + auto n = root->add_child("SamplePeak"); + n->add_child_text (raw_convert (_sample_peak[i].peak)); + n->set_attribute ("Time", raw_convert (_sample_peak[i].time.get())); + } + + for (auto i: _true_peak) { + root->add_child("TruePeak")->add_child_text (raw_convert (i)); + } + + 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 ())); + } + + root->add_child("SamplesPerPoint")->add_child_text (raw_convert (_samples_per_point)); + root->add_child("SampleRate")->add_child_text (raw_convert (_sample_rate)); + + if (_leqm) { + root->add_child("Leqm")->add_child_text(raw_convert(*_leqm)); + } + + doc->write_to_file_formatted (filename.string ()); +} + + +float +AudioAnalysis::gain_correction (shared_ptr playlist) +{ + 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.0f; +} - FILE* f = fopen_boost (tmp, "w"); - fprintf (f, "%ld\n", _data.size ()); - for (vector >::iterator i = _data.begin(); i != _data.end(); ++i) { - fprintf (f, "%ld\n", i->size ()); - for (vector::iterator j = i->begin(); j != i->end(); ++j) { - j->write (f); +/** @return Peak across all channels, and the channel number it is on */ +pair +AudioAnalysis::overall_sample_peak () const +{ + DCPOMATIC_ASSERT (!_sample_peak.empty()); + + optional pt; + int c = 0; + + for (size_t i = 0; i < _sample_peak.size(); ++i) { + if (!pt || _sample_peak[i].peak > pt->peak) { + pt = _sample_peak[i]; + c = i; } } - fclose (f); - boost::filesystem::rename (tmp, filename); + return make_pair (pt.get(), c); } + + +optional +AudioAnalysis::overall_true_peak () const +{ + optional p; + + for (auto i: _true_peak) { + if (!p || i > *p) { + p = i; + } + } + + return p; +} +