libs/rubberband/src/Window.h

   1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
   2
   3 /*
   4     Rubber Band
   5     An audio time-stretching and pitch-shifting library.
   6     Copyright 2007-2008 Chris Cannam.
   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 #ifndef _RUBBERBAND_WINDOW_H_
  16 #define _RUBBERBAND_WINDOW_H_
  17
  18 #include <cmath>
  19 #include <cstdlib>
  20 #include <iostream>
  21 #include <cstdlib>
  22 #include <map>
  23
  24 #include "sysutils.h"
  25
  26 namespace RubberBand {
  27
  28 enum WindowType {
  29     RectangularWindow,
  30     BartlettWindow,
  31     HammingWindow,
  32     HanningWindow,
  33     BlackmanWindow,
  34     GaussianWindow,
  35     ParzenWindow,
  36     NuttallWindow,
  37     BlackmanHarrisWindow
  38 };
  39
  40 template <typename T>
  41 class Window
  42 {
  43 public:
  44     /**
  45      * Construct a windower of the given type.
  46      */
  47     Window(WindowType type, int size) : m_type(type), m_size(size) { encache(); }
  48     Window(const Window &w) : m_type(w.m_type), m_size(w.m_size) { encache(); }
  49     Window &operator=(const Window &w) {
  50         if (&w == this) return *this;
  51         m_type = w.m_type;
  52         m_size = w.m_size;
  53         encache();
  54         return *this;
  55     }
  56     virtual ~Window() { delete[] m_cache; }
  57
  58     void cut(T *R__ src) const
  59     {
  60         const int sz = m_size;
  61         for (int i = 0; i < sz; ++i) {
  62             src[i] *= m_cache[i];
  63         }
  64     }
  65
  66     void cut(T *R__ src, T *dst) const {
  67         const int sz = m_size;
  68         for (int i = 0; i < sz; ++i) {
  69             dst[i] = src[i];
  70         }
  71         for (int i = 0; i < sz; ++i) {
  72             dst[i] *= m_cache[i];
  73         }
  74     }
  75
  76     T getArea() { return m_area; }
  77     T getValue(int i) { return m_cache[i]; }
  78
  79     WindowType getType() const { return m_type; }
  80     int getSize() const { return m_size; }
  81
  82 protected:
  83     WindowType m_type;
  84     int m_size;
  85     T *R__ m_cache;
  86     T m_area;
  87
  88     void encache();
  89     void cosinewin(T *, T, T, T, T);
  90 };
  91
  92 template <typename T>
  93 void Window<T>::encache()
  94 {
  95     int n = int(m_size);
  96     T *mult = new T[n];
  97     int i;
  98     for (i = 0; i < n; ++i) mult[i] = 1.0;
  99
 100     switch (m_type) {
 101
 102     case RectangularWindow:
 103         for (i = 0; i < n; ++i) {
 104             mult[i] *= 0.5;
 105         }
 106         break;
 107
 108     case BartlettWindow:
 109         for (i = 0; i < n/2; ++i) {
 110             mult[i] *= (i / T(n/2));
 111             mult[i + n/2] *= (1.0 - (i / T(n/2)));
 112         }
 113         break;
 114
 115     case HammingWindow:
 116         cosinewin(mult, 0.54, 0.46, 0.0, 0.0);
 117         break;
 118
 119     case HanningWindow:
 120         cosinewin(mult, 0.50, 0.50, 0.0, 0.0);
 121         break;
 122
 123     case BlackmanWindow:
 124         cosinewin(mult, 0.42, 0.50, 0.08, 0.0);
 125         break;
 126
 127     case GaussianWindow:
 128         for (i = 0; i < n; ++i) {
 129             mult[i] *= pow(2, - pow((i - (n-1)/2.0) / ((n-1)/2.0 / 3), 2));
 130         }
 131         break;
 132
 133     case ParzenWindow:
 134     {
 135         int N = n-1;
 136         for (i = 0; i < N/4; ++i) {
 137             T m = 2 * pow(1.0 - (T(N)/2 - i) / (T(N)/2), 3);
 138             mult[i] *= m;
 139             mult[N-i] *= m;
 140         }
 141         for (i = N/4; i <= N/2; ++i) {
 142             int wn = i - N/2;
 143             T m = 1.0 - 6 * pow(wn / (T(N)/2), 2) * (1.0 - abs(wn) / (T(N)/2));
 144             mult[i] *= m;
 145             mult[N-i] *= m;
 146         }
 147         break;
 148     }
 149
 150     case NuttallWindow:
 151         cosinewin(mult, 0.3635819, 0.4891775, 0.1365995, 0.0106411);
 152         break;
 153
 154     case BlackmanHarrisWindow:
 155         cosinewin(mult, 0.35875, 0.48829, 0.14128, 0.01168);
 156         break;
 157     }
 158
 159     m_cache = mult;
 160
 161     m_area = 0;
 162     for (int i = 0; i < n; ++i) {
 163         m_area += m_cache[i];
 164     }
 165     m_area /= n;
 166 }
 167
 168 template <typename T>
 169 void Window<T>::cosinewin(T *mult, T a0, T a1, T a2, T a3)
 170 {
 171     int n = int(m_size);
 172     for (int i = 0; i < n; ++i) {
 173         mult[i] *= (a0
 174                     - a1 * cos(2 * M_PI * i / n)
 175                     + a2 * cos(4 * M_PI * i / n)
 176                     - a3 * cos(6 * M_PI * i / n));
 177     }
 178 }
 179
 180 }
 181
 182 #endif