Mercurial > hg > svcore
view data/fft/FFTMemoryCache.h @ 537:3cc4b7cd2aa5
* Merge from one-fftdataserver-per-fftmodel branch. This bit of
reworking (which is not described very accurately by the title of
the branch) turns the MatrixFile object into something that either
reads or writes, but not both, and separates the FFT file cache
reader and writer implementations separately. This allows the
FFT data server to have a single thread owning writers and one reader
per "customer" thread, and for all locking to be vastly simplified
and concentrated in the data server alone (because none of the
classes it makes use of is used in more than one thread at a time).
The result is faster and more trustworthy code.
author | Chris Cannam |
---|---|
date | Tue, 27 Jan 2009 13:25:10 +0000 |
parents | 6066bde1c126 |
children | 1469caaa8e67 |
line wrap: on
line source
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ /* Sonic Visualiser An audio file viewer and annotation editor. Centre for Digital Music, Queen Mary, University of London. This file copyright 2006 Chris Cannam. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. See the file COPYING included with this distribution for more information. */ #ifndef _FFT_MEMORY_CACHE_H_ #define _FFT_MEMORY_CACHE_H_ #include "FFTCacheReader.h" #include "FFTCacheWriter.h" #include "FFTCacheStorageType.h" #include "base/ResizeableBitset.h" #include "base/Profiler.h" #include <QMutex> /** * In-memory FFT cache. For this we want to cache magnitude with * enough resolution to have gain applied afterwards and determine * whether something is a peak or not, and also cache phase rather * than only phase-adjusted frequency so that we don't have to * recalculate if switching between phase and magnitude displays. At * the same time, we don't want to take up too much memory. It's not * expected to be accurate enough to be used as input for DSP or * resynthesis code. * * This implies probably 16 bits for a normalized magnitude and at * most 16 bits for phase. * * Each column's magnitudes are expected to be stored normalized * to [0,1] with respect to the column, so the normalization * factor should be calculated before all values in a column, and * set appropriately. */ class FFTMemoryCache : public FFTCacheReader, public FFTCacheWriter { public: FFTMemoryCache(FFTCache::StorageType storageType, size_t width, size_t height); ~FFTMemoryCache(); size_t getWidth() const { return m_width; } size_t getHeight() const { return m_height; } float getMagnitudeAt(size_t x, size_t y) const { if (m_storageType == FFTCache::Rectangular) { Profiler profiler("FFTMemoryCache::getMagnitudeAt: cart to polar"); return sqrtf(m_freal[x][y] * m_freal[x][y] + m_fimag[x][y] * m_fimag[x][y]); } else { return getNormalizedMagnitudeAt(x, y) * m_factor[x]; } } float getNormalizedMagnitudeAt(size_t x, size_t y) const { if (m_storageType == FFTCache::Rectangular) return getMagnitudeAt(x, y) / m_factor[x]; else if (m_storageType == FFTCache::Polar) return m_fmagnitude[x][y]; else return float(m_magnitude[x][y]) / 65535.0; } float getMaximumMagnitudeAt(size_t x) const { return m_factor[x]; } float getPhaseAt(size_t x, size_t y) const { if (m_storageType == FFTCache::Rectangular) { Profiler profiler("FFTMemoryCache::getValuesAt: cart to polar"); return atan2f(m_fimag[x][y], m_freal[x][y]); } else if (m_storageType == FFTCache::Polar) { return m_fphase[x][y]; } else { int16_t i = (int16_t)m_phase[x][y]; return (float(i) / 32767.0) * M_PI; } } void getValuesAt(size_t x, size_t y, float &real, float &imag) const { if (m_storageType == FFTCache::Rectangular) { real = m_freal[x][y]; imag = m_fimag[x][y]; } else { Profiler profiler("FFTMemoryCache::getValuesAt: polar to cart"); float mag = getMagnitudeAt(x, y); float phase = getPhaseAt(x, y); real = mag * cosf(phase); imag = mag * sinf(phase); } } void getMagnitudesAt(size_t x, float *values, size_t minbin, size_t count, size_t step) const { if (m_storageType == FFTCache::Rectangular) { for (size_t i = 0; i < count; ++i) { size_t y = i * step + minbin; values[i] = sqrtf(m_freal[x][y] * m_freal[x][y] + m_fimag[x][y] * m_fimag[x][y]); } } else if (m_storageType == FFTCache::Polar) { for (size_t i = 0; i < count; ++i) { size_t y = i * step + minbin; values[i] = m_fmagnitude[x][y] * m_factor[x]; } } else { for (size_t i = 0; i < count; ++i) { size_t y = i * step + minbin; values[i] = (float(m_magnitude[x][y]) * m_factor[x]) / 65535.0; } } } bool haveSetColumnAt(size_t x) const { m_colsetMutex.lock(); bool have = m_colset.get(x); m_colsetMutex.unlock(); return have; } void setColumnAt(size_t x, float *mags, float *phases, float factor); void setColumnAt(size_t x, float *reals, float *imags); void allColumnsWritten() { } static size_t getCacheSize(size_t width, size_t height, FFTCache::StorageType type); FFTCache::StorageType getStorageType() const { return m_storageType; } private: size_t m_width; size_t m_height; uint16_t **m_magnitude; uint16_t **m_phase; float **m_fmagnitude; float **m_fphase; float **m_freal; float **m_fimag; float *m_factor; FFTCache::StorageType m_storageType; ResizeableBitset m_colset; mutable QMutex m_colsetMutex; void initialise(); void setNormalizationFactor(size_t x, float factor) { if (x < m_width) m_factor[x] = factor; } void setMagnitudeAt(size_t x, size_t y, float mag) { // norm factor must already be set setNormalizedMagnitudeAt(x, y, mag / m_factor[x]); } void setNormalizedMagnitudeAt(size_t x, size_t y, float norm) { if (x < m_width && y < m_height) { if (m_storageType == FFTCache::Polar) m_fmagnitude[x][y] = norm; else m_magnitude[x][y] = uint16_t(norm * 65535.0); } } void setPhaseAt(size_t x, size_t y, float phase) { // phase in range -pi -> pi if (x < m_width && y < m_height) { if (m_storageType == FFTCache::Polar) m_fphase[x][y] = phase; else m_phase[x][y] = uint16_t(int16_t((phase * 32767) / M_PI)); } } void initialise(uint16_t **&); void initialise(float **&); }; #endif