Separate visual components Scope/Spectrum/Waterfall

Each now on it's own canvas with shared GL Context

CMakeLists.txt

@@ -83,7 +83,7 @@ endif (DEFINED WIN32)
 
 
 SET (cubicsdr_sources
-  src/CubicSDR.cpp
+    src/CubicSDR.cpp
 	src/SDRThread.cpp
 	src/IQBufferThread.cpp
 	src/PrimaryGLContext.cpp
@@ -94,10 +94,14 @@ SET (cubicsdr_sources
 	src/Gradient.cpp
 	src/visual/ScopeCanvas.cpp
 	src/visual/ScopeContext.cpp
+	src/visual/SpectrumCanvas.cpp
+	src/visual/SpectrumContext.cpp
+	src/visual/WaterfallCanvas.cpp
+	src/visual/WaterfallContext.cpp
 )
 
 SET (cubicsdr_headers
-  src/CubicSDR.h
+    src/CubicSDR.h
 	src/SDRThread.h
 	src/IQBufferThread.h
 	src/PrimaryGLContext.h
@@ -109,6 +113,10 @@ SET (cubicsdr_headers
 	src/Gradient.h
 	src/visual/ScopeCanvas.h
 	src/visual/ScopeContext.h
+	src/visual/SpectrumCanvas.h
+	src/visual/SpectrumContext.h
+	src/visual/WaterfallCanvas.h
+	src/visual/WaterfallContext.h
 )
 
 include_directories ( ${PROJECT_SOURCE_DIR}/src/visual 

src/AppFrame.cpp

@@ -23,7 +23,18 @@ wxEND_EVENT_TABLE()
 AppFrame::AppFrame() :
         wxFrame(NULL, wxID_ANY, wxT("CubicSDR")), frequency(DEFAULT_FREQ) {
 
-    canvas = new ScopeCanvas(this, NULL);
+    wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);
+
+    scopeCanvas = new ScopeCanvas(this, NULL);
+    vbox->Add(scopeCanvas, 1, wxEXPAND | wxALL, 0);
+    vbox->AddSpacer(2);
+    spectrumCanvas = new SpectrumCanvas(this, NULL);
+    vbox->Add(spectrumCanvas, 1, wxEXPAND | wxALL, 0);
+    vbox->AddSpacer(2);
+    waterfallCanvas = new WaterfallCanvas(this, NULL);
+    vbox->Add(waterfallCanvas, 4, wxEXPAND | wxALL, 0);
+
+    this->SetSizer(vbox);
 
 //    SetIcon(wxICON(sample));
 
@@ -77,16 +88,16 @@ AppFrame::~AppFrame() {
         }
     }
 
-    {
+//    {
-        wxCriticalSectionLocker enter(m_pThreadCS);
+//        wxCriticalSectionLocker enter(m_pThreadCS);
-        if (t_IQBuffer) {
+//        if (t_IQBuffer) {
-            wxMessageOutputDebug().Printf("CubicSDR: deleting thread");
+//            wxMessageOutputDebug().Printf("CubicSDR: deleting thread");
-            if (t_IQBuffer->Delete() != wxTHREAD_NO_ERROR) {
+//            if (t_IQBuffer->Delete() != wxTHREAD_NO_ERROR) {
-                wxLogError
+//                wxLogError
-                ("Can't delete the thread!");
+//                ("Can't delete the thread!");
-            }
+//            }
-        }
+//        }
-    }
+//    }
 
     delete t_SDR;
 //    delete t_IQBuffer;
@@ -106,9 +117,10 @@ void AppFrame::OnNewWindow(wxCommandEvent& WXUNUSED(event)) {
 void AppFrame::OnEventInput(wxThreadEvent& event) {
     std::vector<signed char> *new_buffer = event.GetPayload<std::vector<signed char> *>();
 
-//    std::cout << "Got IQ buffer, length: " << new_buffer->size() << std::endl;
+    test_demod.writeBuffer(new_buffer);
-
+    scopeCanvas->setWaveformPoints(test_demod.waveform_points);
-    canvas->setData(new_buffer);
+    spectrumCanvas->setData(new_buffer);
+    waterfallCanvas->setData(new_buffer);
 
     delete new_buffer;
 }

src/AppFrame.h

@@ -4,6 +4,9 @@
 #include "PrimaryGLContext.h"
 #include "SDRThread.h"
 #include "ScopeCanvas.h"
+#include "SpectrumCanvas.h"
+#include "WaterfallCanvas.h"
+#include "Demodulator.h"
 
 // Define a new frame type
 class AppFrame: public wxFrame {
@@ -20,12 +23,17 @@ private:
     void OnNewWindow(wxCommandEvent& event);
     void OnIdle(wxIdleEvent& event);
 
-    ScopeCanvas *canvas;
+    ScopeCanvas *scopeCanvas;
+    SpectrumCanvas *spectrumCanvas;
+    WaterfallCanvas *waterfallCanvas;
     SDRThread *t_SDR;
     IQBufferThread *t_IQBuffer;
     wxCriticalSection m_pThreadCS;
     SDRThreadQueue* m_pQueue;
     unsigned int frequency;
 
+    Demodulator test_demod;
+
+// event table
 wxDECLARE_EVENT_TABLE();
 };

src/CubicSDRDefs.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #define BUF_SIZE (16 * 32 * 256)
-#define SRATE 2500000
+#define SRATE 2000000
 #define FFT_SIZE 2048
 
-#define DEFAULT_FREQ 105700000
+#define DEFAULT_FREQ 98900000
 

src/visual/ScopeCanvas.cpp

@@ -24,18 +24,6 @@ ScopeCanvas::ScopeCanvas(wxWindow *parent, int *attribList) :
         wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize,
         wxFULL_REPAINT_ON_RESIZE), parent(parent) {
 
-    int in_block_size = BUF_SIZE / 2;
-    int out_block_size = FFT_SIZE;
-
-    in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * in_block_size);
-    out[0] = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * out_block_size);
-    out[1] = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * out_block_size);
-    plan[0] = fftw_plan_dft_1d(out_block_size, in, out[0], FFTW_FORWARD, FFTW_MEASURE);
-    plan[1] = fftw_plan_dft_1d(out_block_size, out[0], out[1], FFTW_BACKWARD, FFTW_MEASURE);
-
-    fft_ceil_ma = fft_ceil_maa = 100.0;
-    fft_floor_ma = fft_floor_maa = 0.0;
-
     glContext = new ScopeContext(this, &wxGetApp().GetContext(this));
 }
 
