libs/ardour/transient_detector.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   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 <cmath>
  21
  22 #include "ardour/readable.h"
  23 #include "ardour/transient_detector.h"
  24
  25 #include "i18n.h"
  26
  27 using namespace Vamp;
  28 using namespace ARDOUR;
  29 using namespace std;
  30
  31 /* need a static initializer function for this */
  32
  33 string TransientDetector::_op_id = X_("qm-onset");
  34
  35 TransientDetector::TransientDetector (float sr)
  36         : AudioAnalyser (sr, X_("libardourvampplugins:qm-onsetdetector"))
  37 {
  38         threshold = 0.00;
  39 }
  40
  41 TransientDetector::~TransientDetector()
  42 {
  43 }
  44
  45 string
  46 TransientDetector::operational_identifier()
  47 {
  48         return _op_id;
  49 }
  50
  51 int
  52 TransientDetector::run (const std::string& path, Readable* src, uint32_t channel, AnalysisFeatureList& results)
  53 {
  54         current_results = &results;
  55         int ret = analyse (path, src, channel);
  56
  57         current_results = 0;
  58
  59         return ret;
  60 }
  61
  62 int
  63 TransientDetector::use_features (Plugin::FeatureSet& features, ostream* out)
  64 {
  65         const Plugin::FeatureList& fl (features[0]);
  66
  67         for (Plugin::FeatureList::const_iterator f = fl.begin(); f != fl.end(); ++f) {
  68
  69                 if (f->hasTimestamp) {
  70
  71                         if (out) {
  72                                 (*out) << (*f).timestamp.toString() << endl;
  73                         }
  74
  75                         current_results->push_back (RealTime::realTime2Frame (f->timestamp, (framecnt_t) floor(sample_rate)));
  76                 }
  77         }
  78
  79         return 0;
  80 }
  81
  82 void
  83 TransientDetector::set_threshold (float val)
  84 {
  85         threshold = val;
  86 }
  87
  88 void
  89 TransientDetector::set_sensitivity (float val)
  90 {
  91         if (plugin) {
  92                 plugin->selectProgram ("Percussive onsets");
  93                 plugin->setParameter ("sensitivity", val);
  94         }
  95 }
  96
  97 void
  98 TransientDetector::cleanup_transients (AnalysisFeatureList& t, float sr, float gap_msecs)
  99 {
 100         if (t.empty()) {
 101                 return;
 102         }
 103
 104         t.sort ();
 105
 106         /* remove duplicates or other things that are too close */
 107
 108         AnalysisFeatureList::iterator i = t.begin();
 109         AnalysisFeatureList::iterator f, b;
 110         const framecnt_t gap_frames = (framecnt_t) floor (gap_msecs * (sr / 1000.0));
 111
 112         while (i != t.end()) {
 113
 114                 // move front iterator to just past i, and back iterator the same place
 115
 116                 f = i;
 117                 ++f;
 118                 b = f;
 119
 120                 // move f until we find a new value that is far enough away
 121
 122                 while ((f != t.end()) && (((*f) - (*i)) < gap_frames)) {
 123                         ++f;
 124                 }
 125
 126                 i = f;
 127
 128                 // if f moved forward from b, we had duplicates/too-close points: get rid of them
 129
 130                 if (b != f) {
 131                         t.erase (b, f);
 132                 }
 133         }
 134 }
 135
 136 void
 137 TransientDetector::update_positions (Readable* src, uint32_t channel, AnalysisFeatureList& positions)
 138 {
 139         int const buff_size = 1024;
 140         int const step_size = 64;
 141
 142         Sample* data = new Sample[buff_size];
 143
 144         AnalysisFeatureList::iterator i = positions.begin();
 145
 146         while (i != positions.end()) {
 147
 148                 /* read from source */
 149                 framecnt_t const to_read = buff_size;
 150
 151                 if (src->read (data, (*i) - buff_size, to_read, channel) != to_read) {
 152                         break;
 153                 }
 154
 155                 // Simple heuristic for locating approx correct cut position.
 156
 157                 for (int j = 0; j < (buff_size - step_size); ) {
 158
 159                         Sample const s = abs (data[j]);
 160                         Sample const s2 = abs (data[j + step_size]);
 161
 162                         if ((s2 - s) > threshold) {
 163                                 //cerr << "Thresh exceeded. Moving pos from: " << (*i) << " to: " << (*i) - buff_size + (j + 16) << endl;
 164                                 (*i) = (*i) - buff_size + (j + 24);
 165                                 break;
 166                         }
 167
 168                         j += step_size;
 169                 }
 170
 171                 ++i;
 172         }
 173
 174         delete [] data;
 175 }