comparison vibrato.cpp @ 5:5f3c32dc6e17

* Adjust comment syntax to permit Doxygen to generate HTML documentation; add Doxyfile

 //---------------------------------------------------------------------------
-
 
 #include <math.h>
 #include <string.h>
 #include "vibrato.h"
 #include "arrayalloc.h"
 #include "fft.h"
 #include "hssf.h"
 #include "matrix.h"
 #include "splines.h"
 #include "xcomplex.h"
+
+/** \file vibrato.h */
+
 //---------------------------------------------------------------------------
 //method TVo::TVo: default constructor
 TVo::TVo()
 {
 	memset(this, 0, sizeof(TVo));

 	if (fxr) DeAlloc2(fxr);
 	if (fres) DeAlloc2(fres);
 	if (LogASp) DeAlloc2(LogASp);
 }//~TVo
 
-/*
+/**
   method TVo::AllocateL: allocates or reallocates storage space whose size depends on L. This uses an
   external L value for allocation and updates L itself.
 */
 void TVo::AllocateL(int AnL)
 {

   delete[] F0;
   F0=new double[(L+2)*4];
   F0C=&F0[L+2], F0D=&F0[(L+2)*2], A0C=&F0[(L+2)*3];
 }//AllocateL
 
-/*
+/**
   method TVo::AllocateP: allocates or reallocates storage space whose size depends on P, using the
   interal P.
 */
 void TVo::AllocateP()
 {

   Dp=&lp[P+2];
   Kp=(int*)&lp[(P+2)*2];
   if (LogASp) DeAlloc2(LogASp); Allocate2(double, P, M, LogASp);
 }//AllocateP
 
-/*
+/**
   method TVo::AllocatePK: allocates or reallocates storage space whose size depends on both P and K.
 */
 void TVo::AllocatePK()
 {
   if (fxr) DeAlloc2(fxr);

   memset(fxr[0], 0, sizeof(double)*P*(2*K+1));
   if (fres) DeAlloc2(fres);
   Allocate2(double, P, K, fres);
 }//AllocatePK
 
-/*
+/**
   method TVo::GetOldP: returns the number of "equivalent" cycles of the whole duration. Although P-1
   cycles are delineated by lp[P], the parts before lp[0] and after lp[P-1] are also a part of the
   harmonic sinusoid being modeled and therefore should be taken into account when necessary.
 */
 double TVo::GetOldP()
 {
   return P-1+lp[0]/(lp[1]-lp[0])+(L-lp[P-1])/(lp[P-1]-lp[P-2]);
 }//GetOldP
 
-/*
+/**
   methodTVo::LoadFromFileHandle: reads TVo object from a file stream.
 */
 void TVo::LoadFromFileHandle(FILE* file)
 {
   fread(&M, sizeof(int), 1, file);

   fread(Kp, sizeof(int), P, file);
   fread(fxr[0], sizeof(double), P*(2*K+1), file);
   fread(LogASp[0], sizeof(double), P*M, file);
 }//LoadFromFileHandle
 
-/*
+/**
   method TVo::ReAllocateL: reallocates storage space whose size depends on L, and transfer the contents.
   This uses an external L value for allocation but does not update L itself.
 */
 void TVo::ReAllocateL(int newL)
 {

   memcpy(newF0, F0, sizeof(double)*(L+2));
   delete[] F0;
   F0=newF0;
 }//ReAllocateL
 
-/*
+/**
   method TVo::SaveToFile: saves a TVo object to a file.
 
   In: filename: path to the destination file.
 */
 void TVo::SaveToFile(char* filename)

   {
     throw(strcat((char*)"Cannot open file ", filename));
   }
 }//SaveToFile
 
-/*
+/**
   method TVo::SaveToFileHandle: saves a TVo object to an open file stream.
 */
 void TVo::SaveToFileHandle(FILE* file)
 {
   fwrite(&M, sizeof(int), 1, file);

 
 //---------------------------------------------------------------------------
 //functions
 
 
-/*
+/**
   function AnalyzeV: calculates all basic and non-basic descriptors of a vibrato from a harmonic
   sinusoid
 
   In: HS: harmonic sinusoid to compute vibrato representation from
       sps: sampling rate

     }
     V.FXR[2*k-1]/=sumdp, V.FXR[2*k]/=sumdp, V.FRes[k]/=sumdp;
   }
 }//AnalyzeV
 
-/*
+/**
   function copeak: measures the similarity of F0 between frst and fren to a cosine cycle 0~2pi.
 
   In: F0[peakfr[frst]:peakfr[fren]]
       periodinframe: period of the cosine reference, in frames
 

     rfs+=(f-ef0)*s; rff+=(f-ef0)*(f-ef0); rss+=s*s;
   }
   return rfs/sqrt(rff*rss);
 }//copeak
 
-/*
+/**
   function CorrectFS: time-shifts Fourier series so that maximum is reached at 0. This is done by
   finding the actual peak numerically then shifting it to 0.
 
   In: c[2K-1]: Fourier series coefficients, in the order of 0r, 1i, 1r, 2i, 2r, ..., so that the series
         is expanded as c[0]+c[1]sinx+c[2]cosx+c[3]sin2x+c[4]cos2x+...c[2K-2]cos(K-1)x

     double tmp=c[2*k]*cc+c[2*k-1]*ss;
     c[2*k-1]=-c[2*k]*ss+c[2*k-1]*cc; c[2*k]=tmp;
   }
 }//CorrectFS
 
-/*
+/**
   function DeAM: amplitude demodulation based on given segmentation into cycles
 
   In: A1[Fr]: original amplitude
       peakfr[npfr]: cycle boundaries (literally, "frame indices of frequency modulation peaks")
   Out: A2[Fr]: demodulated amplitude

     delete[] fa;
   }
   delete[] frs;
 }//DeAM
 
-/*
+/**
   function DeAM: wrapper function using floating-point cycle boundaries
 
   In: A1[Fr]: original amplitude
       lp[npfr]: cycle boundaries
   Out: A2[Fr]: demodulated amplitude

   for (int i=0; i<npfr; i++) peakfr[i]=ceil(lp[i]);
   DeAM(A2, A1, npfr, peakfr, Fr);
   delete[] peakfr;
 }//DeAM
 
-/*
+/**
   function DeFM: frequency demodulation based on given segmentation into cycles
 
   In: f1[Fr], AA[Fr]: original frequency and partial-independent amplitude
       peakfr[npfr]: cycle boundaries (literally, "frame indices of frequency modulation peaks")
       furthursmoothing: specifies if a second round demodulation is to be performed for more smooth

 
   if (localfrs) delete[] frs;
   if (localf) delete[] f;
 }//DeFM
 
-/*
+/**
   function DeFM: wrapper function using floating-point cycle boundaries
 
   In: f1[Fr], AA[Fr]: original frequency and partial-independent amplitude
       lp[npfr]: cycle boundaries
       furthursmoothing: specifies if a second round demodulation is to be performed for more smooth

   for (int i=0; i<npfr; i++) peakfr[i]=ceil(lp[i]);
   DeFM(f2, f1, AA, npfr, peakfr, Fr, fct, fcount, frs, f, furthersmoothing);
   delete[] peakfr;
 }//DeFM
 
-/*
+/**
   function FindPeaks: find modulation peaks of signal F0[] roughly periodical at $periodinframe
 
   In: F0[Fr]: modulated signal
       periodinframe: reference modulation period
   Out: npfr, peakfr[npfr]: modulation peaks

   npfr=pen-pst;
   memmove(peakfr, &peakfr[pst], sizeof(int)*npfr); //*/
   if (localpeaky) delete[] peaky;
 }//FindPeaks
 
