libs/ardour/srcfilesource.cc

   1 /*
   2     Copyright (C) 2014 Paul Davis
   3     Written by: Robin Gareus <robin@gareus.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "pbd/error.h"
  22 #include "pbd/failed_constructor.h"
  23
  24 #include "ardour/audiofilesource.h"
  25 #include "ardour/debug.h"
  26 #include "ardour/srcfilesource.h"
  27
  28 #include "pbd/i18n.h"
  29
  30 using namespace ARDOUR;
  31 using namespace PBD;
  32
  33 const uint32_t SrcFileSource::max_blocksize = 2097152U; /* see AudioDiskstream::_do_refill_with_alloc, max */
  34
  35 SrcFileSource::SrcFileSource (Session& s, boost::shared_ptr<AudioFileSource> src, SrcQuality srcq)
  36         : Source(s, DataType::AUDIO, src->name(), Flag (src->flags() & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
  37         , AudioFileSource (s, src->path(), Flag (src->flags() & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
  38         , _source (src)
  39         , _src_state (0)
  40         , _source_position(0)
  41         , _target_position(0)
  42         , _fract_position(0)
  43 {
  44         assert(_source->n_channels() == 1);
  45
  46         int src_type = SRC_SINC_BEST_QUALITY;
  47
  48         switch (srcq) {
  49                 case SrcBest:
  50                         src_type = SRC_SINC_BEST_QUALITY;
  51                         break;
  52                 case SrcGood:
  53                         src_type = SRC_SINC_MEDIUM_QUALITY;
  54                         break;
  55                 case SrcQuick:
  56                         src_type = SRC_SINC_FASTEST;
  57                         break;
  58                 case SrcFast:
  59                         src_type = SRC_ZERO_ORDER_HOLD;
  60                         break;
  61                 case SrcFastest:
  62                         src_type = SRC_LINEAR;
  63                         break;
  64         }
  65
  66
  67         _ratio = s.nominal_frame_rate() / _source->sample_rate();
  68         _src_data.src_ratio = _ratio;
  69
  70         src_buffer_size = ceil((double)max_blocksize / _ratio) + 2;
  71         _src_buffer = new float[src_buffer_size];
  72
  73         int err;
  74         if ((_src_state = src_new (src_type, 1, &err)) == 0) {
  75                 error << string_compose(_("Import: src_new() failed : %1"), src_strerror (err)) << endmsg ;
  76                 throw failed_constructor ();
  77         }
  78 }
  79
  80 SrcFileSource::~SrcFileSource ()
  81 {
  82         DEBUG_TRACE (DEBUG::AudioPlayback, "SrcFileSource::~SrcFileSource\n");
  83         _src_state = src_delete (_src_state) ;
  84         delete [] _src_buffer;
  85 }
  86
  87 void
  88 SrcFileSource::close ()
  89 {
  90         boost::shared_ptr<FileSource> fs = boost::dynamic_pointer_cast<FileSource> (_source);
  91         if (fs) {
  92                 fs->close ();
  93         }
  94 }
  95
  96 framecnt_t
  97 SrcFileSource::read_unlocked (Sample *dst, framepos_t start, framecnt_t cnt) const
  98 {
  99         int err;
 100         const double srccnt = cnt / _ratio;
 101
 102         if (_target_position != start) {
 103                 DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("SRC: reset %1 -> %2\n", _target_position, start));
 104                 src_reset(_src_state);
 105                 _fract_position = 0;
 106                 _source_position = start / _ratio;
 107                 _target_position = start;
 108         }
 109
 110         const framecnt_t scnt = ceilf(srccnt - _fract_position);
 111         _fract_position += (scnt - srccnt);
 112
 113 #ifndef NDEBUG
 114         if (scnt >= src_buffer_size) {
 115                 DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("SRC: CRASH AHEAD :)  %1 >= %2 (fract=%3, cnt=%4)\n",
 116                                         scnt, src_buffer_size, _fract_position, cnt));
 117         }
 118 #endif
 119         assert(scnt < src_buffer_size);
 120
 121         _src_data.input_frames = _source->read (_src_buffer, _source_position, scnt);
 122
 123         if ((framecnt_t) _src_data.input_frames * _ratio <= cnt
 124                         && _source_position + scnt >= _source->length(0)) {
 125                 _src_data.end_of_input = true;
 126                 DEBUG_TRACE (DEBUG::AudioPlayback, "SRC: END OF INPUT\n");
 127         } else {
 128                 _src_data.end_of_input = false;
 129         }
 130
 131         if ((framecnt_t) _src_data.input_frames < scnt) {
 132                 _target_position += _src_data.input_frames * _ratio;
 133         } else {
 134                 _target_position += cnt;
 135         }
 136
 137         _src_data.output_frames = cnt;
 138         _src_data.data_in = _src_buffer;
 139         _src_data.data_out = dst;
 140
 141         if ((err = src_process (_src_state, &_src_data))) {
 142                 error << string_compose(_("SrcFileSource: %1"), src_strerror (err)) << endmsg ;
 143                 return 0;
 144         }
 145
 146         if (_src_data.end_of_input && _src_data.output_frames_gen <= 0) {
 147                 return 0;
 148         }
 149
 150         _source_position += _src_data.input_frames_used;
 151
 152         framepos_t saved_target = _target_position;
 153         framecnt_t generated = _src_data.output_frames_gen;
 154
 155         while (generated < cnt) {
 156                 DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("SRC: recurse for %1 samples\n",  cnt - generated));
 157                 framecnt_t g = read_unlocked(dst + generated, _target_position, cnt - generated);
 158                 generated += g;
 159                 if (g == 0) break;
 160         }
 161         _target_position = saved_target;
 162
 163         DEBUG_TRACE (DEBUG::AudioPlayback, string_compose ("SRC: in: %1-> want: %2 || got: %3 total: %4\n",
 164                                 _src_data.input_frames, _src_data.output_frames, _src_data.output_frames_gen, generated));
 165
 166         return generated;
 167 }