X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Faudio_buffers.cc;h=3692c304e148863a3dbc02a9f2805bb901c43648;hp=56ca7a94b18c5860e3800f03740baa2c09480d59;hb=HEAD;hpb=39029279954b1f346d3ba28ec12c58211bfa7436 diff --git a/src/lib/audio_buffers.cc b/src/lib/audio_buffers.cc index 56ca7a94b..9b88827f7 100644 --- a/src/lib/audio_buffers.cc +++ b/src/lib/audio_buffers.cc @@ -1,171 +1,167 @@ /* - Copyright (C) 2012-2013 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_buffers.h" +#include "dcpomatic_assert.h" +#include "maths_util.h" +#include #include #include #include -#include -#include "audio_buffers.h" -using std::bad_alloc; -using boost::shared_ptr; -/** Construct an AudioBuffers. Audio data is undefined after this constructor. - * @param channels Number of channels. - * @param frames Number of frames to reserve space for. - */ +using std::shared_ptr; +using std::make_shared; + + +/** Construct a silent AudioBuffers */ AudioBuffers::AudioBuffers (int channels, int frames) { allocate (channels, frames); } + /** Copy constructor. * @param other Other AudioBuffers; data is copied. */ AudioBuffers::AudioBuffers (AudioBuffers const & other) { - allocate (other._channels, other._frames); - copy_from (&other, other._frames, 0, 0); + allocate (other.channels(), other.frames()); + copy_from (&other, other.frames(), 0, 0); } -AudioBuffers::AudioBuffers (boost::shared_ptr other) + +AudioBuffers::AudioBuffers (std::shared_ptr other) { - allocate (other->_channels, other->_frames); - copy_from (other.get(), other->_frames, 0, 0); + allocate (other->channels(), other->frames()); + copy_from (other.get(), other->frames(), 0, 0); } + +AudioBuffers::AudioBuffers (std::shared_ptr other, int frames_to_copy, int read_offset) +{ + allocate (other->channels(), frames_to_copy); + copy_from (other.get(), frames_to_copy, read_offset, 0); +} + + AudioBuffers & AudioBuffers::operator= (AudioBuffers const & other) { if (this == &other) { return *this; } - - deallocate (); - allocate (other._channels, other._frames); - copy_from (&other, other._frames, 0, 0); + + allocate (other.channels(), other.frames()); + copy_from (&other, other.frames(), 0, 0); return *this; } -/** AudioBuffers destructor */ -AudioBuffers::~AudioBuffers () -{ - deallocate (); -} void AudioBuffers::allocate (int channels, int frames) { - assert (frames >= 0); - assert (channels >= 0); - - _channels = channels; - _frames = frames; - _allocated_frames = frames; - - _data = static_cast (malloc (_channels * sizeof (float *))); - if (!_data) { - throw bad_alloc (); - } - - for (int i = 0; i < _channels; ++i) { - _data[i] = static_cast (malloc (frames * sizeof (float))); - if (!_data[i]) { - throw bad_alloc (); - } - } -} + DCPOMATIC_ASSERT (frames >= 0); + DCPOMATIC_ASSERT(frames == 0 || channels > 0); -void -AudioBuffers::deallocate () -{ - for (int i = 0; i < _channels; ++i) { - free (_data[i]); - } + dcp::ScopeGuard sg = [this]() { update_data_pointers(); }; - free (_data); + _data.resize(channels); + for (int channel = 0; channel < channels; ++channel) { + _data[channel].resize(frames); + } } -/** @param c Channel index. + +/** @param channel Channel index. * @return Buffer for this channel. */ float* -AudioBuffers::data (int c) const +AudioBuffers::data (int channel) { - assert (c >= 0 && c < _channels); - return _data[c]; + DCPOMATIC_ASSERT (channel >= 0 && channel < channels()); + return _data[channel].data(); } -/** Set the number of frames that these AudioBuffers will report themselves - * as having. If we reduce the number of frames, the `lost' frames will - * be silenced. - * @param f Frames; must be less than or equal to the number of allocated frames. + +/** @param channel Channel index. + * @return Buffer for this channel. */ -void -AudioBuffers::set_frames (int f) +float const* +AudioBuffers::data (int channel) const { - assert (f <= _allocated_frames); + DCPOMATIC_ASSERT (channel >= 0 && channel < channels()); + return _data[channel].data(); +} - for (int c = 0; c < _channels; ++c) { - for (int i = f; i < _frames; ++i) { - _data[c][i] = 0; - } - } - - _frames = f; + +/** Set the number of frames in these AudioBuffers */ +void +AudioBuffers::set_frames (int frames) +{ + allocate(_data.size(), frames); } -/** Make all samples on all channels silent */ + +/** Make all frames silent */ void AudioBuffers::make_silent () { - for (int i = 0; i < _channels; ++i) { - make_silent (i); + for (int channel = 0; channel < channels(); ++channel) { + make_silent (channel); } } -/** Make all samples on a given channel silent. - * @param c Channel. - */ + +/** Make all samples on a given channel silent */ void -AudioBuffers::make_silent (int c) +AudioBuffers::make_silent (int channel) { - assert (c >= 0 && c < _channels); - - for (int i = 0; i < _frames; ++i) { - _data[c][i] = 0; - } + DCPOMATIC_ASSERT (channel >= 0 && channel < channels()); + + /* This isn't really allowed, as all-bits-0 is not guaranteed to mean a 0 float, + but it seems that we can get away with it. + */ + memset (data(channel), 0, frames() * sizeof(float)); } + +/** Make some frames silent. + * @param from Start frame. + */ void -AudioBuffers::make_silent (int from, int frames) +AudioBuffers::make_silent (int from, int frames_to_silence) { - assert ((from + frames) <= _allocated_frames); + DCPOMATIC_ASSERT ((from + frames_to_silence) <= frames()); - for (int c = 0; c < _channels; ++c) { - for (int i = from; i < (from + frames); ++i) { - _data[c][i] = 0; - } + for (int channel = 0; channel < channels(); ++channel) { + /* This isn't really allowed, as all-bits-0 is not guaranteed to mean a 0 float, + but it seems that we can get away with it. + */ + memset (data(channel) + from, 0, frames_to_silence * sizeof(float)); } } + /** Copy data from another AudioBuffers to this one. All channels are copied. * @param from AudioBuffers to copy from; must have the same number of channels as this. * @param frames_to_copy Number of frames to copy. @@ -179,135 +175,182 @@ AudioBuffers::copy_from (AudioBuffers const * from, int frames_to_copy, int read /* Prevent the asserts from firing if there is nothing to do */ return; } - - assert (from->channels() == channels()); - assert (from); - assert (read_offset >= 0 && (read_offset + frames_to_copy) <= from->_allocated_frames); - assert (write_offset >= 0 && (write_offset + frames_to_copy) <= _allocated_frames); + DCPOMATIC_ASSERT (from); + DCPOMATIC_ASSERT (from->channels() == channels()); + DCPOMATIC_ASSERT (read_offset >= 0 && (read_offset + frames_to_copy) <= from->frames()); + DCPOMATIC_ASSERT (write_offset >= 0 && (write_offset + frames_to_copy) <= frames()); - for (int i = 0; i < _channels; ++i) { - memcpy (_data[i] + write_offset, from->_data[i] + read_offset, frames_to_copy * sizeof(float)); + for (int channel = 0; channel < channels(); ++channel) { + memcpy (data(channel) + write_offset, from->data(channel) + read_offset, frames_to_copy * sizeof(float)); } } + /** Move audio data around. + * @param frames_to_move Number of frames to move. * @param from Offset to move from. * @param to Offset to move to. - * @param frames Number of frames to move. */ - void -AudioBuffers::move (int from, int to, int frames) +AudioBuffers::move (int frames_to_move, int from, int to) { - if (frames == 0) { + if (frames_to_move == 0) { return; } - - assert (from >= 0); - assert (from < _frames); - assert (to >= 0); - assert (to < _frames); - assert (frames > 0); - assert (frames <= _frames); - assert ((from + frames) <= _frames); - assert ((to + frames) <= _allocated_frames); - - for (int i = 0; i < _channels; ++i) { - memmove (_data[i] + to, _data[i] + from, frames * sizeof(float)); + + DCPOMATIC_ASSERT (from >= 0); + DCPOMATIC_ASSERT (from < frames()); + DCPOMATIC_ASSERT (to >= 0); + DCPOMATIC_ASSERT (to < frames()); + DCPOMATIC_ASSERT (frames_to_move > 0); + DCPOMATIC_ASSERT (frames_to_move <= frames()); + DCPOMATIC_ASSERT ((from + frames_to_move) <= frames()); + DCPOMATIC_ASSERT ((to + frames_to_move) <= frames()); + + for (int channel = 0; channel < channels(); ++channel) { + memmove (data(channel) + to, data(channel) + from, frames_to_move * sizeof(float)); } } + /** Add data from from `from', `from_channel' to our channel `to_channel'. + * @param from Buffers to copy data from. + * @param from_channel Channel index to read in \p from. + * @param to_channel Channel index to accumulate into. * @param gain Linear gain to apply to the data before it is added. */ void AudioBuffers::accumulate_channel (AudioBuffers const * from, int from_channel, int to_channel, float gain) { int const N = frames (); - assert (from->frames() == N); - assert (to_channel <= _channels); + DCPOMATIC_ASSERT (from->frames() == N); + DCPOMATIC_ASSERT (to_channel <= channels()); - float* s = from->data (from_channel); - float* d = _data[to_channel]; + auto s = from->data (from_channel); + auto d = data(to_channel); for (int i = 0; i < N; ++i) { *d++ += (*s++) * gain; } } -/** Ensure we have space for at least a certain number of frames. If we extend - * the buffers, fill the new space with silence. - */ -void -AudioBuffers::ensure_size (int frames) -{ - if (_allocated_frames >= frames) { - return; - } - - for (int i = 0; i < _channels; ++i) { - _data[i] = static_cast (realloc (_data[i], frames * sizeof (float))); - if (!_data[i]) { - throw bad_alloc (); - } - for (int j = _allocated_frames; j < frames; ++j) { - _data[i][j] = 0; - } - } - - _allocated_frames = frames; -} +/** Mix some other buffers with these ones. The AudioBuffers must have the same number of channels. + * @param from Audio buffers to get data from. + * @param frames Number of frames to mix. + * @param read_offset Offset within `from' to read from. + * @param write_offset Offset within this to mix into. + */ void -AudioBuffers::accumulate_frames (AudioBuffers const * from, int read_offset, int write_offset, int frames) +AudioBuffers::accumulate_frames (AudioBuffers const * from, int frames, int read_offset, int write_offset) { - assert (_channels == from->channels ()); - assert (read_offset >= 0); - assert (write_offset >= 0); + DCPOMATIC_ASSERT (channels() == from->channels()); + DCPOMATIC_ASSERT (read_offset >= 0); + DCPOMATIC_ASSERT (write_offset >= 0); - for (int i = 0; i < _channels; ++i) { + auto from_data = from->data (); + for (int i = 0; i < channels(); ++i) { for (int j = 0; j < frames; ++j) { - _data[i][j + write_offset] += from->data()[i][j + read_offset]; + _data[i][j + write_offset] += from_data[i][j + read_offset]; } } } + /** @param dB gain in dB */ void AudioBuffers::apply_gain (float dB) { - float const linear = pow (10, dB / 20); - - for (int i = 0; i < _channels; ++i) { - for (int j = 0; j < _frames; ++j) { + auto const linear = db_to_linear (dB); + + for (int i = 0; i < channels(); ++i) { + for (int j = 0; j < frames(); ++j) { _data[i][j] *= linear; } } } -/** @param c Channel index. - * @return AudioBuffers object containing only channel `c' from this AudioBuffers. - */ + +/** @return AudioBuffers object containing only the given channel from this AudioBuffers */ shared_ptr -AudioBuffers::channel (int c) const +AudioBuffers::channel (int channel) const { - shared_ptr o (new AudioBuffers (1, frames ())); - o->copy_channel_from (this, c, 0); - return o; + auto output = make_shared(1, frames()); + output->copy_channel_from (this, channel, 0); + return output; } + +/** Copy all the samples from a channel on another AudioBuffers to a channel on this one. + * @param from AudioBuffers to copy from. + * @param from_channel Channel index in `from' to copy from. + * @param to_channel Channel index in this to copy into, overwriting what's already there. + */ void AudioBuffers::copy_channel_from (AudioBuffers const * from, int from_channel, int to_channel) { - assert (from->frames() == frames()); + DCPOMATIC_ASSERT (from->frames() == frames()); memcpy (data(to_channel), from->data(from_channel), frames() * sizeof (float)); } + +/** Make a copy of these AudioBuffers */ shared_ptr AudioBuffers::clone () const { - shared_ptr b (new AudioBuffers (channels (), frames ())); - b->copy_from (this, frames (), 0, 0); + auto b = make_shared(channels(), frames()); + b->copy_from (this, frames(), 0, 0); return b; } + + +/** Extend these buffers with the data from another. The AudioBuffers must have the same number of channels. */ +void +AudioBuffers::append (shared_ptr other) +{ + DCPOMATIC_ASSERT (channels() == other->channels()); + auto old_frames = frames(); + set_frames(old_frames + other->frames()); + copy_from (other.get(), other->frames(), 0, old_frames); +} + + +/** Remove some frames from the start of these AudioBuffers */ +void +AudioBuffers::trim_start (int frames_to_trim) +{ + DCPOMATIC_ASSERT (frames_to_trim <= frames()); + move (frames() - frames_to_trim, frames_to_trim, 0); + set_frames (frames() - frames_to_trim); +} + + +void +AudioBuffers::update_data_pointers () +{ + _data_pointers.resize (channels()); + for (int i = 0; i < channels(); ++i) { + _data_pointers[i] = _data[i].data(); + } +} + + +/** Set a new channel count, either discarding data (if new_channels is less than the current + * channels()), or filling with silence (if new_channels is more than the current channels() + */ +void +AudioBuffers::set_channels(int new_channels) +{ + DCPOMATIC_ASSERT(new_channels > 0); + + dcp::ScopeGuard sg = [this]() { update_data_pointers(); }; + + int const old_channels = channels(); + _data.resize(new_channels); + + for (int channel = old_channels; channel < new_channels; ++channel) { + _data[channel].resize(frames()); + } +} +