-/*
+/**
   function FS: Fourier series decomposition
 
   In: data[frst:fren]: signal to decompose
       period: period of Fourier series decomposition
       shift: amount of original shift of Fourier components (from frst to frst-shift)

   }
   delete[] rec;
   delete[] res;
 }//FS
 
-/*
+/**
   function FS_QR: Fourier series decomposition with QR orthogonalization. Since the Fourier series is
   applied on finite-length discrate signal, the Fourier components are no longer orthogonal to each
   other. A decreasing residue can be guaranteed by applying QR (or any other) orthogonalization process
   to the Fourier components before decomposition.
 

   /* debug only
   delete[] res; //*/
   DeAlloc2(A); DeAlloc2(Q); DeAlloc2(R);
 }//FS_QR
 
-/*
+/**
   function InterpolateV: adjusts modulation rate to $rate times the current value. Since TVo is based on
   individual cycles, this operation involves finding new cycle boundaries and recomputing other single-
   cycle descriptors by interpolation. This is used for time stretching and cycle rate adjustment.
 
   In: V: a TVo object to adjust

 
 //vibrato rate boundaries, in Hz
 #define MAXMOD 15.0
 #define MINMOD 3.0
 
-/*
+/**
   function RateAndReg: evaluates modulation rate and regularity
 
   In: data[frst:fren]: modulated signal, time measured in frames
       padrate: padding rate used for inverse FFT
       sps: sampling frequency

   regularity=(maxlf-0.25*b_*b_/a_)/lf[0]*(fren-frst)/(fren-frst-period);
 
   delete[] lf;
 }//RateAndReg
 
-/*
+/**
   function RegularizeV: synthesize a regular vibrato from the basic descriptors.
 
   In: V: a TVo object hosting vibrato descriptors
       sps: sampling rate
       h: hop size

   }
 
   delete[] fxr;
 }//RegularizeV
 
-/*
+/**
   function QIE: computes extremum using quadratic interpolation
 
   In: y[-1:1]: three points to interpolate from. It is assumed y[0] is larger (or smaller) than both
         y[-1] and y[1].
 

 {
   double a=0.5*(y[1]+y[-1])-y[0], b=0.5*(y[1]-y[-1]);
   return y[0]-0.25*b*b/a;
 }//QIE
 
-/*
+/**
   function QIE: computes extremum using quadratic interpolation
 
   In: y[-1:1]: three points to interpolate from. It is assumed y[0] is larger (or smaller) than both
         y[-1] and y[1].
   Out: x: the argument value that yields extremum of y(x)

   double a=0.5*(y[1]+y[-1])-y[0], b=0.5*(y[1]-y[-1]);
   x=-0.5*b/a;
   return y[0]-0.25*b*b/a;
 }//QIE
 
-/*
+/**
   function S_F: original source-filter estimation used in AES124.
 
   In: afres: filter response resolution
       Partials[M][Fr]: HS partials
       A0C[Fr]: partial-independent amplitude carrier

       else LogAS[m]=0;
     }
   return 0;
 }//S_F
 
-/*
+/**
   function S_F_SV: slow-variation source-filter estimation used in AES126, adapted from TSF to TVo.
 
   In: afres: filter response resolution
       Partials[M][Fr]: HS partials
       A0C[Fr]: partial-independent amplitude carrier

 
   DeAlloc2(loga); DeAlloc2(f); DeAlloc2(h);
   return 0;
 }//S_F_SV
 
-/*
+/**
   function SynthesizeV: synthesizes a harmonic sinusoid from vibrato descriptors
 
   In: V: a TVo object hosting vibrato descriptors
       sps: sampling rate
       UseK: maximal number of Fourier series components to use to construct frequency modulator