@@ -43,6 +31,10 @@ ScopeCanvas::~ScopeCanvas() {
 
 }
 
+void ScopeCanvas::setWaveformPoints(std::vector<float> &waveform_points_in) {
+    waveform_points = waveform_points_in;
+}
+
 void ScopeCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
     wxPaintDC dc(this);
     const wxSize ClientSize = GetClientSize();
@@ -50,7 +42,7 @@ void ScopeCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
     glContext->SetCurrent(*this);
     glViewport(0, 0, ClientSize.x, ClientSize.y);
 
-    glContext->Plot(spectrum_points, test_demod.waveform_points);
+    glContext->Plot(waveform_points);
 
     SwapBuffers();
 }
@@ -82,90 +74,6 @@ void ScopeCanvas::OnKeyDown(wxKeyEvent& event) {
     }
 }
 
-void multiply2(float ar, float aj, float br, float bj, float *cr, float *cj) {
-    *cr = ar * br - aj * bj;
-    *cj = aj * br + ar * bj;
-}
-float polar_discriminant2(float ar, float aj, float br, float bj) {
-    float cr, cj;
-    double angle;
-    multiply2(ar, aj, br, -bj, &cr, &cj);
-    angle = atan2(cj, cr);
-    return (angle / M_PI);
-}
-
-void ScopeCanvas::setData(std::vector<signed char> *data) {
-
-    if (data && data->size()) {
-        if (spectrum_points.size() < FFT_SIZE * 2) {
-            spectrum_points.resize(FFT_SIZE * 2);
-        }
-
-        for (int i = 0; i < BUF_SIZE / 2; i++) {
-            in[i][0] = (float) (*data)[i * 2] / 127.0f;
-            in[i][1] = (float) (*data)[i * 2 + 1] / 127.0f;
-        }
-
-        fftw_execute(plan[0]);
-
-        double fft_ceil = 0, fft_floor = 1;
-
-        if (fft_result.size() < FFT_SIZE) {
-            fft_result.resize(FFT_SIZE);
-            fft_result_ma.resize(FFT_SIZE);
-            fft_result_maa.resize(FFT_SIZE);
-        }
-
-        for (int j = 0; j < 2; j++) {
-            for (int i = 0, iMax = FFT_SIZE / 2; i < iMax; i++) {
-                double a = out[0][i][0];
-                double b = out[0][i][1];
-                double c = sqrt(a * a + b * b);
-
-                double x = out[0][FFT_SIZE / 2 + i][0];
-                double y = out[0][FFT_SIZE / 2 + i][1];
-                double z = sqrt(x * x + y * y);
-
-                fft_result[i] = (z);
-                fft_result[FFT_SIZE / 2 + i] = (c);
-            }
-        }
-
-        float time_slice = (float) SRATE / (float) (BUF_SIZE / 2);
-
-        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
-            fft_result_maa[i] += (fft_result_ma[i] - fft_result_maa[i]) * 0.65;
-            fft_result_ma[i] += (fft_result[i] - fft_result_ma[i]) * 0.65;
-
-            if (fft_result_maa[i] > fft_ceil) {
-                fft_ceil = fft_result_maa[i];
-            }
-            if (fft_result_maa[i] < fft_floor) {
-                fft_floor = fft_result_maa[i];
-            }
-        }
-
-        fft_ceil += 1;
-        fft_floor -= 1;
-
-        fft_ceil_ma = fft_ceil_ma + (fft_ceil - fft_ceil_ma) * 0.01;
-        fft_ceil_maa = fft_ceil_maa + (fft_ceil_ma - fft_ceil_maa) * 0.01;
-
-        fft_floor_ma = fft_floor_ma + (fft_floor - fft_floor_ma) * 0.01;
-        fft_floor_maa = fft_floor_maa + (fft_floor_ma - fft_floor_maa) * 0.01;
-
-        // fftw_execute(plan[1]);
-
-        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
-            float v = (log10(fft_result_maa[i] - fft_floor_maa) / log10(fft_ceil_maa - fft_floor_maa));
-            spectrum_points[i * 2] = ((float) i / (float) iMax);
-            spectrum_points[i * 2 + 1] = v;
-        }
-
-        test_demod.writeBuffer(data);
-    }
-}
-
 void ScopeCanvas::OnIdle(wxIdleEvent &event) {
     Refresh(false);
 }

