src/lib/audio_buffers.cc

   1 /*
   2     Copyright (C) 2012-2013 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include <cassert>
  21 #include <cstring>
  22 #include <stdexcept>
  23 #include "audio_buffers.h"
  24
  25 using std::bad_alloc;
  26 using boost::shared_ptr;
  27
  28 /** Construct an AudioBuffers.  Audio data is undefined after this constructor.
  29  *  @param channels Number of channels.
  30  *  @param frames Number of frames to reserve space for.
  31  */
  32 AudioBuffers::AudioBuffers (int channels, int frames)
  33         : _channels (channels)
  34         , _frames (frames)
  35         , _allocated_frames (frames)
  36 {
  37         _data = static_cast<float**> (malloc (_channels * sizeof (float *)));
  38         if (!_data) {
  39                 throw bad_alloc ();
  40         }
  41
  42         for (int i = 0; i < _channels; ++i) {
  43                 _data[i] = static_cast<float*> (malloc (frames * sizeof (float)));
  44                 if (!_data[i]) {
  45                         throw bad_alloc ();
  46                 }
  47         }
  48 }
  49
  50 /** Copy constructor.
  51  *  @param other Other AudioBuffers; data is copied.
  52  */
  53 AudioBuffers::AudioBuffers (AudioBuffers const & other)
  54         : _channels (other._channels)
  55         , _frames (other._frames)
  56         , _allocated_frames (other._frames)
  57 {
  58         _data = static_cast<float**> (malloc (_channels * sizeof (float *)));
  59         if (!_data) {
  60                 throw bad_alloc ();
  61         }
  62
  63         for (int i = 0; i < _channels; ++i) {
  64                 _data[i] = static_cast<float*> (malloc (_frames * sizeof (float)));
  65                 if (!_data[i]) {
  66                         throw bad_alloc ();
  67                 }
  68                 memcpy (_data[i], other._data[i], _frames * sizeof (float));
  69         }
  70 }
  71
  72 /* XXX: it's a shame that this is a copy-and-paste of the above;
  73    probably fixable with c++0x.
  74 */
  75 AudioBuffers::AudioBuffers (boost::shared_ptr<const AudioBuffers> other)
  76         : _channels (other->_channels)
  77         , _frames (other->_frames)
  78         , _allocated_frames (other->_frames)
  79 {
  80         _data = static_cast<float**> (malloc (_channels * sizeof (float *)));
  81         if (!_data) {
  82                 throw bad_alloc ();
  83         }
  84
  85         for (int i = 0; i < _channels; ++i) {
  86                 _data[i] = static_cast<float*> (malloc (_frames * sizeof (float)));
  87                 if (!_data[i]) {
  88                         throw bad_alloc ();
  89                 }
  90                 memcpy (_data[i], other->_data[i], _frames * sizeof (float));
  91         }
  92 }
  93
  94 /** AudioBuffers destructor */
  95 AudioBuffers::~AudioBuffers ()
  96 {
  97         for (int i = 0; i < _channels; ++i) {
  98                 free (_data[i]);
  99         }
 100
 101         free (_data);
 102 }
 103
 104 /** @param c Channel index.
 105  *  @return Buffer for this channel.
 106  */
 107 float*
 108 AudioBuffers::data (int c) const
 109 {
 110         assert (c >= 0 && c < _channels);
 111         return _data[c];
 112 }
 113
 114 /** Set the number of frames that these AudioBuffers will report themselves
 115  *  as having.
 116  *  @param f Frames; must be less than or equal to the number of allocated frames.
 117  */
 118 void
 119 AudioBuffers::set_frames (int f)
 120 {
 121         assert (f <= _allocated_frames);
 122         _frames = f;
 123 }
 124
 125 /** Make all samples on all channels silent */
 126 void
 127 AudioBuffers::make_silent ()
 128 {
 129         for (int i = 0; i < _channels; ++i) {
 130                 make_silent (i);
 131         }
 132 }
 133
 134 /** Make all samples on a given channel silent.
 135  *  @param c Channel.
 136  */
 137 void
 138 AudioBuffers::make_silent (int c)
 139 {
 140         assert (c >= 0 && c < _channels);
 141
 142         for (int i = 0; i < _frames; ++i) {
 143                 _data[c][i] = 0;
 144         }
 145 }
 146
 147 /** Copy data from another AudioBuffers to this one.  All channels are copied.
 148  *  @param from AudioBuffers to copy from; must have the same number of channels as this.
 149  *  @param frames_to_copy Number of frames to copy.
 150  *  @param read_offset Offset to read from in `from'.
 151  *  @param write_offset Offset to write to in `to'.
 152  */
 153 void
 154 AudioBuffers::copy_from (AudioBuffers const * from, int frames_to_copy, int read_offset, int write_offset)
 155 {
 156         assert (from->channels() == channels());
 157
 158         assert (from);
 159         assert (read_offset >= 0 && (read_offset + frames_to_copy) <= from->_allocated_frames);
 160         assert (write_offset >= 0 && (write_offset + frames_to_copy) <= _allocated_frames);
 161
 162         for (int i = 0; i < _channels; ++i) {
 163                 memcpy (_data[i] + write_offset, from->_data[i] + read_offset, frames_to_copy * sizeof(float));
 164         }
 165 }
 166
 167 /** Move audio data around.
 168  *  @param from Offset to move from.
 169  *  @param to Offset to move to.
 170  *  @param frames Number of frames to move.
 171  */
 172
 173 void
 174 AudioBuffers::move (int from, int to, int frames)
 175 {
 176         if (frames == 0) {
 177                 return;
 178         }
 179
 180         assert (from >= 0);
 181         assert (from < _frames);
 182         assert (to >= 0);
 183         assert (to < _frames);
 184         assert (frames > 0);
 185         assert (frames <= _frames);
 186         assert ((from + frames) <= _frames);
 187         assert ((to + frames) <= _frames);
 188
 189         for (int i = 0; i < _channels; ++i) {
 190                 memmove (_data[i] + to, _data[i] + from, frames * sizeof(float));
 191         }
 192 }
 193
 194 /** Add data from from `from', `from_channel' to our channel `to_channel' */
 195 void
 196 AudioBuffers::accumulate_channel (AudioBuffers const * from, int from_channel, int to_channel)
 197 {
 198         int const N = frames ();
 199         assert (from->frames() == N);
 200
 201         float* s = from->data (from_channel);
 202         float* d = _data[to_channel];
 203
 204         for (int i = 0; i < N; ++i) {
 205                 *d++ += *s++;
 206         }
 207 }
 208
 209 /** Ensure we have space for at least a certain number of frames.  If we extend
 210  *  the buffers, fill the new space with silence.
 211  */
 212 void
 213 AudioBuffers::ensure_size (int frames)
 214 {
 215         if (_allocated_frames >= frames) {
 216                 return;
 217         }
 218
 219         for (int i = 0; i < _channels; ++i) {
 220                 _data[i] = static_cast<float*> (realloc (_data[i], frames * sizeof (float)));
 221                 if (!_data[i]) {
 222                         throw bad_alloc ();
 223                 }
 224                 for (int j = _allocated_frames; j < frames; ++j) {
 225                         _data[i][j] = 0;
 226                 }
 227         }
 228
 229         _allocated_frames = frames;
 230 }
 231
 232 void
 233 AudioBuffers::accumulate_frames (AudioBuffers const * from, int read_offset, int write_offset, int frames)
 234 {
 235         assert (_channels == from->channels ());
 236
 237         for (int i = 0; i < _channels; ++i) {
 238                 for (int j = 0; j < frames; ++j) {
 239                         _data[i][j + write_offset] += from->data()[i][j + read_offset];
 240                 }
 241         }
 242 }
 243