qm-dsp  1.8
Chromagram.cpp
Go to the documentation of this file.
1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
2 
3 /*
4  QM DSP Library
5 
6  Centre for Digital Music, Queen Mary, University of London.
7  This file 2005-2006 Christian Landone.
8 
9  This program is free software; you can redistribute it and/or
10  modify it under the terms of the GNU General Public License as
11  published by the Free Software Foundation; either version 2 of the
12  License, or (at your option) any later version. See the file
13  COPYING included with this distribution for more information.
14 */
15 
16 #include <iostream>
17 #include <cmath>
18 #include "maths/MathUtilities.h"
19 #include "Chromagram.h"
20 
21 //----------------------------------------------------------------------------
22 
24  m_skGenerated(false)
25 {
26  initialise( Config );
27 }
28 
30 {
31  m_FMin = Config.min; // min freq
32  m_FMax = Config.max; // max freq
33  m_BPO = Config.BPO; // bins per octave
34  m_normalise = Config.normalise; // if frame normalisation is required
35 
36  // No. of constant Q bins
37  m_uK = ( unsigned int ) ceil( m_BPO * log(m_FMax/m_FMin)/log(2.0));
38 
39  // Create array for chroma result
40  m_chromadata = new double[ m_BPO ];
41 
42  // Create Config Structure for ConstantQ operator
43  CQConfig ConstantQConfig;
44 
45  // Populate CQ config structure with parameters
46  // inherited from the Chroma config
47  ConstantQConfig.FS = Config.FS;
48  ConstantQConfig.min = m_FMin;
49  ConstantQConfig.max = m_FMax;
50  ConstantQConfig.BPO = m_BPO;
51  ConstantQConfig.CQThresh = Config.CQThresh;
52 
53  // Initialise ConstantQ operator
54  m_ConstantQ = new ConstantQ( ConstantQConfig );
55 
56  // Initialise working arrays
59 
60  // Initialise FFT object
61  m_FFT = new FFTReal(m_frameSize);
62 
63  m_FFTRe = new double[ m_frameSize ];
64  m_FFTIm = new double[ m_frameSize ];
65  m_CQRe = new double[ m_uK ];
66  m_CQIm = new double[ m_uK ];
67 
68  m_window = 0;
69  m_windowbuf = 0;
70 
71  return 1;
72 }
73 
75 {
76  deInitialise();
77 }
78 
80 {
81  delete[] m_windowbuf;
82  delete m_window;
83 
84  delete [] m_chromadata;
85 
86  delete m_FFT;
87 
88  delete m_ConstantQ;
89 
90  delete [] m_FFTRe;
91  delete [] m_FFTIm;
92  delete [] m_CQRe;
93  delete [] m_CQIm;
94  return 1;
95 }
96 
97 //----------------------------------------------------------------------------------
98 // returns the absolute value of complex number xx + i*yy
99 double Chromagram::kabs(double xx, double yy)
100 {
101  double ab = sqrt(xx*xx + yy*yy);
102  return(ab);
103 }
104 //-----------------------------------------------------------------------------------
105 
106 
107 void Chromagram::unityNormalise(double *src)
108 {
109  double min, max;
110 
111  double val = 0;
112 
113  MathUtilities::getFrameMinMax( src, m_BPO, & min, &max );
114 
115  for( unsigned int i = 0; i < m_BPO; i++ )
116  {
117  val = src[ i ] / max;
118 
119  src[ i ] = val;
120  }
121 }
122 
123 
124 double* Chromagram::process( const double *data )
125 {
126  if (!m_skGenerated) {
127  // Generate CQ Kernel
129  m_skGenerated = true;
130  }
131 
132  if (!m_window) {
134  m_windowbuf = new double[m_frameSize];
135  }
136 
137  for (int i = 0; i < m_frameSize; ++i) {
138  m_windowbuf[i] = data[i];
139  }
141 
143 
144  return process(m_FFTRe, m_FFTIm);
145 }
146 
147 double* Chromagram::process( const double *real, const double *imag )
148 {
149  if (!m_skGenerated) {
150  // Generate CQ Kernel
152  m_skGenerated = true;
153  }
154 
155  // initialise chromadata to 0
156  for (unsigned i = 0; i < m_BPO; i++) m_chromadata[i] = 0;
157 
158  double cmax = 0.0;
159  double cval = 0;
160  // Calculate ConstantQ frame
161  m_ConstantQ->process( real, imag, m_CQRe, m_CQIm );
162 
163  // add each octave of cq data into Chromagram
164  const unsigned octaves = (int)floor(double( m_uK/m_BPO))-1;
165  for (unsigned octave = 0; octave <= octaves; octave++)
166  {
167  unsigned firstBin = octave*m_BPO;
168  for (unsigned i = 0; i < m_BPO; i++)
169  {
170  m_chromadata[i] += kabs( m_CQRe[ firstBin + i ], m_CQIm[ firstBin + i ]);
171  }
172  }
173 
175 
176  return m_chromadata;
177 }
178 
179 
double CQThresh
Definition: Chromagram.h:28
double min
Definition: Chromagram.h:25
int deInitialise()
Definition: Chromagram.cpp:79
unsigned int m_BPO
Definition: Chromagram.h:61
unsigned int BPO
Definition: Chromagram.h:27
FFTReal * m_FFT
Definition: Chromagram.h:69
unsigned int m_frameSize
Definition: Chromagram.h:66
unsigned int m_uK
Definition: Chromagram.h:62
unsigned int FS
Definition: Chromagram.h:24
double * process(const double *data)
Definition: Chromagram.cpp:124
double max
Definition: Chromagram.h:26
unsigned int FS
Definition: ConstantQ.h:24
Chromagram(ChromaConfig Config)
Definition: Chromagram.cpp:23
MathUtilities::NormaliseType normalise
Definition: Chromagram.h:29
void process(const double *FFTRe, const double *FFTIm, double *CQRe, double *CQIm)
Definition: ConstantQ.cpp:317
bool m_skGenerated
Definition: Chromagram.h:77
double CQThresh
Definition: ConstantQ.h:28
MathUtilities::NormaliseType m_normalise
Definition: Chromagram.h:64
double * m_CQRe
Definition: Chromagram.h:74
void forward(const double *realIn, double *realOut, double *imagOut)
Carry out a forward real-to-complex transform of size nsamples, where nsamples is the value provided ...
Definition: FFT.cpp:185
double * m_chromadata
Definition: Chromagram.h:58
unsigned int m_hopSize
Definition: Chromagram.h:67
double m_FMin
Definition: Chromagram.h:59
int initialise(ChromaConfig Config)
Definition: Chromagram.cpp:29
int getfftlength()
Definition: ConstantQ.h:53
double max
Definition: ConstantQ.h:26
double min
Definition: ConstantQ.h:25
ConstantQ * m_ConstantQ
Definition: Chromagram.h:70
Definition: FFT.h:46
static void getFrameMinMax(const double *data, unsigned int len, double *min, double *max)
Return through min and max pointers the highest and lowest values in the given array of the given len...
Window< double > * m_window
Definition: Chromagram.h:55
double kabs(double real, double imag)
Definition: Chromagram.cpp:99
unsigned int BPO
Definition: ConstantQ.h:27
double * m_FFTRe
Definition: Chromagram.h:72
void sparsekernel()
Definition: ConstantQ.cpp:76
double * m_FFTIm
Definition: Chromagram.h:73
double m_FMax
Definition: Chromagram.h:60
void unityNormalise(double *src)
Definition: Chromagram.cpp:107
double * m_windowbuf
Definition: Chromagram.h:56
double * m_CQIm
Definition: Chromagram.h:75
static void normalise(double *data, int length, NormaliseType n=NormaliseUnitMax)
int gethop()
Definition: ConstantQ.h:54
void cut(T *src) const
Definition: Window.h:61