src/visual/ScopeCanvas.h

@@ -9,15 +9,13 @@
 #include "ScopeContext.h"
 
 #include "fftw3.h"
-#include "Demodulator.h"
 
 class ScopeCanvas: public wxGLCanvas {
 public:
     ScopeCanvas(wxWindow *parent, int *attribList = NULL);
     ~ScopeCanvas();
 
-    void setData(std::vector<signed char> *data);
+    void setWaveformPoints(std::vector<float> &waveform_points_in);
-
 private:
     void OnPaint(wxPaintEvent& event);
     void OnKeyDown(wxKeyEvent& event);
@@ -25,19 +23,10 @@ private:
     void OnIdle(wxIdleEvent &event);
 
     wxWindow *parent;
-    std::vector<float> spectrum_points;
+    std::vector<float> waveform_points;
 
-    fftw_complex *in, *out[2];
+    ScopeContext *glContext;
-    fftw_plan plan[2];
+// event table
-
+wxDECLARE_EVENT_TABLE();
-    float fft_ceil_ma, fft_ceil_maa;
-    float fft_floor_ma, fft_floor_maa;
-
-    std::vector<float> fft_result;
-    std::vector<float> fft_result_ma;
-    std::vector<float> fft_result_maa;
-
-    Demodulator test_demod;
-    ScopeContext *glContext;wxDECLARE_EVENT_TABLE();
 };
 

src/visual/ScopeContext.cpp

@@ -9,66 +9,22 @@ ScopeContext::ScopeContext(ScopeCanvas *canvas, wxGLContext *sharedContext) :
 
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-
-    glGenTextures(1, &waterfall);
-
-    glEnable(GL_TEXTURE_2D);
-    glBindTexture(GL_TEXTURE_2D, waterfall);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-
-    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
-
-    grad.addColor(GradientColor(0, 0, 0));
-    grad.addColor(GradientColor(0, 0, 1.0));
-    grad.addColor(GradientColor(0, 1.0, 0));
-    grad.addColor(GradientColor(1.0, 1.0, 0));
-    grad.addColor(GradientColor(1.0, 0.2, 0.0));
-
-    grad.generate(256);
-
-    glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 256, &(grad.getRed())[0]);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 256, &(grad.getGreen())[0]);
-    glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 256, &(grad.getBlue())[0]);
 }
 
