src/lib/audio_merger.h

   1 /*
   2     Copyright (C) 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 "audio_buffers.h"
  21 #include "util.h"
  22
  23 template <class T, class F>
  24 class AudioMerger
  25 {
  26 public:
  27         AudioMerger (int channels, boost::function<F (T)> t_to_f, boost::function<T (F)> f_to_t)
  28                 : _buffers (new AudioBuffers (channels, 0))
  29                 , _next_out (0)
  30                 , _t_to_f (t_to_f)
  31                 , _f_to_t (f_to_t)
  32         {}
  33
  34         TimedAudioBuffers<T>
  35         push (boost::shared_ptr<const AudioBuffers> audio, T time)
  36         {
  37                 assert (time >= _next_out);
  38
  39                 TimedAudioBuffers<T> out;
  40
  41                 if (time > _next_out) {
  42                         /* We can return some audio from our buffer; this is how many frames
  43                            we are going to return.
  44                         */
  45                         F const to_return = _t_to_f (time - _next_out);
  46                         out.audio.reset (new AudioBuffers (_buffers->channels(), to_return));
  47                         /* And this is how many we will get from our buffer */
  48                         F const to_return_from_buffers = min (to_return, _buffers->frames ());
  49
  50                         /* Copy the data that we have to the back end of the return buffer */
  51                         out.audio->copy_from (_buffers.get(), to_return_from_buffers, 0, to_return - to_return_from_buffers);
  52                         /* Silence any gap at the start */
  53                         out.audio->make_silent (0, to_return - to_return_from_buffers);
  54
  55                         out.time = _next_out;
  56                         _next_out += _f_to_t (to_return);
  57
  58                         /* And remove the data we're returning from our buffers */
  59                         if (_buffers->frames() > to_return_from_buffers) {
  60                                 _buffers->move (to_return_from_buffers, 0, _buffers->frames() - to_return_from_buffers);
  61                         }
  62                         _buffers->set_frames (_buffers->frames() - to_return_from_buffers);
  63                 }
  64
  65                 /* Now accumulate the new audio into our buffers */
  66                 F frame = _t_to_f (time);
  67                 F after = max (_buffers->frames(), frame + audio->frames() - _t_to_f (_next_out));
  68                 _buffers->ensure_size (after);
  69                 _buffers->accumulate_frames (audio.get(), 0, frame - _t_to_f (_next_out), audio->frames ());
  70                 _buffers->set_frames (after);
  71
  72                 return out;
  73         }
  74
  75         F min (F a, int b)
  76         {
  77                 if (a < b) {
  78                         return a;
  79                 }
  80
  81                 return b;
  82         }
  83
  84         F max (int a, F b)
  85         {
  86                 if (a > b) {
  87                         return a;
  88                 }
  89
  90                 return b;
  91         }
  92
  93         TimedAudioBuffers<T>
  94         flush ()
  95         {
  96                 if (_buffers->frames() == 0) {
  97                         return TimedAudioBuffers<T> ();
  98                 }
  99
 100                 return TimedAudioBuffers<T> (_buffers, _next_out);
 101         }
 102
 103 private:
 104         boost::shared_ptr<AudioBuffers> _buffers;
 105         T _next_out;
 106         boost::function<F (T)> _t_to_f;
 107         boost::function<T (F)> _f_to_t;
 108 };