libs/vamp-plugins/Transcription.cpp

   1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
   2
   3 /*
   4   QM Vamp Plugin Set
   5
   6   Centre for Digital Music, Queen Mary, University of London.
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License as
  10     published by the Free Software Foundation; either version 2 of the
  11     License, or (at your option) any later version.  See the file
  12     COPYING included with this distribution for more information.
  13 */
  14
  15 /*transcription vamp plugin: Ruohua Zhou, Josh Reiss, josh.reiss@elec.qmul.ac.uk */
  16
  17 #include "Transcription.h"
  18 #include <vamp-sdk/PluginAdapter.h>
  19 #include <math.h>
  20 #include <stdlib.h>
  21
  22 using std::string;
  23 using std::vector;
  24 using std::cerr;
  25 using std::endl;
  26
  27 const double CNum[8] = {
  28     3.025328153863e-005,0.0002117729707704,0.0006353189123113, 0.001058864853852,
  29     0.001058864853852,0.0006353189123113,0.0002117729707704,3.025328153863e-005
  30 };
  31
  32 const double CDen[8] = {
  33     1,   -4.647847898799,    9.540784706769,   -11.14354542746,
  34     7.967285533211,   -3.477244449085,   0.8559660579522, -0.09152610255505
  35 };
  36
  37 const int A[10] = {0, 120, 190, 240, 279, 310, 337, 360, 380, 399};
  38
  39
  40
  41 const double EualCurve960[960] = {
  42     83.750025,83.532690,83.315770,83.099260,82.883159,82.667463,82.452170,82.237276,82.022779,81.808675,
  43     81.594963,81.381639,81.168699,80.956142,80.743964,80.532163,80.320735,80.109677,79.898987,79.688663,79.478700,79.269096,79.059848,78.850953,
  44     78.642408,78.434211,78.226359,78.018848,77.811676,77.604839,77.398336,77.192162,76.986316,76.780794,76.575593,76.370710,76.166143,75.961889,
  45     75.757945,75.554307,75.350973,75.147940,74.945205,74.742766,74.540618,74.338761,74.137189,73.935902,73.734895,73.534166,73.333712,73.133529,
  46     72.933616,72.733970,72.534586,72.335463,72.136598,71.937987,71.739628,71.541517,71.343653,71.146032,70.948650,70.751506,70.554597,70.357919,
  47     70.161469,69.965245,69.769244,69.573462,69.377898,69.182548,68.987408,68.792477,68.597752,68.403228,68.208905,68.014781,67.820873,67.627197,
  48     67.433772,67.240617,67.047749,66.855187,66.662949,66.471053,66.279516,66.088358,65.897597,65.707250,65.517336,65.327873,65.138879,64.950373,
  49     64.762372,64.574894,64.387959,64.201583,64.015785,63.830584,63.645997,63.462043,63.278739,63.096105,62.914158,62.732915,62.552397,62.372620,
  50     62.193602,62.015363,61.837920,61.661291,61.485494,61.310549,61.136471,60.963274,60.790941,60.619447,60.448770,60.278885,60.109770,59.941401,
  51     59.773755,59.606807,59.440536,59.274916,59.109924,58.945538,58.781733,58.618486,58.455773,58.293572,58.131858,57.970608,57.809799,57.649407,
  52     57.489408,57.329780,57.170498,57.011539,56.852880,56.694496,56.536366,56.378464,56.220768,56.063255,55.905900,55.748680,55.591571,55.434551,
  53     55.277595,55.120681,54.963784,54.806886,54.649983,54.493077,54.336169,54.179261,54.022353,53.865448,53.708546,53.551650,53.394759,53.237877,
  54     53.081003,52.924139,52.767287,52.610448,52.453624,52.296815,52.140023,51.983250,51.826496,51.669763,51.513053,51.356366,51.199705,51.043070,
  55     50.886463,50.729885,50.573337,50.416821,50.260338,50.103890,49.947478,49.791103,49.634766,49.478469,49.322214,49.166001,49.009832,48.853710,
  56     48.697648,48.541659,48.385757,48.229958,48.074273,47.918719,47.763308,47.608055,47.452974,47.298080,47.143385,46.988904,46.834652,46.680642,
  57     46.526889,46.373405,46.220207,46.067307,45.914720,45.762460,45.610540,45.458976,45.307780,45.156968,45.006553,44.856549,44.706971,44.557832,
  58     44.409146,44.260928,44.113192,43.965951,43.819220,43.673013,43.527344,43.382227,43.237676,43.093703,42.950305,42.807478,42.665218,42.523520,
  59     42.382381,42.241794,42.101757,41.962264,41.823311,41.684894,41.547008,41.409648,41.272811,41.136491,41.000685,40.865387,40.730594,40.596301,
  60     40.462503,40.329195,40.196375,40.064036,39.932175,39.800787,39.669867,39.539412,39.409417,39.279876,39.150787,39.022143,38.893942,38.766178,
  61     38.638846,38.511944,38.385465,38.259405,38.133761,38.008525,37.883679,37.759203,37.635076,37.511278,37.387789,37.264588,37.141656,37.018971,
  62     36.896513,36.774262,36.652197,36.530298,36.408545,36.286918,36.165395,36.043957,35.922583,35.801253,35.679947,35.558643,35.437322,35.315964,
  63     35.194547,35.073052,34.951458,34.829745,34.707892,34.585879,34.463686,34.341293,34.218678,34.095822,33.972704,33.849303,33.725600,33.601574,
  64     33.477205,33.352481,33.227425,33.102069,32.976445,32.850585,32.724520,32.598284,32.471906,32.345420,32.218858,32.092250,31.965629,31.839028,
  65     31.712477,31.586009,31.459655,31.333448,31.207419,31.081601,30.956024,30.830722,30.705725,30.581067,30.456777,30.332890,30.209436,30.086447,
  66     29.963955,29.841993,29.720591,29.599783,29.479599,29.360071,29.241233,29.123114,29.005748,28.889166,28.773400,28.658474,28.544378,28.431095,
  67     28.318607,28.206897,28.095947,27.985740,27.876257,27.767481,27.659396,27.551982,27.445224,27.339102,27.233599,27.128699,27.024383,26.920633,
  68     26.817433,26.714764,26.612609,26.510951,26.409772,26.309053,26.208779,26.108930,26.009491,25.910442,25.811766,25.713446,25.615465,25.517804,
  69     25.420446,25.323374,25.226570,25.130016,25.033695,24.937589,24.841681,24.745955,24.650409,24.555043,24.459856,24.364847,24.270016,24.175363,
  70     24.080887,23.986588,23.892466,23.798520,23.704751,23.611156,23.517737,23.424492,23.331422,23.238526,23.145803,23.053253,22.960877,22.868672,
  71     22.776640,22.684779,22.593090,22.501572,22.410224,22.319046,22.228038,22.137200,22.046530,21.956029,21.865697,21.775532,21.685535,21.595704,
  72     21.506041,21.416544,21.327213,21.238047,21.149047,21.060211,20.971540,20.883034,20.794691,20.706512,20.618496,20.530642,20.442952,20.355423,
  73     20.268057,20.180852,20.093808,20.006925,19.920202,19.833640,19.747237,19.660994,19.574910,19.488985,19.403218,19.317610,19.232159,19.146866,
  74     19.061729,18.976750,18.891927,18.807260,18.722749,18.638393,18.554193,18.470147,18.386255,18.302518,18.218934,18.135504,18.052227,17.969105,
  75     17.886151,17.803379,17.720805,17.638444,17.556310,17.474419,17.392786,17.311425,17.230351,17.149581,17.069127,16.989007,16.909233,16.829822,
  76     16.750789,16.672148,16.593914,16.516103,16.438729,16.361808,16.285354,16.209382,16.133907,16.058945,15.984510,15.910617,15.837282,15.764518,
  77     15.692342,15.620768,15.549811,15.479486,15.409809,15.340793,15.272455,15.204808,15.137869,15.071646,15.006129,14.941300,14.877144,14.813643,
  78     14.750781,14.688540,14.626906,14.565860,14.505386,14.445467,14.386088,14.327231,14.268879,14.211016,14.153626,14.096691,14.040195,13.984121,
  79     13.928453,13.873174,13.818267,13.763716,13.709504,13.655615,13.602031,13.548736,13.495714,13.442948,13.390420,13.338115,13.286016,13.234107,
  80     13.182369,13.130788,13.079346,13.028026,12.976813,12.925693,12.874671,12.823756,12.772958,12.722285,12.671746,12.621351,12.571107,12.521025,
  81     12.471113,12.421380,12.371835,12.322488,12.273346,12.224419,12.175717,12.127248,12.079020,12.031044,11.983328,11.935880,11.888711,11.841828,
  82     11.795242,11.748960,11.702993,11.657348,11.612035,11.567063,11.522441,11.478178,11.434282,11.390764,11.347631,11.304893,11.262558,11.220637,
  83     11.179137,11.138068,11.097437,11.057252,11.017521,10.978252,10.939452,10.901129,10.863290,10.825944,10.789098,10.752760,10.716937,10.681638,
  84     10.646869,10.612640,10.578956,10.545827,10.513259,10.481261,10.449840,10.419004,10.388760,10.359117,10.330082,10.301663,10.273867,10.246702,
  85     10.220176,10.194296,10.169071,10.144508,10.120615,10.097399,10.074868,10.053030,10.031892,10.011463,9.991749,9.972762,9.954523,9.937056,9.920385,
  86     9.904534,9.889527,9.875389,9.862144,9.849815,9.838428,9.828005,9.818572,9.810152,9.802770,9.796449,9.791214,9.787089,9.784099,9.782266,9.781616,
  87     9.782172,9.783959,9.787001,9.791322,9.796946,9.803897,9.812200,9.821878,9.832956,9.845457,9.859407,9.874829,9.891747,9.910185,9.930168,9.951720,
  88     9.974864,9.999625,10.026008,10.053933,10.083304,10.114023,10.145991,10.179112,10.213287,10.248419,10.284410,10.321161,10.358576,10.396556,10.435004,
  89     10.473821,10.512911,10.552175,10.591516,10.630835,10.670035,10.709018,10.747686,10.785942,10.823688,10.860826,10.897258,10.932886,10.967613,11.001341,
  90     11.033972,11.065408,11.095552,11.124305,11.151570,11.177249,11.201245,11.223459,11.243793,11.262151,11.278450,11.292676,11.304827,11.314906,11.322913,
  91     11.328848,11.332713,11.334508,11.334233,11.331889,11.327477,11.320998,11.312453,11.301841,11.289164,11.274422,11.257616,11.238747,11.217816,11.194822,
  92     11.169767,11.142652,11.113476,11.082241,11.048948,11.013597,10.976189,10.936724,10.895203,10.851627,10.805996,10.758312,10.708574,10.656784,10.602942,
  93     10.547049,10.489106,10.429113,10.367082,10.303073,10.237155,10.169399,10.099876,10.028655,9.955807,9.881403,9.805512,9.728206,9.649554,9.569627,9.488495,
  94     9.406228,9.322897,9.238573,9.153325,9.067225,8.980341,8.892745,8.804508,8.715698,8.626388,8.536646,8.446544,8.356152,8.265539,8.174778,8.083937,7.993087,
  95     7.902299,7.811643,7.721190,7.631008,7.541170,7.451746,7.362804,7.274417,7.186644,7.099504,7.013003,6.927151,6.841956,6.757424,6.673565,6.590385,6.507894,
  96     6.426099,6.345008,6.264629,6.184970,6.106039,6.027843,5.950392,5.873692,5.797752,5.722579,5.648183,5.574570,5.501748,5.429727,5.358512,5.288114,5.218538,
  97     5.149794,5.081890,5.014832,4.948630,4.883292,4.818824,4.755236,4.692535,4.630729,4.569826,4.509834,4.450761,4.392616,4.335415,4.279172,4.223905,4.169630,
  98     4.116362,4.064118,4.012914,3.962766,3.913691,3.865703,3.818820,3.773058,3.728432,3.684960,3.642656,3.601538,3.561621,3.522921,3.485455,3.449239,3.414289,
  99     3.380620,3.348250,3.317194,3.287469,3.259090,3.232074,3.206437,3.182194,3.159363,3.137959,3.117999,3.099498,3.082473,3.066939,3.052914,3.040413,3.029451,
 100     3.020039,3.012186,3.005904,3.001201,2.998087,2.996571,2.996665,2.998377,3.001718,3.006696,3.013323,3.021607,3.031559,3.043187,3.056503,3.071516,3.088235,
 101     3.106671,3.126833,3.148731,3.172374,3.197773,3.224938,3.253877,3.284601,3.317120,3.351444,3.387581,3.425543,3.465339,3.506978,3.550470,3.595826,3.643054,
 102     3.692166,3.743169,3.796075,3.850896,3.907655,3.966377,4.027088,4.089815,4.154581,4.221415,4.290340,4.361382,4.434569,4.509924,4.587474,4.667245,4.749261,
 103     4.833550,4.920136,5.009046,5.100305,5.193938,5.289972,5.388432,5.489343,5.592732,5.698625,5.807046,5.918022,6.031578,6.147741,6.266535,6.387986,6.512121,
 104     6.638964,6.768542,6.900880,7.036004,7.173939,7.314712,7.458348,7.604856,7.754175,7.906227,8.060936,8.218223,8.378012,8.540225,8.704784,8.871612,9.040631,
 105     9.211765,9.384934,9.560063,9.737073,9.915888,10.096429,10.278619,10.462380,10.647636,10.834309,11.022321,11.211594,11.402052,11.593616,11.786210,11.979755,
 106     12.174175,12.369392,12.565329,12.761907,12.959049,13.156679,13.354718,13.553089,13.751715,13.950518,14.149420,14.348345,14.547211,14.745925,14.944391,
 107     15.142512,15.340191,15.537333,15.733840,15.929615,16.124564
 108 };
 109 void Transcribe(int Len,int inputLen,double *SoundIn,double *out,double *outArray2,double *outArray3,double SampleRate);
 110
 111 Transcription::Transcription(float inputSampleRate) :
 112     Plugin(inputSampleRate),
 113     m_stepSize(0)
 114 {
 115     m_SoundIn=0;
 116     m_SampleN=0;
 117     m_AllocN = 0;
 118     m_Excess = false;
 119 }
 120
 121 Transcription::~Transcription()
 122 {
 123     free(m_SoundIn);
 124 }
 125
 126 string
 127 Transcription::getIdentifier() const
 128 {
 129     return "qm-transcription";
 130 }
 131
 132 string
 133 Transcription::getName() const
 134 {
 135     return "Polyphonic Transcription";
 136 }
 137
 138 string
 139 Transcription::getDescription() const
 140 {
 141     return "Transcribe the input audio to estimated notes";
 142 }
 143
 144 string
 145 Transcription::getMaker() const
 146 {
 147     return "Queen Mary, University of London";
 148 }
 149
 150 int
 151 Transcription::getPluginVersion() const
 152 {
 153     return 1;
 154 }
 155
 156 string
 157 Transcription::getCopyright() const
 158 {
 159     return "Plugin by Dr. Ruohua Zhou.  Copyright (c) 2008-2009 QMUL - All Rights Reserved";
 160 }
 161
 162 size_t
 163 Transcription::getPreferredStepSize() const
 164 {
 165     return 441;
 166 }
 167
 168 size_t
 169 Transcription::getPreferredBlockSize() const
 170 {
 171     return 441;
 172 }
 173
 174 bool
 175 Transcription::initialise(size_t channels, size_t stepSize, size_t blockSize)
 176 {
 177     if (channels < getMinChannelCount() ||
 178         channels > getMaxChannelCount()) return false;
 179
 180     if (m_inputSampleRate < 4410 || m_inputSampleRate > 441000) return false;
 181
 182     m_stepSize = std::min(stepSize, blockSize);
 183     m_blockSize=blockSize;
 184
 185     m_SampleN = 0;
 186
 187     return true;
 188 }
 189
 190 void
 191 Transcription::reset()
 192 {
 193     free(m_SoundIn);
 194     m_SoundIn = 0;
 195     m_SampleN = 0;
 196     m_AllocN = 0;
 197     m_Excess = false;
 198     m_Base = Vamp::RealTime();
 199 }
 200
 201 Transcription::OutputList
 202 Transcription::getOutputDescriptors() const
 203 {
 204     OutputList list;
 205
 206     OutputDescriptor zc;
 207     zc.identifier = "transcription";
 208     zc.name = "Transcription";
 209     zc.description = "Estimated note pitch (MIDI note number from 0 to 127)";
 210     zc.unit = "MIDI units";
 211     zc.hasFixedBinCount = true;
 212     zc.binCount = 1;
 213     zc.hasKnownExtents = true;
 214     zc.minValue = 0;
 215     zc.maxValue = 127;
 216     zc.isQuantized = true;
 217     zc.quantizeStep = 1.0;
 218     zc.hasDuration = true;
 219     zc.sampleType = OutputDescriptor::VariableSampleRate;
 220
 221 /* no -- this is the result of a confusion between bin indices and values
 222     {
 223
 224         zc.binNames.push_back("A0");// MIDI Note 21
 225         zc.binNames.push_back("A0#");
 226         zc.binNames.push_back("B0");
 227         zc.binNames.push_back("C1");
 228         zc.binNames.push_back("C1#");
 229         zc.binNames.push_back("D1");
 230         zc.binNames.push_back("D1#");
 231         zc.binNames.push_back("E1");
 232         zc.binNames.push_back("F1");
 233         zc.binNames.push_back("F1#");
 234         zc.binNames.push_back("G1");
 235         zc.binNames.push_back("G1#");
 236
 237         zc.binNames.push_back("A1");// MIDI Note 33
 238         zc.binNames.push_back("A1#");
 239         zc.binNames.push_back("B1");
 240         zc.binNames.push_back("C2");
 241         zc.binNames.push_back("C2#");
 242         zc.binNames.push_back("D2");
 243         zc.binNames.push_back("D2#");
 244         zc.binNames.push_back("E2");
 245         zc.binNames.push_back("F2");
 246         zc.binNames.push_back("F2#");
 247         zc.binNames.push_back("G2");
 248         zc.binNames.push_back("G2#");
 249
 250         zc.binNames.push_back("A2");// MIDI Note 45
 251         zc.binNames.push_back("A2#");
 252         zc.binNames.push_back("B3");
 253         zc.binNames.push_back("C3");
 254         zc.binNames.push_back("C3#");
 255         zc.binNames.push_back("D3");
 256         zc.binNames.push_back("D3#");
 257         zc.binNames.push_back("E3");
 258         zc.binNames.push_back("F3");
 259         zc.binNames.push_back("F3#");
 260         zc.binNames.push_back("G3");
 261         zc.binNames.push_back("G3#");
 262
 263         zc.binNames.push_back("A3");// MIDI Note 57
 264         zc.binNames.push_back("A3#");
 265         zc.binNames.push_back("B0");
 266         zc.binNames.push_back("C4");
 267         zc.binNames.push_back("C4#");
 268         zc.binNames.push_back("D4");
 269         zc.binNames.push_back("D4#");
 270         zc.binNames.push_back("E4");
 271         zc.binNames.push_back("F4");
 272         zc.binNames.push_back("F4#");
 273         zc.binNames.push_back("G4");
 274         zc.binNames.push_back("G4#");
 275
 276         zc.binNames.push_back("A4");// MIDI Note 69
 277         zc.binNames.push_back("A4#");
 278         zc.binNames.push_back("B0");
 279         zc.binNames.push_back("C5");
 280         zc.binNames.push_back("C5#");
 281         zc.binNames.push_back("D5");
 282         zc.binNames.push_back("D5#");
 283         zc.binNames.push_back("E5");
 284         zc.binNames.push_back("F5");
 285         zc.binNames.push_back("F5#");
 286         zc.binNames.push_back("G5");
 287         zc.binNames.push_back("G5#");
 288
 289         zc.binNames.push_back("A5");// MIDI Note 85
 290         zc.binNames.push_back("A5#");
 291         zc.binNames.push_back("B0");
 292         zc.binNames.push_back("C6");
 293         zc.binNames.push_back("C6#");
 294         zc.binNames.push_back("D6");
 295         zc.binNames.push_back("D6#");
 296         zc.binNames.push_back("E6");
 297         zc.binNames.push_back("F6");
 298         zc.binNames.push_back("F6#");
 299         zc.binNames.push_back("G6");
 300         zc.binNames.push_back("G6#");
 301
 302         zc.binNames.push_back("A6");// MIDI Note 93
 303         zc.binNames.push_back("A6#");
 304         zc.binNames.push_back("B0");
 305         zc.binNames.push_back("C7");
 306         zc.binNames.push_back("C7#");
 307         zc.binNames.push_back("D7");
 308         zc.binNames.push_back("D7#");
 309         zc.binNames.push_back("E7");
 310         zc.binNames.push_back("F7");
 311         zc.binNames.push_back("F7#");
 312         zc.binNames.push_back("G7");
 313         zc.binNames.push_back("G7#");
 314
 315         zc.binNames.push_back("A7");// MIDI Note 105
 316         zc.binNames.push_back("A7#");
 317         zc.binNames.push_back("B0");
 318         zc.binNames.push_back("C8");
 319     }
 320 */
 321
 322     list.push_back(zc);
 323
 324 /*    zc.identifier = "Transcriptions";
 325       zc.name = "Polyphonic Transcription";
 326       zc.description = "Polyphonic Music Transcription";
 327       zc.unit = "";
 328       zc.hasFixedBinCount = true;
 329       zc.binCount = 0;
 330       zc.sampleType = OutputDescriptor::VariableSampleRate;
 331       zc.sampleRate = m_inputSampleRate;
 332       list.push_back(zc);*/
 333
 334     return list;
 335 }
 336
 337 Transcription::FeatureSet
 338 Transcription::process(const float *const *inputBuffers,
 339                        Vamp::RealTime timestamp)
 340 {
 341     if (m_stepSize == 0) {
 342         cerr << "ERROR: Transcription::process: "
 343              << "Transcription has not been initialised"
 344              << endl;
 345         return FeatureSet();
 346     }
 347
 348     if (m_SampleN == 0) {
 349         m_Base = timestamp;
 350     }
 351
 352     if (m_Excess) return FeatureSet();
 353
 354     for (size_t i = 0; i < m_blockSize;i++) {
 355
 356         if (m_SampleN >= m_AllocN) {
 357             size_t newsize = m_AllocN * 2;
 358             if (newsize < 10000) newsize = 10000;
 359             double *newbuf = (double *)realloc(m_SoundIn, newsize * sizeof(double));
 360             if (!newbuf) {
 361                 m_Excess = true;
 362                 break;
 363             }
 364             m_SoundIn = newbuf;
 365             m_AllocN = newsize;
 366         }
 367
 368         m_SoundIn[m_SampleN]=inputBuffers[0][i];
 369         m_SampleN=m_SampleN+1;
 370     }
 371
 372     return FeatureSet();
 373 }
 374
 375 Transcription::FeatureSet
 376 Transcription::getRemainingFeatures()
 377 {
 378     FeatureSet returnFeatures;
 379
 380     double * OutArray;
 381     double *OutArray2;
 382     double *hello1;
 383     double *hello2;
 384     int Msec;
 385     size_t i;
 386     size_t j;
 387     size_t n;
 388     size_t count;
 389
 390     Msec=(int)(100*m_SampleN/m_inputSampleRate);
 391
 392     if (Msec < 100) return returnFeatures;
 393
 394     OutArray=(double *)malloc(3*3000*sizeof(double));
 395     OutArray2=(double *)malloc(88*Msec*sizeof(double));
 396     hello1=(double *)malloc(112*Msec*sizeof(double));
 397     hello2=(double *)malloc(112*Msec*sizeof(double));
 398
 399     for (j = 0; j <Msec; j++) {
 400
 401         for(n=0;n<88;n++)
 402         {
 403
 404             OutArray2[j*88+n]=0;
 405         }
 406
 407     }
 408
 409
 410     Transcribe(Msec,m_SampleN,m_SoundIn,hello1,hello2,OutArray,m_inputSampleRate);
 411     int start;
 412     int endd;
 413
 414
 415     /* for (i = 0; i < 3000; i++) {
 416
 417        if((OutArray[3*i]>0)&&(OutArray[3*i]<88))
 418        {
 419        start=OutArray[3*i+1];endd=OutArray[3*i+2];
 420        for(j=start;j<(start+0.05);j=j+0.01)
 421        {
 422
 423        Feature feature;
 424        Vamp::RealTime ts;
 425
 426        feature.hasTimestamp = true;
 427
 428        feature.timestamp =ts.fromSeconds(j);
 429        feature.values.push_back(OutArray[3*i]+21);
 430        returnFeatures[0].push_back(feature);
 431
 432        }
 433
 434
 435
 436        }
 437        else
 438        {
 439
 440        break;
 441        }
 442
 443
 444        }
 445
 446     */
 447
 448
 449     for (i = 0; i < 3000; i++) {
 450
 451         if((OutArray[3*i]>0)&&(OutArray[3*i]<88))
 452         {
 453             start=100*OutArray[3*i+1];
 454             endd=100*OutArray[3*i+2]-5;
 455             for(j=start;j<endd;j++)
 456             {
 457                 n=OutArray[3*i];
 458                 OutArray2[j*88+n]=OutArray[3*i];
 459             }
 460
 461         }
 462         else
 463         {
 464
 465             break;
 466         }
 467
 468
 469     }
 470
 471     double starts[88];
 472     for (n = 0; n < 88; ++n) starts[n] = -1.0;
 473
 474     int nn;
 475     for (j = 0; j <Msec; j++) {
 476
 477
 478         for(n=0;n<88;n++)
 479         {
 480             if(OutArray2[j*88+n]>0)
 481             {
 482
 483                 if (starts[n] < 0.)
 484                 {
 485                     starts[n] = j * 0.01;
 486                 }
 487             }
 488             else
 489             {
 490                 if (starts[n] > 0.)
 491                 {
 492                     Feature feature;
 493                     feature.hasTimestamp = true;
 494                     feature.timestamp = m_Base + Vamp::RealTime::fromSeconds(starts[n]);
 495                     feature.hasDuration = true;
 496                     feature.duration = Vamp::RealTime::fromSeconds(j * 0.01 - starts[n]);
 497                     feature.values.push_back(n+20);
 498                     returnFeatures[0].push_back(feature);
 499
 500                     starts[n] = -1.0;
 501                 }
 502             }
 503         }
 504     }
 505
 506
 507     for(n=0;n<88;n++)
 508     {
 509         if (starts[n] > 0.)
 510         {
 511             Feature feature;
 512             feature.hasTimestamp = true;
 513             feature.timestamp = m_Base + Vamp::RealTime::fromSeconds(starts[n]);
 514             feature.hasDuration = true;
 515             feature.duration = Vamp::RealTime::fromSeconds(j * 0.01 - starts[n]);
 516             feature.values.push_back(n+20);
 517             returnFeatures[0].push_back(feature);
 518
 519             starts[n] = -1.0;
 520         }
 521     }
 522
 523     free(OutArray2);
 524     free(OutArray);
 525
 526     free(hello1);
 527     free(hello2);
 528
 529     return returnFeatures;
 530
 531 }
 532
 533
 534
 535
 536
 537 void sofacomplexMex(double *y, double *z, int ncols,double StartNote,double NoteInterval1,double NoteNum,double C,double D,double SR)
 538 {
 539     int mseconds,i,j,el,count,count2;
 540     double  Snote,NoteInterval,NoteN, BasicR;
 541     double  *signs;
 542     double  *rwork,*buffer;
 543     double  freq,R,gain,gainI,gainII,coefI,coefM;
 544     double output,input,outputI,outputM;
 545     double *x;
 546     double *sum,*sum2;
 547     double power;
 548     double temp;
 549
 550
 551     //SR=44100;
 552     Snote=StartNote;
 553     NoteInterval=NoteInterval1;
 554     NoteN=NoteNum;
 555
 556     signs=(double*)malloc((int)NoteN*5*sizeof(double));
 557
 558     for (i = 0; i <NoteN; i++) {
 559
 560         freq=exp((log(2.0))*(Snote+i*NoteInterval-69)/12)*440;
 561         R=exp(-(D+C*freq*2*3.1415926)/(SR*3.1415926));
 562         gain=(1*(sqrt(1+R*R-2*R*cos(2*freq*2*3.1415926/SR)))-1*R*(sqrt(1+R*R-2*R*cos(2*freq*2*3.1415926/SR))))/sin(freq*2*3.1415926/SR);
 563         gainI=-2*R*cos(freq*2*3.1415926/SR);
 564         gainII =R*R ;
 565         coefI=cos(freq*2*3.1415926/SR);
 566         coefM=sin(freq*2*3.1415926/SR);
 567
 568         signs[i*5+0]=gain*gain;
 569         signs[i*5+1]=gainI;
 570         signs[i*5+2]=gainII;
 571         signs[i*5+3]=coefI;
 572         signs[i*5+4]=coefM;
 573
 574     }
 575
 576     x=(double*)malloc((int)NoteN*2*sizeof(double));
 577     rwork=(double*)malloc((int)NoteN*sizeof(double));
 578     sum=(double*)malloc((int)NoteN*sizeof(double));
 579     sum2=(double*)malloc((int)NoteN*sizeof(double));
 580     mseconds=(int)(100*ncols/SR);
 581     power=0;
 582     for (i=0;i<mseconds*(int)(SR/100);i++)
 583     {
 584         power=power+y[i]*y[i];
 585     }
 586     power=sqrt(power);
 587     for(i=0;i<NoteN*2;i++)
 588         x[i]=0;
 589     for (i=0;i<NoteN;i++)
 590     {
 591         sum[i]=0;
 592         sum2[i]=0;
 593     };
 594     count=0;
 595     count2=0;
 596     for (i=0;i<(mseconds*(int)(SR/100));i++)
 597     {
 598         count=count+1;
 599         input=y[i];
 600         for(el=0;el<NoteN;el++)
 601         {
 602             output=(input-signs[5*el+1]*x[2*el+0]-signs[5*el+2]*x[2*el+1]);
 603             outputI=output-signs[5*el+3]*x[2*el+0];
 604             outputM=signs[5*el+4]*x[2*el+0];
 605             sum[el]=sum[el]+signs[5*el+0]*(outputI*outputI+ outputM*outputM);
 606             rwork[el]=output;
 607             x[el+el+1]=x[el+el+0];
 608             x[el+el+0]=rwork[el];
 609
 610         }
 611         if(count==(int)(SR/100))
 612         {
 613             for(el=0;el<NoteN;el++)
 614             {
 615                 *(z+count2*(int)NoteN+el)=1000000*(sum[el]+sum2[el])/(2*(int)(SR/100))+0.00001;
 616                 sum2[el]=sum[el];
 617                 sum[el]=0;
 618             }
 619             count2=count2+1;
 620             count=0;
 621         }
 622
 623     }
 624     for (i=0;i<NoteN;i++)
 625     {
 626         sum[i]=0;
 627         sum2[i]=0;
 628     };
 629     for (el=0;el<NoteN;el++)
 630     {
 631         for (i=0;i<mseconds;i++)
 632         {
 633             sum[el]=sum[el]+*(z+i*(int)NoteN+el);
 634         }
 635
 636     }
 637
 638     free(x);
 639     free(rwork);
 640     free(sum);
 641     free(sum2);
 642     free(signs);
 643
 644 }
 645
 646 void FindMaxN( double *InputArray, int InputLen,int MaxOrder)
 647 {
 648     int i,j,MaxIndex = 0;
 649     double MaxValue;
 650     double *In2;
 651
 652     In2=(double*)malloc(InputLen*sizeof(double));
 653     for (i=0;i<InputLen;i++)
 654     {
 655         In2[i]=InputArray[i];
 656         InputArray[i]=0;
 657     }
 658     for (i=0;i<MaxOrder;i++)
 659     {
 660         MaxValue=0;
 661         for (j=0;j<InputLen;j++)
 662         {
 663             if(In2[j]>MaxValue)
 664             {
 665                 MaxValue=In2[j];
 666                 MaxIndex=j;
 667             }
 668         }
 669         InputArray[MaxIndex]=In2[MaxIndex];
 670         In2[MaxIndex]=0;
 671     }
 672
 673     free(In2);
 674 }
 675
 676 double SumF(double *InputArray,int Start, int End)
 677 {
 678     double Value;
 679     int i;
 680     Value=0;
 681     for (i=Start;i<(End+1);i++)
 682     {
 683         Value=Value+InputArray[i];
 684     }
 685
 686     return Value;
 687
 688 }
 689
 690 int round10(int x)
 691 {
 692     int I,I2;
 693     I=((int)(x/10));
 694     I2=x-I*10;
 695
 696     if(I2>5)
 697         return (I+1);
 698     else
 699         return I;
 700
 701 }
 702
 703
 704 void ConToPitch1250(double *In, int InLen)
 705 {
 706     int i,j,k, nn,col;
 707     double *Out;
 708     const int A[12]={0, 120, 190, 240, 279, 310, 337, 360, 380, 399, 415, 430};
 709     Out=(double*)malloc(InLen*sizeof(double));
 710
 711
 712     col=InLen;
 713
 714     for (i=0;i<col;i++)
 715     {
 716         Out[i]=0;
 717     }
 718
 719     for (i=0;i<col;i++)
 720     {
 721         k=0;
 722         nn=5;
 723         for (j=0;j<nn;j++)
 724         {
 725             if((i+A[j])<col)
 726             {
 727                 k=k+1;
 728                 Out[i]=Out[i]+In[i+A[j]];
 729             }
 730
 731             if((i+A[j])>(col-1))
 732             {
 733                 k=k+1;
 734                 Out[i]=Out[i]+In[col-1];
 735             }
 736         }
 737         if(k>0)
 738         {
 739             Out[i]=Out[i]/k;
 740         }
 741     }
 742     for (i=0;i<col;i++)
 743     {
 744         In[i]=Out[i];
 745     }
 746
 747
 748     free(Out);
 749 }
 750
 751 void Norm1(double *In, int InLen)
 752 {
 753     double MaxValue;
 754     int i;
 755     double *Out;
 756     Out=(double*)malloc(InLen*sizeof(double));
 757
 758     MaxValue=In[0];
 759     for (i=1;i<InLen;i++)
 760     {
 761         if(In[i]>MaxValue)
 762             MaxValue=In[i];
 763     }
 764
 765     for (i=0;i<InLen;i++)
 766     {
 767         Out[i]=In[i]-MaxValue;
 768     }
 769
 770     for (i=0;i<InLen;i++)
 771     {
 772         In[i]=Out[i];
 773     }
 774
 775     free(Out);
 776 }
 777
 778 void Smooth(double *In, int InLen,int smoothLen)
 779 {
 780     double sum;
 781     int i,j,nn,n,count;
 782     double *Out;
 783     Out=(double*)malloc(InLen*sizeof(double));
 784     nn=InLen;
 785     n=(smoothLen-1)/2;
 786     for (i=0;i<nn;i++)
 787     {
 788         sum=0;
 789         count=0;
 790         for (j=0;j<(n+1);j++)
 791         {
 792             if ((i-j)>-1)
 793             {
 794                 sum=sum+In[i-j];
 795                 count=count+1;
 796             }
 797         }
 798
 799         for (j=1;j<(n+1);j++)
 800         {
 801             if ((i+j)<nn)
 802             {
 803                 sum=sum+In[i+j];
 804                 count=count+1;
 805             }
 806         }
 807         Out[i]=sum/count;
 808     }
 809     for (i=0;i<InLen;i++)
 810         In[i]=Out[i];
 811
 812     free(Out);
 813 }
 814
 815
 816 void FindPeaks(double *In, int InLen,double *Out1,double *Out2, int db, int db2, int db3)
 817 {
 818     int i,lastout;
 819     for (i=0;i<InLen;i++)
 820     {
 821         Out1[i]=0;
 822         Out2[1]=0;
 823     }
 824
 825     for (i=20;i<(InLen-20-1);i++)
 826     {
 827         if( /**/ ((In[i]>(db2+In[i-6]))||(In[i]>(db2+In[i+6]))
 828                   ||(In[i]>(db3+In[i+20]))||(In[i]>(db3+In[i-20])))
 829             /*&&(In[i]>db)*/&&(In[i]>In[i+3])&&(In[i]>In[i-3])
 830             &&(In[i]>In[i+2])&&(In[i]>In[i-2])
 831             &&(In[i]>In[i+1])&&(In[i]>In[i-1]))
 832         {
 833             Out1[i]=In[i];
 834             Out2[i]=1;
 835         }
 836
 837     }
 838
 839     lastout=1;
 840     for(i=0;i<InLen;i++)
 841     {
 842
 843         if(Out2[i]==1)
 844         {
 845             if((i-lastout)<5)
 846             {
 847                 if(Out1[i]>Out1[lastout])
 848                 {
 849                     Out2[lastout]=0;
 850                     Out1[lastout]=0;
 851                     lastout=i;
 852                 }
 853                 else
 854                 {
 855                     Out2[i]=0;
 856                     Out1[i]=0;
 857                 }
 858
 859             }
 860             else
 861             {
 862                 lastout=i;
 863             }
 864         }
 865
 866     }
 867
 868 }
 869
 870
 871 void ConFrom1050To960(double *In, double *out, int InputLen)
 872 {
 873     int i,j;
 874
 875     for(i=0;i<960;i++)
 876     {
 877         for (j=0;j<InputLen;j++)
 878         {
 879             out[i+j*960]=In[i+j*1050];
 880
 881         }
 882     }
 883
 884
 885 }
 886
 887 void Move( double *InputArray, int InputLen,int m)
 888 {
 889     int i;
 890     double *OutArray;
 891
 892     OutArray=(double *)malloc(InputLen*sizeof(double));
 893     for (i=0;i<InputLen;i++)
 894         OutArray[i]=0;
 895
 896     for (i=0;i<InputLen;i++)
 897     {  if(((i+m)>-1)&&((i+m)<InputLen))
 898             OutArray[i+m]=InputArray[i];
 899     }
 900
 901     for (i=0;i<InputLen;i++)
 902     {
 903         InputArray[i]=OutArray[i];
 904     }
 905
 906     free(OutArray);
 907 }
 908
 909
 910 double SumArray( double *InputArray, int InputHLen, int InputVLen)
 911 {
 912     int i;
 913     int j;
 914     double sum;
 915     int count;
 916     count=0;
 917     sum=0;
 918     for (j=0;j<InputHLen;j++)
 919     {
 920         for (i=0;i<InputVLen;i++)
 921         {
 922             count=count+1;
 923             sum=sum+InputArray[i+j*InputVLen];
 924
 925         }
 926     }
 927     return sum;
 928 }
 929
 930 double Sum( double *InputArray, int InputHLen)
 931 {
 932     int i;
 933     double sum;
 934     int count;
 935     count=0;
 936     sum=0;
 937     for (i=0;i<InputHLen;i++)
 938     {
 939         count=count+1;
 940         sum=sum+InputArray[i];
 941
 942     }
 943     return sum;
 944 }
 945
 946 void MeanV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
 947 {
 948     int i;
 949     int j;
 950     double sum;
 951     for (i=0;i<InputVLen;i++)
 952     {
 953         sum=0;
 954         for (j=0;j<InputHLen;j++)
 955         {
 956
 957             sum=sum+InputArray[i+j*InputVLen];
 958
 959         }
 960         OutArray[i]=sum/InputHLen;
 961     }
 962
 963 }
 964
 965 void SumV( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
 966 {
 967     int i;
 968     int j;
 969     double sum;
 970
 971     for (j=0;j<InputHLen;j++)
 972     {
 973         sum=0;
 974         for (i=0;i<InputVLen;i++)
 975         {
 976
 977             sum=sum+InputArray[i+j*InputVLen];
 978
 979         }
 980         OutArray[j]=sum;
 981     }
 982
 983 }
 984
 985
 986
 987 void SumV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
 988 {
 989     int i;
 990     int j;
 991     double sum;
 992     for (i=0;i<InputVLen;i++)
 993     {
 994         sum=0;
 995         for (j=0;j<InputHLen;j++)
 996         {
 997
 998             sum=sum+InputArray[i+j*InputVLen];
 999
1000         }
1001         OutArray[i]=sum;
1002     }
1003
1004 }
1005
1006 void MaxV( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
1007 {
1008     int i;
1009     int j;
1010     double MaxVal;
1011
1012     for (j=0;j<InputHLen;j++)
1013     {
1014         MaxVal=InputArray[j*InputVLen];
1015         for (i=0;i<InputVLen;i++)
1016         {
1017             if(InputArray[i+j*InputVLen]>MaxVal)
1018             {
1019                 MaxVal=InputArray[i+j*InputVLen];
1020             }
1021
1022         }
1023         OutArray[j]=MaxVal;
1024     }
1025
1026 }
1027
1028 void MaxV2( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
1029 {
1030     int i;
1031     int j;
1032     double MaxVal;
1033     for (i=0;i<InputVLen;i++)
1034     {
1035         MaxVal=InputArray[i];
1036         for (j=0;j<InputHLen;j++)
1037         {
1038             if(InputArray[i+j*InputVLen]>MaxVal)
1039             {
1040                 MaxVal=InputArray[i+j*InputVLen];
1041             }
1042
1043         }
1044         OutArray[i]=MaxVal;
1045     }
1046
1047 }
1048
1049
1050
1051 void MinArray( double *InputArray, int InputHLen, int InputVLen, double MinValue)
1052 {
1053     int i;
1054     int j;
1055
1056     for (i=0;i<InputVLen;i++)
1057     {
1058         for (j=0;j<InputHLen;j++)
1059         {
1060             if(InputArray[i+j*InputVLen]<MinValue)
1061                 InputArray[i+j*InputVLen]=MinValue;
1062
1063         }
1064
1065     }
1066
1067 }
1068
1069
1070 void MaxArray( double *InputArray, int InputHLen, int InputVLen, double MaxValue)
1071 {
1072     int i;
1073     int j;
1074
1075     for (i=0;i<InputVLen;i++)
1076     {
1077         for (j=0;j<InputHLen;j++)
1078         {
1079             if(InputArray[i+j*InputVLen]>MaxValue)
1080                 InputArray[i+j*InputVLen]=MaxValue;
1081
1082         }
1083
1084     }
1085
1086 }
1087
1088 double  GetMaxValue( double *InputArray, int InputHLen, int InputVLen)
1089 {
1090     int i;
1091     int j;
1092
1093     double MaxValue;
1094     MaxValue=InputArray[0];
1095     for (i=0;i<InputVLen;i++)
1096     {
1097         for (j=0;j<InputHLen;j++)
1098         {
1099             if(InputArray[i*InputHLen+j]>MaxValue)
1100                 MaxValue=InputArray[i*InputHLen+j];
1101
1102         }
1103
1104     }
1105
1106     return MaxValue;
1107 }
1108
1109 void RemoveNoise( double *InputArray, int InputHLen, int InputVLen)
1110 {
1111     int i;
1112     int j;
1113
1114     for (i=0;i<InputVLen;i++)
1115     {
1116         for (j=0;j<InputHLen;j++)
1117         {
1118
1119             InputArray[i+j*InputVLen]=InputArray[i+j*InputVLen]-EualCurve960[i];
1120
1121         }
1122
1123     }
1124
1125 }
1126 double MeanArray( double *InputArray, int InputHLen, int InputVLen)
1127 {
1128     int i;
1129     int j;
1130     double sum;
1131     int count;
1132     count=0;
1133     sum=0;
1134     for (j=0;j<InputHLen;j++)
1135     {
1136         for (i=0;i<InputVLen;i++)
1137         {
1138             count=count+1;
1139             sum=sum+InputArray[i+j*InputVLen];
1140
1141         }
1142     }
1143     return sum/count;
1144 }
1145 void Mydiff( double *InputArray, int InputHLen, int InputVLen,int n)
1146 {
1147     int i;
1148     int j;
1149     double * OutArray;
1150
1151     OutArray=(double*)malloc(InputHLen*InputVLen*sizeof(double));
1152
1153     for (i=0;i<InputVLen;i++)
1154     {
1155         for (j=n;j<InputHLen;j++)
1156         {
1157             OutArray[i+j*InputVLen]=InputArray[i+j*InputVLen]-InputArray[i+(j-n)*InputVLen];
1158
1159         }
1160     }
1161
1162     for (i=0;i<InputVLen;i++)
1163     {
1164         for (j=n;j<InputHLen;j++)
1165         {
1166             InputArray[i+j*InputVLen]=OutArray[i+j*InputVLen];
1167
1168         }
1169     }
1170
1171     for (i=0;i<InputVLen;i++)
1172     {
1173         for (j=0;j<n;j++)
1174         {
1175             InputArray[i+j*InputVLen]=0;
1176
1177         }
1178     }
1179
1180     free(OutArray);
1181 }
1182
1183 void PeakDetect(double *In, int InLen)
1184 {
1185     int i,j;
1186     double *Out1;
1187
1188     Out1=(double*)malloc(InLen*sizeof(double));
1189     for (i=0;i<InLen;i++)
1190     {
1191         Out1[i]=0;
1192     }
1193
1194
1195
1196     for (i=2;i<(InLen-3);i++)
1197     {
1198         if( (In[i]>In[i+2])&&(In[i]>In[i-2])
1199             &&(In[i]>In[i+1])&&(In[i]>In[i-1]))
1200         {
1201             Out1[i]=In[i];
1202         }
1203
1204     }
1205
1206     for(i=0;i<InLen;i++)
1207     {
1208
1209         In[i]=Out1[i];
1210     }
1211
1212     free(Out1);
1213 }
1214 void MeanV( double *InputArray, int InputHLen, int InputVLen, double *OutArray)
1215 {
1216     int i;
1217     int j;
1218     double sum;
1219
1220     for (j=0;j<InputHLen;j++)
1221     {
1222         sum=0;
1223         for (i=0;i<InputVLen;i++)
1224         {
1225
1226             sum=sum+InputArray[i+j*InputVLen];
1227
1228         }
1229         OutArray[j]=sum/InputVLen;
1230     }
1231
1232 }
1233 void Edetect(double *InputArray, int InputHLen, int InputVLen, double MinT, double db1,double *OutOne)
1234 {
1235     int i;
1236     int j;
1237     double MaxValue;
1238
1239 //    printf(" Starting Energy Onset Detection.. %f\n",db1);
1240     RemoveNoise(InputArray, InputHLen, InputVLen);
1241
1242
1243     MaxValue=GetMaxValue(InputArray,InputHLen,InputVLen);
1244
1245     for (i=0;i<InputVLen;i++)
1246     {
1247         for (j=0;j<InputHLen;j++)
1248         {
1249             InputArray[i*InputHLen+j]=InputArray[i*InputHLen+j]-MaxValue;
1250
1251         }
1252
1253     }
1254
1255     MinArray(InputArray, InputHLen, InputVLen, -100);
1256     Mydiff(InputArray, InputHLen, InputVLen,3);
1257     MinArray(InputArray, InputHLen, InputVLen, MinT);
1258
1259     for (i=0;i<InputVLen;i++)
1260     {
1261         for (j=0;j<InputHLen;j++)
1262         {
1263             InputArray[i*InputHLen+j]=InputArray[i*InputHLen+j]-MinT;
1264
1265         }
1266
1267     }
1268
1269     MeanV(InputArray,InputHLen,InputVLen,OutOne);
1270     Smooth(OutOne, InputHLen,3);
1271     Smooth(OutOne, InputHLen,3);
1272     Move(OutOne,InputHLen,-2);
1273     PeakDetect(OutOne,InputHLen);
1274     MinArray(OutOne, InputHLen,1, db1);
1275
1276     for (j=0;j<InputHLen;j++)
1277     {
1278         OutOne[j]=OutOne[j]-db1;
1279
1280     }
1281 }
1282
1283
1284
1285 void OnsetDetection2(double *In,int InputLen,double *OutOne,double a,double b)
1286 {
1287     int mseconds;
1288     double *Input;
1289
1290
1291     mseconds=InputLen;
1292
1293     Input=(double *)malloc(mseconds*960*sizeof(double));
1294
1295     ConFrom1050To960(In,Input,InputLen);
1296
1297
1298
1299
1300     if(a>0)
1301     {
1302         Edetect(Input,mseconds,960, a,b,OutOne);
1303     }
1304
1305
1306     free(Input);
1307
1308 }
1309
1310 void PitchEstimation(double *In, int InLen, double *OutArray,double *OutArray2)
1311 {
1312     double *xx,*x,*y,*y1,*PeakPitch1, *PeakPitch2,*PeakInput1, *PeakInput2;
1313     double *out,*outValue;
1314     double *output,*output1;
1315     double notefloat,hh0,hh1,hh28;
1316     double outM12[12];
1317     int *outc;
1318     int *yI;
1319     double temp;
1320     int i,j,sumI;
1321     int Len;
1322     int NN,NN2;
1323     int count;
1324     double Th;
1325
1326     Len=1050;
1327     xx=(double*)malloc(Len*sizeof(double));
1328     x=(double*)malloc(Len*sizeof(double));
1329     y=(double*)malloc(Len*sizeof(double));
1330     y1=(double*)malloc(Len*sizeof(double));
1331     PeakPitch1=(double*)malloc(Len*sizeof(double));
1332     PeakPitch2=(double*)malloc(Len*sizeof(double));
1333     PeakInput1=(double*)malloc(Len*sizeof(double));
1334     PeakInput2=(double*)malloc(Len*sizeof(double));
1335     out=(double*)malloc(Len*sizeof(double));
1336     outValue=(double*)malloc(Len*sizeof(double));
1337     output=(double*)malloc(112*sizeof(double));
1338     output1=(double*)malloc(112*sizeof(double));
1339     outc=(int*)malloc(112*sizeof(int));
1340 // yI=(double*)malloc(12*sizeof(double));
1341
1342
1343     for (i=0;i<Len;i++)
1344     {
1345         x[i]=In[i];
1346     }
1347
1348     for (i=0;i<Len;i++)
1349     {
1350         y1[i]=x[i];
1351     }
1352
1353     ConToPitch1250(y1,Len);
1354
1355     for (i=0;i<Len;i++)
1356     {
1357         y[i]=y1[i];
1358     }
1359
1360     Smooth(y,Len,30);
1361
1362     for (i=0;i<Len;i++)
1363     {
1364         y1[i]=y1[i]-y[i];
1365     }
1366
1367     for (i=0;i<Len;i++)
1368     {
1369         y1[i]=y1[i]+20;
1370     }
1371
1372     temp=0;
1373     for (i=0;i<Len;i++)
1374     {
1375         temp=temp+x[i];
1376     }
1377     temp=temp/Len;
1378     for (i=0;i<Len;i++)
1379     {
1380         y[i]=x[i]-temp;
1381     }
1382
1383
1384     for (i=0;i<Len;i++)
1385     {
1386         PeakPitch2[i]=0;
1387         PeakPitch1[i]=0;
1388         PeakInput1[i]=0;
1389         PeakInput2[i]=0;
1390     }
1391     FindPeaks(y1, Len,PeakPitch1,PeakPitch2, 0, -1000, -1000);
1392     FindPeaks(y, Len,PeakInput1,PeakInput2, 0, 6, 15);
1393
1394
1395
1396     sumI=0;
1397     for (i=0;i<Len;i++)
1398     {
1399         sumI=sumI+PeakPitch2[i];
1400     }
1401
1402
1403     if (sumI>12)
1404     {
1405         FindMaxN(PeakPitch1,Len,12);
1406
1407         for (i=0;i<Len;i++)
1408         {
1409             if(PeakPitch1[i]==0)
1410             {
1411                 PeakPitch2[i]=0;
1412             }
1413         }
1414
1415     }
1416
1417     for (i=0;i<Len;i++)
1418     {
1419         out[i]=0;
1420         outValue[i]=0;
1421     }
1422
1423     for (i=0;i<(Len-300);i++)
1424     {
1425         if(PeakPitch2[i]==1)
1426
1427         {
1428             if (
1429                 ((SumF(PeakInput2,i-4,i+4)>0)&&(SumF(PeakInput2,i+120-4,i+120+4)>0))
1430                 ||((SumF(PeakInput2,i-4,i+4)>0)&&(SumF(PeakInput2,i+190-4,i+190+4)>0))
1431                 ||((SumF(PeakInput2,i+190-4,i+190+4)>0)&&(SumF(PeakInput2,i+120-4,i+120+4)>0))
1432                 )
1433             {
1434                 out[i]=1;
1435                 outValue[i]=y1[i];
1436
1437             }
1438         }
1439     }
1440
1441     for (i=0;i<112;i++)
1442     {
1443         output[i]=0;
1444         outc[i]=0;
1445     }
1446
1447
1448
1449     for (i=0;i<Len;i++)
1450     {
1451         if(out[i]==1)
1452         {
1453             output[20+round10(i+1)-1]=1;
1454             outc[20+round10(i+1)-1]=i;
1455         }
1456     }
1457
1458
1459     for (i=0;i<112;i++)
1460     {
1461         output1[i]=output[i];
1462     }
1463
1464
1465
1466     for (i=20;i<(112-28);i++)
1467     {
1468         if((output[i]>0)&&(SumF(PeakInput2,outc[i]-5,outc[i]+5)==0))
1469         {
1470             output1[i]=0;
1471         }
1472     }
1473
1474
1475     for (i=0;i<112;i++)
1476     {
1477         OutArray[i]=0;
1478         OutArray2[i]=0;
1479
1480     }
1481
1482     Th=30;
1483     for(i=20;i<105;i++)
1484     {
1485         if(output1[i]==1)
1486         {
1487             OutArray[i]=outc[i]+200+2;
1488             OutArray2[i]=y[outc[i]];
1489
1490         }
1491
1492     }
1493
1494     free(xx); // xx=(double*)malloc(Len*sizeof(double));
1495     free(x); // x=(double*)malloc(Len*sizeof(double));
1496     free(y); // y=(double*)malloc(Len*sizeof(double));
1497     free(y1);  // y1=(double*)malloc(Len*sizeof(double));
1498     free(PeakPitch1); //=(double*)malloc(Len*sizeof(double));
1499     free(PeakPitch2); //=(double*)malloc(Len*sizeof(double));
1500     free(PeakInput1); //=(double*)malloc(Len*sizeof(double));
1501     free(PeakInput2); //=(double*)malloc(Len*sizeof(double));
1502     free(out); //=(double*)malloc(Len*sizeof(double));
1503     free(outValue); //=(double*)malloc(Len*sizeof(double));
1504     free(output); //=(double*)malloc(112*sizeof(double));
1505     free(output1); //=(double*)malloc(112*sizeof(double));
1506     free(outc); //=(double*)malloc(112*sizeof(int));
1507 //free(yI); //=(double*)malloc(12*sizeof(int));
1508 //  printf(" end free \n");
1509 }
1510
1511 void DoMultiPitch(double *In, int RLen,int CLen, double *Out1, double *Out2)
1512 {
1513
1514     int i, j;
1515     double *sum1,*mean1;
1516     double MaxV;
1517     double *OutArray1, *OutArray2,*tempArray;
1518
1519     OutArray1=(double *)malloc(112*sizeof(double));
1520     OutArray2=(double *)malloc(112*sizeof(double));
1521     tempArray=(double *)malloc(RLen*sizeof(double));
1522
1523     sum1=(double*)malloc(CLen*sizeof(double));
1524     mean1=(double*)malloc(CLen*sizeof(double));
1525
1526     for (j=0;j<CLen;j++)
1527     {
1528         sum1[j]=0;
1529         for (i=0;i<RLen;i++)
1530         {
1531             sum1[j]=sum1[j]+In[j*RLen+i];
1532         }
1533
1534         mean1[j]=sum1[j]/CLen;
1535     }
1536     MaxV=mean1[0];
1537     for (j=0;j<CLen;j++)
1538     {
1539         if(mean1[j]>MaxV)
1540         {
1541             MaxV=mean1[j];
1542         }
1543     }
1544
1545     for (j=0;j<CLen;j++)
1546     {
1547         mean1[j]=mean1[j]-MaxV;
1548     }
1549
1550
1551     for (j=0;j<CLen;j++)
1552     {
1553
1554         for (i=0;i<112;i++)
1555         {
1556
1557             OutArray1[i]=0;
1558             OutArray2[i]=0;;
1559
1560         }
1561         MaxV=In[j*RLen];
1562         for(i=0;i<RLen;i++)
1563         {
1564             tempArray[i]=In[j*RLen+i];
1565             if(tempArray[i]>MaxV)
1566                 MaxV=tempArray[i];
1567         }
1568
1569         if(mean1[j]>-55)
1570         {
1571
1572             PitchEstimation(tempArray,RLen,OutArray1,OutArray2);
1573
1574             for(i=0;i<112;i++)
1575             {
1576                 if(OutArray1[i]>0)
1577                 {
1578                     if((MaxV-tempArray[(int)OutArray1[i]-201-1])>40)
1579                     {
1580                         OutArray1[i]=0;
1581                         OutArray2[i]=0;
1582                     }
1583
1584                 }
1585             }
1586
1587         }
1588
1589         for (i=0;i<112;i++)
1590         {
1591
1592             Out1[j*112+i]=OutArray1[i];
1593             Out2[j*112+i]=OutArray2[i];
1594
1595         }
1596
1597     }
1598
1599     free(OutArray1);
1600     free(OutArray2);
1601     free(tempArray);
1602     free(sum1);
1603     free(mean1);
1604 }
1605
1606
1607 int OnsetToArray(double *In, int Len, double *OutStart,double *OutEnd)
1608 {
1609     int count,i;
1610
1611     count=0;
1612
1613     for (i=0;i<Len;i++)
1614     {
1615         if(In[i]>0)
1616         {
1617             OutStart[count]=i+1;
1618             if(count>0)
1619             {
1620                 OutEnd[count-1]=i+1;
1621             }
1622             count=count+1;
1623         }
1624     }
1625     if (count>0)
1626     {
1627         OutEnd[count-1]=Len;
1628     }
1629     return count;
1630
1631 }
1632 void dbfunction( double *InputArray, int InputHLen, int InputVLen,double *OutArray)
1633 {
1634     int i;
1635     int j;
1636     double temp;
1637
1638     for (i=0;i<InputVLen;i++)
1639     {
1640         for (j=0;j<InputHLen;j++)
1641         {
1642             OutArray[i*InputHLen+j]=20*log10(InputArray[i*InputHLen+j]);
1643
1644         }
1645
1646     }
1647 }
1648
1649 void Transcribe(int Len,int inputLen,double *SoundIn,double *out,double *outArray2,double *outArray3,double SampleRate)
1650 {
1651     int OnsetN;
1652     int i,j,k;
1653     int count;
1654     int index;
1655     double *OutStart,*OutEnd;
1656     int start,endd,startb=1,start2,endd2;
1657     double *A1,*A2,*A3,*A4,*A5,*A6,*D,*D2;
1658     double *A6A;
1659     double *out2, *PitchOut1,*PitchOut2,*PitchOut3;
1660     double sum,maxV,maxVal;
1661     double *tempArray;
1662     double temp;
1663     double p;
1664     double M1,M2;
1665     double *In;
1666     int Len2;
1667     double *dbs,*ss,*dbs1,*jj;
1668     int TempInt;
1669
1670
1671     A1=(double *)malloc(112*sizeof(double));
1672     A2=(double *)malloc(112*sizeof(double));
1673     A3=(double *)malloc(112*sizeof(double));
1674     A4=(double *)malloc(112*sizeof(double));
1675     A5=(double *)malloc(112*sizeof(double));
1676     A6=(double *)malloc(112*sizeof(double));
1677     D=(double *)malloc(112*sizeof(double));
1678     D2=(double *)malloc(112*sizeof(double));
1679     PitchOut1=(double *)malloc(112*Len*sizeof(double));
1680     PitchOut2=(double *)malloc(112*Len*sizeof(double));
1681     PitchOut3=(double *)malloc(112*Len*sizeof(double));
1682     OutStart=(double *)malloc(Len*sizeof(double));
1683     OutEnd=(double *)malloc(Len*sizeof(double));
1684     tempArray=(double *)malloc(sizeof(double)*Len);
1685     In=(double *)malloc(sizeof(double)*Len);
1686     dbs=(double *)malloc(1050*sizeof(double)*Len);
1687     dbs1=(double *)malloc(210*sizeof(double)*Len);
1688     ss=(double *)malloc(210*sizeof(double)*Len);
1689     jj=(double *)malloc(1050*sizeof(double));
1690
1691
1692
1693
1694     for(k=0;k<1050;k++)
1695     {
1696
1697         jj[k]=k/5.0;
1698
1699     }
1700
1701     sofacomplexMex(SoundIn,ss,inputLen,20,0.5,210,0.03,20,SampleRate);
1702     dbfunction(ss, Len, 210,dbs1);
1703
1704     for(i=0;i<Len;i++)
1705     {
1706         for(k=0;k<1045;k++)
1707         {
1708             TempInt=(int)jj[k];
1709             dbs[k+i*1050]=(jj[k]-TempInt)*dbs1[TempInt+1+i*210]+(TempInt+1-jj[k])*dbs1[TempInt+i*210];
1710
1711         }
1712
1713         for (k=1045;k<1050;k++)
1714         {
1715             dbs[k+i*1050]=dbs[1044+i*1050];
1716         }
1717
1718     }
1719
1720     OnsetDetection2(dbs,Len,In,3,1.2);
1721     for (i=0;i<Len;i++)
1722     {
1723         outArray2[i]=In[i];
1724
1725     }
1726
1727     OnsetN=0;
1728     count=0;
1729     for (i=0;i<Len;i++)
1730     {
1731         if(In[i]>0)
1732         {
1733             OnsetN=OnsetN+1;
1734             count=count+1;
1735         }
1736     }
1737     Len2=count;
1738     out2=(double *)malloc(112*Len2*sizeof(double));
1739     A6A=(double *)malloc(112*Len2*sizeof(double));
1740     OnsetToArray(In,Len,OutStart,OutEnd);
1741     DoMultiPitch(dbs,1050,Len, PitchOut1, PitchOut2);
1742
1743
1744     for (i=0;i<Len;i++)
1745     {
1746         for (j=0;j<112;j++)
1747         {
1748             PitchOut3[i*112+j]=PitchOut1[i*112+j];
1749             if(PitchOut3[i*112+j]>1)
1750                 PitchOut3[i*112+j]=1;
1751         }
1752
1753     }
1754
1755
1756     for (i=0;i<OnsetN;i++)
1757     {
1758         for(j=0;j<112;j++)
1759         {
1760             A1[j]=0;A2[j]=0;A3[j]=0;A4[j]=0;A5[j]=0;A6[j]=0;
1761
1762         }
1763         maxV=0;
1764         start=(int)OutStart[i];
1765         endd=(int)OutEnd[i];
1766         if(i>0)
1767         {
1768             startb=(int)OutStart[i-1];
1769         }
1770
1771         for (j=0;j<112;j++)
1772         {
1773             sum=0;
1774             count=0;
1775             for (k=(start-1);k<endd;k++)
1776             {
1777                 sum=sum+PitchOut3[k*112+j];
1778                 count=count+1;
1779             }
1780
1781             A1[j]=sum;
1782             A6[j]=sum/count;
1783             A6A[i*112+j]=sum/count;
1784
1785         }
1786
1787         for (j=0;j<112;j++)
1788         {
1789             maxVal=PitchOut2[start*112+j];
1790             for (k=(start-1);k<endd;k++)
1791             {
1792                 if(PitchOut2[k*112+j]>maxVal)
1793                 {
1794                     maxVal=PitchOut2[k*112+j];
1795                 }
1796
1797             }
1798
1799             A3[j]=maxVal;
1800
1801         }
1802
1803         for (j=0;j<112;j++)
1804         {
1805             sum=0;
1806             count=0;
1807             for (k=(start-1);k<endd;k++)
1808             {
1809                 if(PitchOut2[k*112+j]>0)
1810                 {
1811                     sum=sum+PitchOut2[k*112+j];
1812                     count=count+1;
1813                 }
1814             }
1815             if(count>0)
1816                 A4[j]=sum/count;
1817             else
1818                 A4[j]=0;
1819         }
1820
1821
1822         for (j=0;j<112;j++)
1823         {
1824             sum=0;
1825             count=0;
1826             for (k=(start-1);k<endd;k++)
1827             {
1828                 if(PitchOut1[k*112+j]>0)
1829                 {
1830                     sum=sum+PitchOut1[k*112+j];
1831                     count=count+1;
1832                 }
1833             }
1834             if(count>0)
1835                 A5[j]=sum/count;
1836             else
1837                 A5[j]=0;
1838         }
1839
1840         maxV=A3[0];
1841         for (j=0;j<112;j++)
1842         {
1843             if(A3[j]>maxV)
1844                 maxV=A3[j];
1845         }
1846
1847         for (j=0;j<112;j++)
1848         {
1849
1850             if(A1[j]>0)
1851             {
1852                 D[j]=A1[j];D2[j]=A1[j];
1853             }
1854
1855             else
1856             {
1857                 D[j]=A1[j];D2[j]=A1[j];
1858             }
1859         }
1860
1861         for (j=0;j<112;j++)
1862         {
1863             if(A1[j]<8)
1864             {
1865                 D[j]=0;D2[j]=0;
1866             }
1867
1868         }
1869
1870         for(j=0;j<112;j++)
1871         {
1872
1873             if ((j>12)&&(D[j]>0)&&(D[j-12]>0))
1874             {
1875                 D[j]=0;  D2[j]=0;
1876                 if((A3[j]>45)&&(A3[j]>(A3[j-12]+3)))
1877                 {
1878                     D[j]=1;
1879                 }
1880             }
1881
1882
1883             if ((j>19)&&(D[j]>0)&&(D[j-19]>0))
1884             {
1885
1886                 D[j]=0;    D2[j]=0;
1887                 if((A3[j]>50))
1888                 {
1889                     D[j]=1;
1890                 }
1891             }
1892
1893             if ((j>24)&&(D[j]>0)&&(D[j-24]>0))
1894             {
1895
1896                 D[j]=0;          D2[j]=0;
1897                 if((A3[j]>50))
1898                 {
1899                     D[j]=1;
1900                 }
1901             }
1902
1903             if ((j>28)&&(D[j]>0)&&(D[j-28]>0))
1904             {
1905
1906                 D[j]=0;           D2[j]=0;
1907                 if((A3[j]>50))
1908                 {
1909                     D[j]=1;
1910                 }
1911             }
1912
1913             if ((j>34)&&(abs(A5[j]-337.0-A5[j-34])<3.0)&&(D[j]>0)&&(D[j-34]>0))
1914             {
1915
1916                 D[j]=0;           D2[j]=0;
1917                 if((A4[j]>25)&&(A3[j]>40)&&(A3[j]>(A3[j-34]-3))&&((A1[j]>8)||(A6[j]>0.8)))
1918                 {
1919                     D[j]=1;
1920                 }
1921             }
1922
1923             if((j>48)&&(j<59)&&(A3[j]<20))
1924             {
1925                 D[j]=0;
1926             }
1927
1928             if((j>58)&&(j<69)&&(A3[j]<28))
1929             {
1930                 D[j]=0;
1931             }
1932
1933
1934             if((j>68)&&(j<79)&&(A3[j]<40))
1935             {
1936                 D[j]=0;
1937             }
1938
1939             if((j>78)&&(A3[j]<50))
1940             {
1941                 D[j]=0;
1942             }
1943
1944             if((j>85)&&(A3[j]<55))
1945             {
1946                 D[j]=0;
1947             }
1948
1949             if((D2[j]>0)&&(A1[j]>15))
1950             {
1951                 D[j]=1;
1952             }
1953             if(i>1)
1954             {
1955
1956                 for (k=(startb-1);k<start;k++)
1957                 {
1958                     tempArray[k-startb+1]=PitchOut3[j+k*112];
1959
1960                 }
1961                 temp=Sum(tempArray,start-startb+1);
1962                 if(((maxV-A3[j])>20)&&(temp>3))
1963                 {
1964                     D[j]=0;
1965                 }
1966
1967             }
1968
1969         }
1970
1971         for(j=0;j<112;j++)
1972         {
1973             out[j+i*112]=D[j];
1974             out2[j+i*112]=D[j];
1975         }
1976     }
1977
1978     for (i=1;i<OnsetN;i++)
1979     {
1980         start2=(int)OutStart[i];
1981         endd2=(int)OutEnd[i];
1982
1983         for (j=0;j<112;j++)
1984         {
1985             sum=0;
1986             count=0;
1987             for (k=(start2-1);k<endd2;k++)
1988             {
1989                 sum=sum+PitchOut3[k*112+j];
1990                 count=count+1;
1991             }
1992
1993             A1[j]=sum;
1994         }
1995
1996         for (j=0;j<112;j++)
1997         {
1998             if((out2[(i-1)*112+j]>0)&&(out[j+i*112]>0))
1999             {
2000                 out[j+i*112]=0;
2001                 sum=0;
2002                 for(k=(start2-1);k<endd2;k++)
2003                 {
2004                     sum=sum+PitchOut1[j+k*112];
2005
2006                 }
2007                 p=sum/A1[j];
2008
2009                 index=(int)(p+0.5)-200;
2010
2011                 if((index>0)&&(i<(OnsetN-1))&&(start2>5))
2012                 {
2013
2014                     M1=dbs[index+(start2-1)*1050];
2015                     for (k=(start2-1);k<(start2+10);k++)
2016                     {
2017                         if(dbs[index+k*1050]>M1)
2018                             M1=dbs[index+k*1050];
2019
2020                     }
2021
2022                     M2=dbs[index+(start2-5-1)*1050];
2023                     for (k=(start2-5-1);k<start2;k++)
2024                     {
2025                         if(dbs[index+k*1050]<M2)
2026                             M2=dbs[index+k*1050];
2027
2028                     }
2029
2030                     if((M1-M2)>10)
2031                     {
2032                         out[j+i*112]=1;
2033                     }
2034                 }
2035             }
2036         }
2037     }
2038
2039     count=0;
2040     for (i=0;i<OnsetN;i++)
2041     {
2042
2043         start=(int)OutStart[i];
2044         endd=(int)OutEnd[i];
2045
2046         for(j=0;j<112;j++)
2047         {
2048             if(out[j+i*112]>0)
2049             {
2050                 outArray3[count*3+0]=j+1-21;//exp((log(2.0))*(j+1-69)/12)*440;
2051                 outArray3[count*3+1]=start*0.01;
2052
2053                 if(i==(OnsetN-1))
2054                 {
2055                     outArray3[count*3+2]=0.01*OutEnd[i];
2056                 }
2057                 else
2058                 {
2059
2060                     for(k=(i+1);k<OnsetN;k++)
2061                     {
2062
2063                         if(k==(OnsetN-1))
2064                         {
2065                             outArray3[count*3+2]=0.01*OutEnd[k];
2066                         }
2067
2068                         if(out[j+k*112]>0)
2069                         {
2070                             outArray3[count*3+2]=0.01*OutStart[k];
2071                             break;
2072                         }
2073
2074                         if(A6A[k*112+j]<0.5)
2075                         {
2076                             outArray3[count*3+2]=0.01*OutStart[k];
2077                             break;
2078
2079                         }
2080
2081                     }
2082
2083                 }
2084
2085                 count=count+1;
2086             }
2087
2088         }
2089
2090     }
2091     outArray3[count*3+0]=0;
2092     outArray3[count*3+1]=0;
2093     outArray3[count*3+2]=0;
2094
2095     free(tempArray);
2096     free(OutStart);
2097     free(OutEnd);
2098     free(A1);
2099     free(A2);
2100     free(A3);
2101     free(A4);
2102     free(A5);
2103     free(A6);
2104     free(A6A);
2105     free(D);
2106     free(D2);
2107     free(out2);
2108     free(PitchOut1);
2109     free(PitchOut2);
2110     free(PitchOut3);
2111     free(In);
2112     free(dbs);
2113     free(dbs1);
2114     free(ss);
2115     free(jj);
2116 }
2117