-void ScopeContext::Plot(std::vector<float> &points, std::vector<float> &points2) {
+void ScopeContext::Plot(std::vector<float> &points) {
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
 
-    if (points.size()) {
-        memmove(waterfall_tex + FFT_SIZE, waterfall_tex, (NUM_WATERFALL_LINES - 1) * FFT_SIZE);
-
-        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
-            float v = points[i * 2 + 1];
-
-            float wv = v;
-            if (wv < 0.0)
-                wv = 0.0;
-            if (wv > 1.0)
-                wv = 1.0;
-            waterfall_tex[i] = (unsigned char) floor(wv * 255.0);
-        }
-    }
-
-    glBindTexture(GL_TEXTURE_2D, waterfall);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, FFT_SIZE, NUM_WATERFALL_LINES, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, (GLvoid *) waterfall_tex);
-
     glDisable(GL_TEXTURE_2D);
 
     glColor3f(1.0, 1.0, 1.0);
 
     if (points.size()) {
         glPushMatrix();
-        glTranslatef(-1.0f, -0.9f, 0.0f);
+        glTranslatef(-1.0f, 0.0f, 0.0f);
-        glScalef(2.0f, 1.0f, 1.0f);
+        glScalef(2.0f, 2.0f, 1.0f);
         glEnableClientState(GL_VERTEX_ARRAY);
         glVertexPointer(2, GL_FLOAT, 0, &points[0]);
         glDrawArrays(GL_LINE_STRIP, 0, points.size() / 2);
@@ -76,30 +32,6 @@ void ScopeContext::Plot(std::vector<float> &points, std::vector<float> &points2)
         glPopMatrix();
     }
 
-    if (points2.size()) {
-        glPushMatrix();
-        glTranslatef(-1.0f, 0.5f, 0.0f);
-        glScalef(2.0f, 1.0f, 1.0f);
-        glEnableClientState(GL_VERTEX_ARRAY);
-        glVertexPointer(2, GL_FLOAT, 0, &points2[0]);
-        glDrawArrays(GL_LINE_STRIP, 0, points2.size() / 2);
-        glDisableClientState(GL_VERTEX_ARRAY);
-        glPopMatrix();
-    }
-
-    glEnable(GL_TEXTURE_2D);
-    // glEnable(GL_COLOR_TABLE);
-    glBindTexture(GL_TEXTURE_2D, waterfall);
-    glBegin(GL_QUADS);
-    glTexCoord2f(0.0, 0.0);
-    glVertex3f(-1.0, -1.0, 0.0);
-    glTexCoord2f(1.0, 0.0);
-    glVertex3f(1.0, -1.0, 0.0);
-    glTexCoord2f(1.0, 1.0);
-    glVertex3f(1.0, 1.0, 0.0);
-    glTexCoord2f(0.0, 1.0);
-    glVertex3f(-1.0, 1.0, 0.0);
-    glEnd();
 
     glFlush();
 

src/visual/ScopeContext.h

@@ -11,10 +11,7 @@ class ScopeContext: public PrimaryGLContext {
 public:
     ScopeContext(ScopeCanvas *canvas, wxGLContext *sharedContext);
 
-    void Plot(std::vector<float> &points, std::vector<float> &points2);
+    void Plot(std::vector<float> &points);
 
 private:
-    Gradient grad;
-    GLuint waterfall;
-    unsigned char waterfall_tex[FFT_SIZE * NUM_WATERFALL_LINES];
 };

src/visual/SpectrumCanvas.cpp

