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                 , _last_pull (0)
  30                 , _t_to_f (t_to_f)
  31                 , _f_to_t (f_to_t)
  32         {}
  33
  34         /** Pull audio up to a given time; after this call, no more data can be pushed
  35          *  before the specified time.
  36          */
  37         TimedAudioBuffers<T>
  38         pull (T time)
  39         {
  40                 TimedAudioBuffers<T> out;
  41
  42                 F const to_return = _t_to_f (time - _last_pull);
  43                 out.audio.reset (new AudioBuffers (_buffers->channels(), to_return));
  44                 /* And this is how many we will get from our buffer */
  45                 F const to_return_from_buffers = min (to_return, _buffers->frames ());
  46
  47                 /* Copy the data that we have to the back end of the return buffer */
  48                 out.audio->copy_from (_buffers.get(), to_return_from_buffers, 0, to_return - to_return_from_buffers);
  49                 /* Silence any gap at the start */
  50                 out.audio->make_silent (0, to_return - to_return_from_buffers);
  51
  52                 out.time = _last_pull;
  53                 _last_pull = time;
  54
  55                 /* And remove the data we're returning from our buffers */
  56                 if (_buffers->frames() > to_return_from_buffers) {
  57                         _buffers->move (to_return_from_buffers, 0, _buffers->frames() - to_return_from_buffers);
  58                 }
  59                 _buffers->set_frames (_buffers->frames() - to_return_from_buffers);
  60
  61                 return out;
  62         }
  63
  64         void
  65         push (boost::shared_ptr<const AudioBuffers> audio, T time)
  66         {
  67                 assert (time >= _last_pull);
  68
  69                 F frame = _t_to_f (time);
  70                 F after = max (_buffers->frames(), frame + audio->frames() - _t_to_f (_last_pull));
  71                 _buffers->ensure_size (after);
  72                 _buffers->accumulate_frames (audio.get(), 0, frame - _t_to_f (_last_pull), audio->frames ());
  73                 _buffers->set_frames (after);
  74         }
  75
  76         F min (F a, int b)
  77         {
  78                 if (a < b) {
  79                         return a;
  80                 }
  81
  82                 return b;
  83         }
  84
  85         F max (int a, F b)
  86         {
  87                 if (a > b) {
  88                         return a;
  89                 }
  90
  91                 return b;
  92         }
  93
  94         TimedAudioBuffers<T>
  95         flush ()
  96         {
  97                 if (_buffers->frames() == 0) {
  98                         return TimedAudioBuffers<T> ();
  99                 }
 100
 101                 return TimedAudioBuffers<T> (_buffers, _last_pull);
 102         }
 103
 104 private:
 105         boost::shared_ptr<AudioBuffers> _buffers;
 106         T _last_pull;
 107         boost::function<F (T)> _t_to_f;
 108         boost::function<T (F)> _f_to_t;
 109 };