From 0dfd150ac546eb42067cb51b6d4386fadc24afab Mon Sep 17 00:00:00 2001 From: Carl Hetherington Date: Fri, 18 Sep 2015 22:33:20 +0100 Subject: [PATCH] Add UpmixerB. --- ChangeLog | 6 ++ src/lib/audio_delay.cc | 86 ++++++++++++++++++ src/lib/audio_delay.h | 34 +++++++ src/lib/audio_processor.cc | 2 + src/lib/upmixer_b.cc | 139 +++++++++++++++++++++++++++++ src/lib/upmixer_b.h | 45 ++++++++++ src/lib/wscript | 2 + test/audio_processor_delay_test.cc | 125 ++++++++++++++++++++++++++ test/wscript | 1 + 9 files changed, 440 insertions(+) create mode 100644 src/lib/audio_delay.cc create mode 100644 src/lib/audio_delay.h create mode 100644 src/lib/upmixer_b.cc create mode 100644 src/lib/upmixer_b.h create mode 100644 test/audio_processor_delay_test.cc diff --git a/ChangeLog b/ChangeLog index a0856e8e2..37ac15d07 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2015-09-18 Carl Hetherington + + * Add another upmixer which is a simpler + matrix-type thing with no filtering + (apart from Lfe). + 2015-09-17 Carl Hetherington * Version 2.3.4 released. diff --git a/src/lib/audio_delay.cc b/src/lib/audio_delay.cc new file mode 100644 index 000000000..076d10d6f --- /dev/null +++ b/src/lib/audio_delay.cc @@ -0,0 +1,86 @@ +/* + Copyright (C) 2015 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 + 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, + 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. + +*/ + +#include "audio_delay.h" +#include "audio_buffers.h" +#include "dcpomatic_assert.h" +#include + +using std::cout; +using boost::shared_ptr; + +AudioDelay::AudioDelay (int samples) + : _samples (samples) +{ + +} + +shared_ptr +AudioDelay::run (shared_ptr in) +{ + /* You can't call this with varying channel counts */ + DCPOMATIC_ASSERT (!_tail || in->channels() == _tail->channels()); + + shared_ptr out (new AudioBuffers (in->channels(), in->frames())); + + if (in->frames() > _samples) { + + if (!_tail) { + /* No tail; use silence */ + out->make_silent (0, _samples); + } else { + /* Copy tail */ + out->copy_from (_tail.get(), _samples, 0, 0); + } + + /* Copy in to out */ + out->copy_from (in.get(), in->frames() - _samples, 0, _samples); + + /* Keep tail */ + if (!_tail) { + _tail.reset (new AudioBuffers (in->channels(), _samples)); + } + _tail->copy_from (in.get(), _samples, in->frames() - _samples, 0); + + } else { + + /* First part of the tail into the output */ + if (_tail) { + out->copy_from (_tail.get(), out->frames(), 0, 0); + } else { + out->make_silent (); + _tail.reset (new AudioBuffers (out->channels(), _samples)); + _tail->make_silent (); + } + + /* Shuffle the tail down */ + _tail->move (out->frames(), 0, _tail->frames() - out->frames()); + + /* Copy input into the tail */ + _tail->copy_from (in.get(), in->frames(), 0, _tail->frames() - in->frames()); + } + + return out; +} + +void +AudioDelay::flush () +{ + _tail.reset (); +} diff --git a/src/lib/audio_delay.h b/src/lib/audio_delay.h new file mode 100644 index 000000000..0072915e2 --- /dev/null +++ b/src/lib/audio_delay.h @@ -0,0 +1,34 @@ +/* + Copyright (C) 2015 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 + 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, + 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. + +*/ + +#include + +class AudioBuffers; + +class AudioDelay +{ +public: + AudioDelay (int samples); + boost::shared_ptr run (boost::shared_ptr in); + void flush (); + +private: + boost::shared_ptr _tail; + int _samples; +}; diff --git a/src/lib/audio_processor.cc b/src/lib/audio_processor.cc index f350cc2aa..1e8e3e4c6 100644 --- a/src/lib/audio_processor.cc +++ b/src/lib/audio_processor.cc @@ -20,6 +20,7 @@ #include "audio_processor.h" #include "mid_side_decoder.h" #include "upmixer_a.h" +#include "upmixer_b.h" using std::string; using std::list; @@ -31,6 +32,7 @@ AudioProcessor::setup_audio_processors () { _all.push_back (new MidSideDecoder ()); _all.push_back (new UpmixerA (48000)); + _all.push_back (new UpmixerB (48000)); } AudioProcessor const * diff --git a/src/lib/upmixer_b.cc b/src/lib/upmixer_b.cc new file mode 100644 index 000000000..9340582c3 --- /dev/null +++ b/src/lib/upmixer_b.cc @@ -0,0 +1,139 @@ +/* + Copyright (C) 2015 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 + 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, + 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. + +*/ + +#include "upmixer_b.h" +#include "audio_buffers.h" +#include "audio_mapping.h" + +#include "i18n.h" + +using std::string; +using std::min; +using std::vector; +using boost::shared_ptr; + +UpmixerB::UpmixerB (int sampling_rate) + : _lfe (0.02, 20.0 / sampling_rate, 150.0 / sampling_rate) + , _delay (0.02 * sampling_rate) +{ + +} + +string +UpmixerB::name () const +{ + return _("Stereo to 5.1 up-mixer B"); +} + + +string +UpmixerB::id () const +{ + return N_("stereo-5.1-upmix-b"); +} + +int +UpmixerB::out_channels () const +{ + return 6; +} + +shared_ptr +UpmixerB::clone (int sampling_rate) const +{ + return shared_ptr (new UpmixerB (sampling_rate)); +} + +shared_ptr +UpmixerB::run (shared_ptr in, int channels) +{ + shared_ptr out (new AudioBuffers (channels, in->frames())); + + /* L + R minus 6dB (in terms of amplitude) */ + shared_ptr in_LR = in->channel(0); + in_LR->accumulate_frames (in->channel(1).get(), 0, 0, in->frames()); + in_LR->apply_gain (-6); + + if (channels > 0) { + /* L = Lt */ + out->copy_channel_from (in.get(), 0, 0); + } + + if (channels > 1) { + /* R = Rt */ + out->copy_channel_from (in.get(), 1, 1); + } + + if (channels > 2) { + /* C = L + R minus 3dB */ + out->copy_channel_from (in_LR.get(), 0, 2); + } + + if (channels > 3) { + /* Lfe is filtered C */ + out->copy_channel_from (_lfe.run(in_LR).get(), 0, 3); + } + + shared_ptr S; + if (channels > 4) { + /* Ls is L - R with some delay */ + shared_ptr sub (new AudioBuffers (1, in->frames())); + sub->copy_channel_from (in.get(), 0, 0); + float* p = sub->data (0); + float const * q = in->data (1); + for (int i = 0; i < in->frames(); ++i) { + *p++ -= *q++; + } + S = _delay.run (sub); + out->copy_channel_from (S.get(), 0, 4); + } + + if (channels > 5) { + /* Rs = Ls */ + out->copy_channel_from (S.get(), 0, 5); + } + + return out; +} + +void +UpmixerB::flush () +{ + _lfe.flush (); + _delay.flush (); +} + +void +UpmixerB::make_audio_mapping_default (AudioMapping& mapping) const +{ + /* Just map the first two input channels to our L/R */ + mapping.make_zero (); + for (int i = 0; i < min (2, mapping.input_channels()); ++i) { + mapping.set (i, i, 1); + } +} + +vector +UpmixerB::input_names () const +{ + vector n; + n.push_back (_("Upmix L")); + n.push_back (_("Upmix R")); + return n; +} diff --git a/src/lib/upmixer_b.h b/src/lib/upmixer_b.h new file mode 100644 index 000000000..f128e1d0e --- /dev/null +++ b/src/lib/upmixer_b.h @@ -0,0 +1,45 @@ +/* + Copyright (C) 2015 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 + 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, + 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. + +*/ + +/** @file src/lib/upmixer_b.h + * @brief UpmixerB class. + */ + +#include "audio_processor.h" +#include "audio_filter.h" +#include "audio_delay.h" + +class UpmixerB : public AudioProcessor +{ +public: + UpmixerB (int sampling_rate); + + std::string name () const; + std::string id () const; + int out_channels () const; + boost::shared_ptr clone (int) const; + boost::shared_ptr run (boost::shared_ptr, int channels); + void flush (); + void make_audio_mapping_default (AudioMapping& mapping) const; + std::vector input_names () const; + +private: + BandPassAudioFilter _lfe; + AudioDelay _delay; +}; diff --git a/src/lib/wscript b/src/lib/wscript index f0646910b..a95905578 100644 --- a/src/lib/wscript +++ b/src/lib/wscript @@ -26,6 +26,7 @@ sources = """ audio_content.cc audio_decoder.cc audio_decoder_stream.cc + audio_delay.cc audio_filter.cc audio_mapping.cc audio_point.cc @@ -122,6 +123,7 @@ sources = """ upload_job.cc uploader.cc upmixer_a.cc + upmixer_b.cc util.cc video_content.cc video_content_scale.cc diff --git a/test/audio_processor_delay_test.cc b/test/audio_processor_delay_test.cc new file mode 100644 index 000000000..b3948a71b --- /dev/null +++ b/test/audio_processor_delay_test.cc @@ -0,0 +1,125 @@ +/* + Copyright (C) 2015 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 + 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, + 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. + +*/ + +#include "lib/audio_delay.h" +#include "lib/audio_buffers.h" +#include +#include + +using std::cerr; +using std::cout; +using boost::shared_ptr; + +#define CHECK_SAMPLE(c,f,r) \ + if (fabs(out->data(c)[f] - (r)) > 0.1) { \ + cerr << "Sample " << f << " at line " << __LINE__ << " is " << out->data(c)[f] << " not " << r << "; difference is " << fabs(out->data(c)[f] - (r)) << "\n"; \ + BOOST_REQUIRE (fabs(out->data(c)[f] - (r)) <= 0.1); \ + } + +/** Block size greater than delay */ +BOOST_AUTO_TEST_CASE (audio_processor_delay_test1) +{ + AudioDelay delay (64); + + int const C = 2; + + shared_ptr in (new AudioBuffers (C, 256)); + for (int i = 0; i < C; ++i) { + for (int j = 0; j < 256; ++j) { + in->data(i)[j] = j; + } + } + + shared_ptr out = delay.run (in); + BOOST_REQUIRE_EQUAL (out->frames(), in->frames()); + + /* Silence at the start */ + for (int i = 0; i < C; ++i) { + for (int j = 0; j < 64; ++j) { + CHECK_SAMPLE (i, j, 0); + } + } + + /* Then the delayed data */ + for (int i = 0; i < C; ++i) { + for (int j = 64; j < 256; ++j) { + CHECK_SAMPLE (i, j, j - 64); + } + } + + /* Feed some more in */ + for (int i = 0; i < C; ++i) { + for (int j = 0; j < 256; ++j) { + in->data(i)[j] = j + 256; + } + } + out = delay.run (in); + + /* Check again */ + for (int i = 0; i < C; ++i) { + for (int j = 256; j < 512; ++j) { + CHECK_SAMPLE (i, j - 256, j - 64); + } + } +} + +/** Block size less than delay */ +BOOST_AUTO_TEST_CASE (audio_processor_delay_test2) +{ + AudioDelay delay (256); + + int const C = 2; + + /* Feeding 4 blocks of 64 should give silence each time */ + + for (int i = 0; i < 4; ++i) { + cout << "i=" << i << "\n"; + shared_ptr in (new AudioBuffers (C, 64)); + for (int j = 0; j < C; ++j) { + for (int k = 0; k < 64; ++k) { + in->data(j)[k] = k + i * 64; + } + } + + shared_ptr out = delay.run (in); + BOOST_REQUIRE_EQUAL (out->frames(), in->frames()); + + /* Check for silence */ + for (int j = 0; j < C; ++j) { + for (int k = 0; k < 64; ++k) { + CHECK_SAMPLE (j, k, 0); + } + } + } + + /* Now feed 4 blocks of silence and we should see the data */ + for (int i = 0; i < 4; ++i) { + /* Feed some silence */ + shared_ptr in (new AudioBuffers (C, 64)); + in->make_silent (); + shared_ptr out = delay.run (in); + + /* Should now see the delayed data */ + for (int j = 0; j < C; ++j) { + for (int k = 0; k < 64; ++k) { + CHECK_SAMPLE (j, k, k + i * 64); + } + } + } +} diff --git a/test/wscript b/test/wscript index 8707c1562..1a1038e8d 100644 --- a/test/wscript +++ b/test/wscript @@ -44,6 +44,7 @@ def build(bld): audio_filter_test.cc audio_mapping_test.cc audio_processor_test.cc + audio_processor_delay_test.cc black_fill_test.cc client_server_test.cc colour_conversion_test.cc -- 2.30.2