@@ -0,0 +1,156 @@
+#include "SpectrumCanvas.h"
+
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#if !wxUSE_GLCANVAS
+#error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
+#endif
+
+#include "CubicSDR.h"
+#include "CubicSDRDefs.h"
+#include "AppFrame.h"
+#include <algorithm>
+
+wxBEGIN_EVENT_TABLE(SpectrumCanvas, wxGLCanvas) EVT_PAINT(SpectrumCanvas::OnPaint)
+EVT_KEY_DOWN(SpectrumCanvas::OnKeyDown)
+EVT_IDLE(SpectrumCanvas::OnIdle)
+wxEND_EVENT_TABLE()
+
+SpectrumCanvas::SpectrumCanvas(wxWindow *parent, int *attribList) :
+        wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize,
+        wxFULL_REPAINT_ON_RESIZE), parent(parent) {
+
+    int in_block_size = BUF_SIZE / 2;
+    int out_block_size = FFT_SIZE;
+
+    in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * in_block_size);
+    out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * out_block_size);
+    plan = fftw_plan_dft_1d(out_block_size, in, out, FFTW_FORWARD, FFTW_MEASURE);
+
+    fft_ceil_ma = fft_ceil_maa = 100.0;
+    fft_floor_ma = fft_floor_maa = 0.0;
+
+    glContext = new SpectrumContext(this, &wxGetApp().GetContext(this));
+}
+
+SpectrumCanvas::~SpectrumCanvas() {
+
+}
+
+void SpectrumCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
+    wxPaintDC dc(this);
+    const wxSize ClientSize = GetClientSize();
+
+    glContext->SetCurrent(*this);
+    glViewport(0, 0, ClientSize.x, ClientSize.y);
+
+    glContext->Draw(spectrum_points);
+
+    SwapBuffers();
+}
+
+void SpectrumCanvas::OnKeyDown(wxKeyEvent& event) {
+    float angle = 5.0;
+
+    unsigned int freq;
+    switch (event.GetKeyCode()) {
+    case WXK_RIGHT:
+        freq = ((AppFrame*) parent)->getFrequency();
+        freq += 100000;
+        ((AppFrame*) parent)->setFrequency(freq);
+        break;
+    case WXK_LEFT:
+        freq = ((AppFrame*) parent)->getFrequency();
+        freq -= 100000;
+        ((AppFrame*) parent)->setFrequency(freq);
+        break;
+    case WXK_DOWN:
+        break;
+    case WXK_UP:
+        break;
+    case WXK_SPACE:
+        break;
+    default:
+        event.Skip();
+        return;
+    }
+}
+
+void SpectrumCanvas::setData(std::vector<signed char> *data) {
+
+    if (data && data->size()) {
+        if (spectrum_points.size() < FFT_SIZE * 2) {
+            spectrum_points.resize(FFT_SIZE * 2);
+        }
+
+        for (int i = 0; i < BUF_SIZE / 2; i++) {
+            in[i][0] = (float) (*data)[i * 2] / 127.0f;
+            in[i][1] = (float) (*data)[i * 2 + 1] / 127.0f;
+        }
+
+        fftw_execute(plan);
+
+        double fft_ceil = 0, fft_floor = 1;
+
+        if (fft_result.size() < FFT_SIZE) {
+            fft_result.resize(FFT_SIZE);
+            fft_result_ma.resize(FFT_SIZE);
+            fft_result_maa.resize(FFT_SIZE);
+        }
+
+        for (int j = 0; j < 2; j++) {
+            for (int i = 0, iMax = FFT_SIZE / 2; i < iMax; i++) {
+                double a = out[i][0];
+                double b = out[i][1];
+                double c = sqrt(a * a + b * b);
+
+                double x = out[FFT_SIZE / 2 + i][0];
+                double y = out[FFT_SIZE / 2 + i][1];
+                double z = sqrt(x * x + y * y);
+
+                fft_result[i] = (z);
+                fft_result[FFT_SIZE / 2 + i] = (c);
+            }
+        }
+
+        float time_slice = (float) SRATE / (float) (BUF_SIZE / 2);
+
+        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
+            fft_result_maa[i] += (fft_result_ma[i] - fft_result_maa[i]) * 0.65;
+            fft_result_ma[i] += (fft_result[i] - fft_result_ma[i]) * 0.65;
+
+            if (fft_result_maa[i] > fft_ceil) {
+                fft_ceil = fft_result_maa[i];
+            }
+            if (fft_result_maa[i] < fft_floor) {
+                fft_floor = fft_result_maa[i];
+            }
+        }
+
+        fft_ceil += 1;
+        fft_floor -= 1;
+
+        fft_ceil_ma = fft_ceil_ma + (fft_ceil - fft_ceil_ma) * 0.01;
+        fft_ceil_maa = fft_ceil_maa + (fft_ceil_ma - fft_ceil_maa) * 0.01;
+
+        fft_floor_ma = fft_floor_ma + (fft_floor - fft_floor_ma) * 0.01;
+        fft_floor_maa = fft_floor_maa + (fft_floor_ma - fft_floor_maa) * 0.01;
+
+        // fftw_execute(plan[1]);
+
+        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
+            float v = (log10(fft_result_maa[i] - fft_floor_maa) / log10(fft_ceil_maa - fft_floor_maa));
+            spectrum_points[i * 2] = ((float) i / (float) iMax);
+            spectrum_points[i * 2 + 1] = v;
+        }
+
+    }
+}
+
+void SpectrumCanvas::OnIdle(wxIdleEvent &event) {
+    Refresh(false);
+}

src/visual/SpectrumCanvas.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "wx/glcanvas.h"
+#include "wx/timer.h"
+
+#include <vector>
+#include <queue>
+
+#include "SpectrumContext.h"
+
+#include "fftw3.h"
+#include "Demodulator.h"
+
+class SpectrumCanvas: public wxGLCanvas {
+public:
+    SpectrumCanvas(wxWindow *parent, int *attribList = NULL);
+    ~SpectrumCanvas();
+
+    void setData(std::vector<signed char> *data);
+private:
+    void OnPaint(wxPaintEvent& event);
+    void OnKeyDown(wxKeyEvent& event);
+
+    void OnIdle(wxIdleEvent &event);
+
+    wxWindow *parent;
+    std::vector<float> spectrum_points;
+
+    fftw_complex *in, *out;
+    fftw_plan plan;
+
+    float fft_ceil_ma, fft_ceil_maa;
+    float fft_floor_ma, fft_floor_maa;
+
+    std::vector<float> fft_result;
+    std::vector<float> fft_result_ma;
+    std::vector<float> fft_result_maa;
+
+    SpectrumContext *glContext;
+// event table
+wxDECLARE_EVENT_TABLE();
+};
+

src/visual/SpectrumContext.cpp

@@ -0,0 +1,36 @@
+#include "SpectrumContext.h"
+
+#include "SpectrumCanvas.h"
+
+SpectrumContext::SpectrumContext(SpectrumCanvas *canvas, wxGLContext *sharedContext) :
+        PrimaryGLContext(canvas, sharedContext) {
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+
+}
+
+void SpectrumContext::Draw(std::vector<float> &points) {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    glDisable(GL_TEXTURE_2D);
+
+    glColor3f(1.0, 1.0, 1.0);
+
+    if (points.size()) {
+        glPushMatrix();
+        glTranslatef(-1.0f, -0.9f, 0.0f);
+        glScalef(2.0f, 1.8f, 1.0f);
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glVertexPointer(2, GL_FLOAT, 0, &points[0]);
+        glDrawArrays(GL_LINE_STRIP, 0, points.size() / 2);
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glPopMatrix();
+    }
+    CheckGLError();
+}

src/visual/SpectrumContext.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "PrimaryGLContext.h"
+#include "Gradient.h"
+
+#define NUM_WATERFALL_LINES 512
+
+class SpectrumCanvas;
+
+class SpectrumContext: public PrimaryGLContext {
+public:
+    SpectrumContext(SpectrumCanvas *canvas, wxGLContext *sharedContext);
+
+    void Draw(std::vector<float> &points);
+
+private:
+};

src/visual/WaterfallCanvas.cpp

@@ -0,0 +1,154 @@
+#include "WaterfallCanvas.h"
+
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+#include "wx/wx.h"
+#endif
+
+#if !wxUSE_GLCANVAS
+#error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library"
+#endif
+
+#include "CubicSDR.h"
+#include "CubicSDRDefs.h"
+#include "AppFrame.h"
+#include <algorithm>
+
+wxBEGIN_EVENT_TABLE(WaterfallCanvas, wxGLCanvas) EVT_PAINT(WaterfallCanvas::OnPaint)
+EVT_KEY_DOWN(WaterfallCanvas::OnKeyDown)
+EVT_IDLE(WaterfallCanvas::OnIdle)
+wxEND_EVENT_TABLE()
+
+WaterfallCanvas::WaterfallCanvas(wxWindow *parent, int *attribList) :
+        wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize,
+        wxFULL_REPAINT_ON_RESIZE), parent(parent) {
+
+    int in_block_size = BUF_SIZE / 2;
+    int out_block_size = FFT_SIZE;
+
+    in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * in_block_size);
+    out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * out_block_size);
+    plan = fftw_plan_dft_1d(out_block_size, in, out, FFTW_FORWARD, FFTW_MEASURE);
+
+    fft_ceil_ma = fft_ceil_maa = 100.0;
+    fft_floor_ma = fft_floor_maa = 0.0;
+
+    glContext = new WaterfallContext(this, &wxGetApp().GetContext(this));
+}
+
+WaterfallCanvas::~WaterfallCanvas() {
+
+}
+
+void WaterfallCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
+    wxPaintDC dc(this);
+    const wxSize ClientSize = GetClientSize();
+
+    glContext->SetCurrent(*this);
+    glViewport(0, 0, ClientSize.x, ClientSize.y);
+
+    glContext->Draw(spectrum_points);
+
+    SwapBuffers();
+}
+
+void WaterfallCanvas::OnKeyDown(wxKeyEvent& event) {
+    float angle = 5.0;
+
+    unsigned int freq;
+    switch (event.GetKeyCode()) {
+    case WXK_RIGHT:
+        freq = ((AppFrame*) parent)->getFrequency();
+        freq += 100000;
+        ((AppFrame*) parent)->setFrequency(freq);
+        break;
+    case WXK_LEFT:
+        freq = ((AppFrame*) parent)->getFrequency();
+        freq -= 100000;
+        ((AppFrame*) parent)->setFrequency(freq);
+        break;
+    case WXK_DOWN:
+        break;
+    case WXK_UP:
+        break;
+    case WXK_SPACE:
+        break;
+    default:
+        event.Skip();
+        return;
+    }
+}
+
+void WaterfallCanvas::setData(std::vector<signed char> *data) {
+
+    if (data && data->size()) {
+        if (spectrum_points.size() < FFT_SIZE * 2) {
+            spectrum_points.resize(FFT_SIZE * 2);
+        }
+
+        for (int i = 0; i < BUF_SIZE / 2; i++) {
+            in[i][0] = (float) (*data)[i * 2] / 127.0f;
+            in[i][1] = (float) (*data)[i * 2 + 1] / 127.0f;
+        }
+
+        fftw_execute(plan);
+
+        double fft_ceil = 0, fft_floor = 1;
+
+        if (fft_result.size() < FFT_SIZE) {
+            fft_result.resize(FFT_SIZE);
+            fft_result_ma.resize(FFT_SIZE);
+            fft_result_maa.resize(FFT_SIZE);
+        }
+
+        for (int j = 0; j < 2; j++) {
+            for (int i = 0, iMax = FFT_SIZE / 2; i < iMax; i++) {
+                double a = out[i][0];
+                double b = out[i][1];
+                double c = sqrt(a * a + b * b);
+
+                double x = out[FFT_SIZE / 2 + i][0];
+                double y = out[FFT_SIZE / 2 + i][1];
+                double z = sqrt(x * x + y * y);
+
+                fft_result[i] = (z);
+                fft_result[FFT_SIZE / 2 + i] = (c);
+            }
+        }
+
+        float time_slice = (float) SRATE / (float) (BUF_SIZE / 2);
+
+        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
+            fft_result_maa[i] += (fft_result_ma[i] - fft_result_maa[i]) * 0.65;
+            fft_result_ma[i] += (fft_result[i] - fft_result_ma[i]) * 0.65;
+
+            if (fft_result_maa[i] > fft_ceil) {
+                fft_ceil = fft_result_maa[i];
+            }
+            if (fft_result_maa[i] < fft_floor) {
+                fft_floor = fft_result_maa[i];
+            }
+        }
+
+        fft_ceil += 1;
+        fft_floor -= 1;
+
+        fft_ceil_ma = fft_ceil_ma + (fft_ceil - fft_ceil_ma) * 0.01;
+        fft_ceil_maa = fft_ceil_maa + (fft_ceil_ma - fft_ceil_maa) * 0.01;
+
+        fft_floor_ma = fft_floor_ma + (fft_floor - fft_floor_ma) * 0.01;
+        fft_floor_maa = fft_floor_maa + (fft_floor_ma - fft_floor_maa) * 0.01;
+
+        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
+            float v = (log10(fft_result_maa[i] - fft_floor_maa) / log10(fft_ceil_maa - fft_floor_maa));
+            spectrum_points[i * 2] = ((float) i / (float) iMax);
+            spectrum_points[i * 2 + 1] = v;
+        }
+
+    }
+}
+
+void WaterfallCanvas::OnIdle(wxIdleEvent &event) {
+    Refresh(false);
+}

src/visual/WaterfallCanvas.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "wx/glcanvas.h"
+#include "wx/timer.h"
+
+#include <vector>
+#include <queue>
+
+#include "WaterfallContext.h"
+
+#include "fftw3.h"
+
+class WaterfallCanvas: public wxGLCanvas {
+public:
+    WaterfallCanvas(wxWindow *parent, int *attribList = NULL);
+    ~WaterfallCanvas();
+
+    void setData(std::vector<signed char> *data);
+private:
+    void OnPaint(wxPaintEvent& event);
+    void OnKeyDown(wxKeyEvent& event);
+
+    void OnIdle(wxIdleEvent &event);
+
+    wxWindow *parent;
+    std::vector<float> spectrum_points;
+
+    fftw_complex *in, *out;
+    fftw_plan plan;
+
+    float fft_ceil_ma, fft_ceil_maa;
+    float fft_floor_ma, fft_floor_maa;
+
+    std::vector<float> fft_result;
+    std::vector<float> fft_result_ma;
+    std::vector<float> fft_result_maa;
+
+    WaterfallContext *glContext;
+// event table
+wxDECLARE_EVENT_TABLE();
+};
+

src/visual/WaterfallContext.cpp

@@ -0,0 +1,84 @@
+#include "WaterfallContext.h"
+#include "WaterfallCanvas.h"
+
+WaterfallContext::WaterfallContext(WaterfallCanvas *canvas, wxGLContext *sharedContext) :
+        PrimaryGLContext(canvas, sharedContext) {
+    glEnable(GL_CULL_FACE);
+    glEnable(GL_DEPTH_TEST);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+
+    glGenTextures(1, &waterfall);
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, waterfall);
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
+
+    grad.addColor(GradientColor(0, 0, 0));
+    grad.addColor(GradientColor(0, 0, 1.0));
+    grad.addColor(GradientColor(0, 1.0, 0));
+    grad.addColor(GradientColor(1.0, 1.0, 0));
+    grad.addColor(GradientColor(1.0, 0.2, 0.0));
+
+    grad.generate(256);
+
+    glPixelTransferi(GL_MAP_COLOR, GL_TRUE);
+    glPixelMapfv(GL_PIXEL_MAP_I_TO_R, 256, &(grad.getRed())[0]);
+    glPixelMapfv(GL_PIXEL_MAP_I_TO_G, 256, &(grad.getGreen())[0]);
+    glPixelMapfv(GL_PIXEL_MAP_I_TO_B, 256, &(grad.getBlue())[0]);
+}
+
+void WaterfallContext::Draw(std::vector<float> &points) {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    if (points.size()) {
+        memmove(waterfall_tex + FFT_SIZE, waterfall_tex, (NUM_WATERFALL_LINES - 1) * FFT_SIZE);
+
+        for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) {
+            float v = points[i * 2 + 1];
+
+            float wv = v;
+            if (wv < 0.0)
+                wv = 0.0;
+            if (wv > 1.0)
+                wv = 1.0;
+            waterfall_tex[i] = (unsigned char) floor(wv * 255.0);
+        }
+    }
+
+    glBindTexture(GL_TEXTURE_2D, waterfall);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, FFT_SIZE, NUM_WATERFALL_LINES, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, (GLvoid *) waterfall_tex);
+
+    glDisable(GL_TEXTURE_2D);
+
+    glColor3f(1.0, 1.0, 1.0);
+
+    glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_COLOR_TABLE);
+    glBindTexture(GL_TEXTURE_2D, waterfall);
+    glBegin(GL_QUADS);
+    glTexCoord2f(0.0, 1.0);
+    glVertex3f(-1.0, -1.0, 0.0);
+    glTexCoord2f(1.0, 1.0);
+    glVertex3f(1.0, -1.0, 0.0);
+    glTexCoord2f(1.0, 0.0);
+    glVertex3f(1.0, 1.0, 0.0);
+    glTexCoord2f(0.0, 0.0);
+    glVertex3f(-1.0, 1.0, 0.0);
+    glEnd();
+
+    glFlush();
+
+    CheckGLError();
+}

src/visual/WaterfallContext.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "PrimaryGLContext.h"
+#include "Gradient.h"
+
+#define NUM_WATERFALL_LINES 512
+
+class WaterfallCanvas;
+
+class WaterfallContext: public PrimaryGLContext {
+public:
+    WaterfallContext(WaterfallCanvas *canvas, wxGLContext *sharedContext);
+
+    void Draw(std::vector<float> &points);
+
+private:
+    Gradient grad;
+    GLuint waterfall;
+    unsigned char waterfall_tex[FFT_SIZE * NUM_WATERFALL_LINES];
+};