mirror of
https://github.com/cjcliffe/CubicSDR.git
synced 2024-09-28 08:16:37 -04:00
cleanup, refactor, right mouse waterfall zoom drag
This commit is contained in:
parent
cfe35dc922
commit
334618d000
@ -38,15 +38,15 @@ AppFrame::AppFrame() :
|
||||
wxBoxSizer *demodTray = new wxBoxSizer(wxHORIZONTAL);
|
||||
|
||||
demodSpectrumCanvas = new SpectrumCanvas(this, NULL);
|
||||
demodSpectrumCanvas->Setup(1024);
|
||||
demodSpectrumCanvas->SetView(DEFAULT_FREQ, 300000);
|
||||
demodSpectrumCanvas->setup(1024);
|
||||
demodSpectrumCanvas->setView(DEFAULT_FREQ, 300000);
|
||||
demodVisuals->Add(demodSpectrumCanvas, 1, wxEXPAND | wxALL, 0);
|
||||
|
||||
demodVisuals->AddSpacer(1);
|
||||
|
||||
demodWaterfallCanvas = new WaterfallCanvas(this, NULL);
|
||||
demodWaterfallCanvas->Setup(1024, 256);
|
||||
demodWaterfallCanvas->SetView(DEFAULT_FREQ, 300000);
|
||||
demodWaterfallCanvas->setup(1024, 256);
|
||||
demodWaterfallCanvas->setView(DEFAULT_FREQ, 300000);
|
||||
demodWaterfallCanvas->attachSpectrumCanvas(demodSpectrumCanvas);
|
||||
demodSpectrumCanvas->attachWaterfallCanvas(demodWaterfallCanvas);
|
||||
demodVisuals->Add(demodWaterfallCanvas, 3, wxEXPAND | wxALL, 0);
|
||||
@ -67,11 +67,11 @@ AppFrame::AppFrame() :
|
||||
vbox->Add(demodTray, 2, wxEXPAND | wxALL, 0);
|
||||
vbox->AddSpacer(2);
|
||||
spectrumCanvas = new SpectrumCanvas(this, NULL);
|
||||
spectrumCanvas->Setup(2048);
|
||||
spectrumCanvas->setup(2048);
|
||||
vbox->Add(spectrumCanvas, 1, wxEXPAND | wxALL, 0);
|
||||
vbox->AddSpacer(2);
|
||||
waterfallCanvas = new WaterfallCanvas(this, NULL);
|
||||
waterfallCanvas->Setup(2048, 512);
|
||||
waterfallCanvas->setup(2048, 512);
|
||||
waterfallCanvas->attachSpectrumCanvas(spectrumCanvas);
|
||||
spectrumCanvas->attachWaterfallCanvas(waterfallCanvas);
|
||||
vbox->Add(waterfallCanvas, 4, wxEXPAND | wxALL, 0);
|
||||
@ -101,33 +101,33 @@ AppFrame::AppFrame() :
|
||||
|
||||
for (devices_i = devices.begin(); devices_i != devices.end(); devices_i++) {
|
||||
if (devices_i->inputChannels) {
|
||||
input_devices[i] = *devices_i;
|
||||
inputDevices[i] = *devices_i;
|
||||
}
|
||||
if (devices_i->outputChannels) {
|
||||
output_devices[i] = *devices_i;
|
||||
outputDevices[i] = *devices_i;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
|
||||
for (mdevices_i = output_devices.begin(); mdevices_i != output_devices.end(); mdevices_i++) {
|
||||
for (mdevices_i = outputDevices.begin(); mdevices_i != outputDevices.end(); mdevices_i++) {
|
||||
wxMenuItem *itm = menu->AppendRadioItem(wxID_RT_AUDIO_DEVICE + mdevices_i->first, mdevices_i->second.name, wxT("Description?"));
|
||||
itm->SetId(wxID_RT_AUDIO_DEVICE + mdevices_i->first);
|
||||
if (mdevices_i->second.isDefaultOutput) {
|
||||
itm->Check(true);
|
||||
}
|
||||
output_device_menuitems[mdevices_i->first] = itm;
|
||||
outputDeviceMenuItems[mdevices_i->first] = itm;
|
||||
}
|
||||
|
||||
wxMenuBar *menuBar = new wxMenuBar;
|
||||
menuBar->Append(menu, wxT("Active Demodulator &Output"));
|
||||
|
||||
wxMenu *demodMenu = new wxMenu;
|
||||
demod_menuitems[DEMOD_TYPE_FM] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_FM, wxT("FM"), wxT("Description?"));
|
||||
demod_menuitems[DEMOD_TYPE_AM] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_AM, wxT("AM"), wxT("Description?"));
|
||||
demod_menuitems[DEMOD_TYPE_LSB] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_LSB, wxT("LSB"), wxT("Description?"));
|
||||
demod_menuitems[DEMOD_TYPE_USB] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_USB, wxT("USB"), wxT("Description?"));
|
||||
demodMenuItems[DEMOD_TYPE_FM] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_FM, wxT("FM"), wxT("Description?"));
|
||||
demodMenuItems[DEMOD_TYPE_AM] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_AM, wxT("AM"), wxT("Description?"));
|
||||
demodMenuItems[DEMOD_TYPE_LSB] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_LSB, wxT("LSB"), wxT("Description?"));
|
||||
demodMenuItems[DEMOD_TYPE_USB] = demodMenu->AppendRadioItem(wxID_DEMOD_TYPE_USB, wxT("USB"), wxT("Description?"));
|
||||
|
||||
menuBar->Append(demodMenu, wxT("Active Demodulator &Type"));
|
||||
|
||||
@ -200,15 +200,15 @@ void AppFrame::OnIdle(wxIdleEvent& event) {
|
||||
if (demod != activeDemodulator) {
|
||||
demodSignalMeter->setInputValue(demod->getSquelchLevel());
|
||||
int outputDevice = demod->getOutputDevice();
|
||||
scopeCanvas->setDeviceName(output_devices[outputDevice].name);
|
||||
output_device_menuitems[outputDevice]->Check(true);
|
||||
scopeCanvas->setDeviceName(outputDevices[outputDevice].name);
|
||||
outputDeviceMenuItems[outputDevice]->Check(true);
|
||||
int dType = demod->getDemodulatorType();
|
||||
demod_menuitems[dType]->Check(true);
|
||||
demodMenuItems[dType]->Check(true);
|
||||
}
|
||||
if (demodWaterfallCanvas->getDragState() == WaterfallCanvas::WF_DRAG_NONE) {
|
||||
if (demod->getParams().frequency != demodWaterfallCanvas->GetCenterFrequency()) {
|
||||
demodWaterfallCanvas->SetCenterFrequency(demod->getParams().frequency);
|
||||
demodSpectrumCanvas->SetCenterFrequency(demod->getParams().frequency);
|
||||
if (demod->getParams().frequency != demodWaterfallCanvas->getCenterFrequency()) {
|
||||
demodWaterfallCanvas->setCenterFrequency(demod->getParams().frequency);
|
||||
demodSpectrumCanvas->setCenterFrequency(demod->getParams().frequency);
|
||||
}
|
||||
unsigned int demodBw = (unsigned int) ceil((float) demod->getParams().bandwidth * 2.5);
|
||||
if (demodBw > SRATE / 2) {
|
||||
@ -217,8 +217,8 @@ void AppFrame::OnIdle(wxIdleEvent& event) {
|
||||
if (demodBw < 80000) {
|
||||
demodBw = 80000;
|
||||
}
|
||||
demodWaterfallCanvas->SetBandwidth(demodBw);
|
||||
demodSpectrumCanvas->SetBandwidth(demodBw);
|
||||
demodWaterfallCanvas->setBandwidth(demodBw);
|
||||
demodSpectrumCanvas->setBandwidth(demodBw);
|
||||
}
|
||||
demodSignalMeter->setLevel(demod->getSignalLevel());
|
||||
if (demodSignalMeter->inputChanged()) {
|
||||
|
@ -41,11 +41,11 @@ private:
|
||||
DemodulatorInstance *activeDemodulator;
|
||||
|
||||
std::vector<RtAudio::DeviceInfo> devices;
|
||||
std::map<int,RtAudio::DeviceInfo> input_devices;
|
||||
std::map<int,RtAudio::DeviceInfo> output_devices;
|
||||
std::map<int,wxMenuItem *> output_device_menuitems;
|
||||
std::map<int,RtAudio::DeviceInfo> inputDevices;
|
||||
std::map<int,RtAudio::DeviceInfo> outputDevices;
|
||||
std::map<int,wxMenuItem *> outputDeviceMenuItems;
|
||||
|
||||
std::map<int,wxMenuItem *> demod_menuitems;
|
||||
std::map<int,wxMenuItem *> demodMenuItems;
|
||||
|
||||
wxDECLARE_EVENT_TABLE();
|
||||
};
|
||||
|
@ -10,7 +10,7 @@ std::map<int, std::thread *> AudioThread::deviceThread;
|
||||
#endif
|
||||
|
||||
AudioThread::AudioThread(AudioThreadInputQueue *inputQueue, DemodulatorThreadCommandQueue* threadQueueNotify) :
|
||||
currentInput(NULL), inputQueue(inputQueue), audio_queue_ptr(0), underflow_count(0), terminated(false), active(false), output_device(-1), gain(1.0), threadQueueNotify(
|
||||
currentInput(NULL), inputQueue(inputQueue), audioQueuePtr(0), underflowCount(0), terminated(false), active(false), outputDevice(-1), gain(1.0), threadQueueNotify(
|
||||
threadQueueNotify) {
|
||||
#ifdef __APPLE__
|
||||
boundThreads = new std::vector<AudioThread *>;
|
||||
@ -52,7 +52,7 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
float *out = (float*) outputBuffer;
|
||||
memset(out, 0, nBufferFrames * 2 * sizeof(float));
|
||||
if (status) {
|
||||
std::cout << "Audio buffer underflow.." << (src->underflow_count++) << std::endl;
|
||||
std::cout << "Audio buffer underflow.." << (src->underflowCount++) << std::endl;
|
||||
}
|
||||
|
||||
if (!src->boundThreads.load()->empty()) {
|
||||
@ -72,7 +72,7 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
continue;
|
||||
}
|
||||
srcmix->inputQueue->pop(srcmix->currentInput);
|
||||
srcmix->audio_queue_ptr = 0;
|
||||
srcmix->audioQueuePtr = 0;
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -88,14 +88,14 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
continue;
|
||||
}
|
||||
srcmix->inputQueue->pop(srcmix->currentInput);
|
||||
srcmix->audio_queue_ptr = 0;
|
||||
srcmix->audioQueuePtr = 0;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (srcmix->currentInput->channels == 1) {
|
||||
for (int i = 0; i < nBufferFrames; i++) {
|
||||
if (srcmix->audio_queue_ptr >= srcmix->currentInput->data.size()) {
|
||||
if (srcmix->audioQueuePtr >= srcmix->currentInput->data.size()) {
|
||||
if (srcmix->currentInput) {
|
||||
srcmix->currentInput->decRefCount();
|
||||
srcmix->currentInput = NULL;
|
||||
@ -104,18 +104,18 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
continue;
|
||||
}
|
||||
srcmix->inputQueue->pop(srcmix->currentInput);
|
||||
srcmix->audio_queue_ptr = 0;
|
||||
srcmix->audioQueuePtr = 0;
|
||||
}
|
||||
if (srcmix->currentInput && srcmix->currentInput->data.size()) {
|
||||
float v = srcmix->currentInput->data[srcmix->audio_queue_ptr] * src->gain;
|
||||
float v = srcmix->currentInput->data[srcmix->audioQueuePtr] * src->gain;
|
||||
out[i * 2] += v;
|
||||
out[i * 2 + 1] += v;
|
||||
}
|
||||
srcmix->audio_queue_ptr++;
|
||||
srcmix->audioQueuePtr++;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0, iMax = srcmix->currentInput->channels * nBufferFrames; i < iMax; i++) {
|
||||
if (srcmix->audio_queue_ptr >= srcmix->currentInput->data.size()) {
|
||||
if (srcmix->audioQueuePtr >= srcmix->currentInput->data.size()) {
|
||||
if (srcmix->currentInput) {
|
||||
srcmix->currentInput->decRefCount();
|
||||
srcmix->currentInput = NULL;
|
||||
@ -124,12 +124,12 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
continue;
|
||||
}
|
||||
srcmix->inputQueue->pop(srcmix->currentInput);
|
||||
srcmix->audio_queue_ptr = 0;
|
||||
srcmix->audioQueuePtr = 0;
|
||||
}
|
||||
if (srcmix->currentInput && srcmix->currentInput->data.size()) {
|
||||
out[i] = out[i] + srcmix->currentInput->data[srcmix->audio_queue_ptr] * src->gain;
|
||||
out[i] = out[i] + srcmix->currentInput->data[srcmix->audioQueuePtr] * src->gain;
|
||||
}
|
||||
srcmix->audio_queue_ptr++;
|
||||
srcmix->audioQueuePtr++;
|
||||
}
|
||||
}
|
||||
|
||||
@ -146,12 +146,12 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
float *out = (float*) outputBuffer;
|
||||
memset(out, 0, nBufferFrames * 2 * sizeof(float));
|
||||
if (status) {
|
||||
std::cout << "Audio buffer underflow.." << (src->underflow_count++) << std::endl;
|
||||
std::cout << "Audio buffer underflow.." << (src->underflowCount++) << std::endl;
|
||||
}
|
||||
|
||||
if (!src->currentInput) {
|
||||
src->inputQueue->pop(src->currentInput);
|
||||
src->audio_queue_ptr = 0;
|
||||
src->audioQueuePtr = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -167,14 +167,14 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
return 1;
|
||||
}
|
||||
src->inputQueue->pop(src->currentInput);
|
||||
src->audio_queue_ptr = 0;
|
||||
src->audioQueuePtr = 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (src->currentInput->channels == 1) {
|
||||
for (int i = 0; i < nBufferFrames; i++) {
|
||||
if (src->audio_queue_ptr >= src->currentInput->data.size()) {
|
||||
if (src->audioQueuePtr >= src->currentInput->data.size()) {
|
||||
if (src->currentInput) {
|
||||
src->currentInput->decRefCount();
|
||||
src->currentInput = NULL;
|
||||
@ -183,16 +183,16 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
return 1;
|
||||
}
|
||||
src->inputQueue->pop(src->currentInput);
|
||||
src->audio_queue_ptr = 0;
|
||||
src->audioQueuePtr = 0;
|
||||
}
|
||||
if (src->currentInput && src->currentInput->data.size()) {
|
||||
out[i * 2] = out[i * 2 + 1] = src->currentInput->data[src->audio_queue_ptr] * src->gain;
|
||||
out[i * 2] = out[i * 2 + 1] = src->currentInput->data[src->audioQueuePtr] * src->gain;
|
||||
}
|
||||
src->audio_queue_ptr++;
|
||||
src->audioQueuePtr++;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0, iMax = src->currentInput->channels * nBufferFrames; i < iMax; i++) {
|
||||
if (src->audio_queue_ptr >= src->currentInput->data.size()) {
|
||||
if (src->audioQueuePtr >= src->currentInput->data.size()) {
|
||||
if (src->currentInput) {
|
||||
src->currentInput->decRefCount();
|
||||
src->currentInput = NULL;
|
||||
@ -201,12 +201,12 @@ static int audioCallback(void *outputBuffer, void *inputBuffer, unsigned int nBu
|
||||
return 1;
|
||||
}
|
||||
src->inputQueue->pop(src->currentInput);
|
||||
src->audio_queue_ptr = 0;
|
||||
src->audioQueuePtr = 0;
|
||||
}
|
||||
if (src->currentInput && src->currentInput->data.size()) {
|
||||
out[i] = src->currentInput->data[src->audio_queue_ptr] * src->gain;
|
||||
out[i] = src->currentInput->data[src->audioQueuePtr] * src->gain;
|
||||
}
|
||||
src->audio_queue_ptr++;
|
||||
src->audioQueuePtr++;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
@ -278,8 +278,8 @@ void AudioThread::setupDevice(int deviceId) {
|
||||
try {
|
||||
|
||||
#ifdef __APPLE__
|
||||
if (deviceController.find(output_device.load()) != deviceController.end()) {
|
||||
deviceController[output_device.load()]->removeThread(this);
|
||||
if (deviceController.find(outputDevice.load()) != deviceController.end()) {
|
||||
deviceController[outputDevice.load()]->removeThread(this);
|
||||
}
|
||||
|
||||
opts.priority = sched_get_priority_max(SCHED_FIFO);
|
||||
@ -315,18 +315,18 @@ void AudioThread::setupDevice(int deviceId) {
|
||||
return;
|
||||
}
|
||||
|
||||
output_device = deviceId;
|
||||
outputDevice = deviceId;
|
||||
}
|
||||
|
||||
int AudioThread::getOutputDevice() {
|
||||
if (output_device == -1) {
|
||||
if (outputDevice == -1) {
|
||||
return dac.getDefaultOutputDevice();
|
||||
}
|
||||
return output_device;
|
||||
return outputDevice;
|
||||
}
|
||||
|
||||
void AudioThread::setInitOutputDevice(int deviceId) {
|
||||
output_device = deviceId;
|
||||
outputDevice = deviceId;
|
||||
}
|
||||
|
||||
void AudioThread::threadMain() {
|
||||
@ -344,7 +344,7 @@ void AudioThread::threadMain() {
|
||||
return;
|
||||
}
|
||||
|
||||
setupDevice((output_device.load() == -1)?(dac.getDefaultOutputDevice()):output_device.load());
|
||||
setupDevice((outputDevice.load() == -1)?(dac.getDefaultOutputDevice()):outputDevice.load());
|
||||
|
||||
std::cout << "Audio thread started." << std::endl;
|
||||
|
||||
|
@ -57,11 +57,11 @@ public:
|
||||
|
||||
AudioThreadInput *currentInput;
|
||||
AudioThreadInputQueue *inputQueue;
|
||||
std::atomic<unsigned int> audio_queue_ptr;
|
||||
std::atomic<unsigned int> underflow_count;
|
||||
std::atomic<unsigned int> audioQueuePtr;
|
||||
std::atomic<unsigned int> underflowCount;
|
||||
std::atomic<bool> terminated;
|
||||
std::atomic<bool> active;
|
||||
std::atomic<int> output_device;
|
||||
std::atomic<int> outputDevice;
|
||||
float gain;
|
||||
|
||||
AudioThread(AudioThreadInputQueue *inputQueue, DemodulatorThreadCommandQueue* threadQueueNotify);
|
||||
|
@ -44,7 +44,7 @@ public:
|
||||
class DemodulatorThreadControlCommand {
|
||||
public:
|
||||
enum DemodulatorThreadControlCommandEnum {
|
||||
DEMOD_THREAD_CMD_CTL_NULL, DEMOD_THREAD_CMD_CTL_SQUELCH_AUTO, DEMOD_THREAD_CMD_CTL_SQUELCH_OFF, DEMOD_THREAD_CMD_CTL_TYPE
|
||||
DEMOD_THREAD_CMD_CTL_NULL, DEMOD_THREAD_CMD_CTL_SQUELCH_ON, DEMOD_THREAD_CMD_CTL_SQUELCH_OFF, DEMOD_THREAD_CMD_CTL_TYPE
|
||||
};
|
||||
|
||||
DemodulatorThreadControlCommand() :
|
||||
@ -75,14 +75,14 @@ class DemodulatorThreadPostIQData: public ReferenceCounter {
|
||||
public:
|
||||
std::vector<liquid_float_complex> data;
|
||||
int bandwidth;
|
||||
double audio_resample_ratio;
|
||||
msresamp_rrrf audio_resampler;
|
||||
msresamp_rrrf stereo_resampler;
|
||||
double resample_ratio;
|
||||
msresamp_crcf resampler;
|
||||
double resamplerRatio;
|
||||
msresamp_rrrf audioResampler;
|
||||
msresamp_rrrf stereoResampler;
|
||||
double audioResampleRatio;
|
||||
|
||||
DemodulatorThreadPostIQData() :
|
||||
bandwidth(0), audio_resample_ratio(0), audio_resampler(NULL), stereo_resampler(NULL), resample_ratio(0), resampler(NULL) {
|
||||
bandwidth(0), resampler(NULL), resamplerRatio(0), audioResampler(NULL), stereoResampler(NULL), audioResampleRatio(0) {
|
||||
|
||||
}
|
||||
|
||||
|
@ -18,7 +18,7 @@ DemodulatorInstance::DemodulatorInstance() :
|
||||
audioInputQueue = new AudioThreadInputQueue;
|
||||
audioThread = new AudioThread(audioInputQueue, threadQueueNotify);
|
||||
|
||||
demodulatorThread->setAudioInputQueue(audioInputQueue);
|
||||
demodulatorThread->setAudioOutputQueue(audioInputQueue);
|
||||
|
||||
currentDemodType = demodulatorThread->getDemodulatorType();
|
||||
}
|
||||
@ -160,7 +160,7 @@ void DemodulatorInstance::setStereo(bool state) {
|
||||
|
||||
void DemodulatorInstance::squelchAuto() {
|
||||
DemodulatorThreadControlCommand command;
|
||||
command.cmd = DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_AUTO;
|
||||
command.cmd = DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_ON;
|
||||
threadQueueControl->push(command);
|
||||
squelch = true;
|
||||
}
|
||||
@ -176,7 +176,7 @@ void DemodulatorInstance::setSquelchEnabled(bool state) {
|
||||
threadQueueControl->push(command);
|
||||
} else if (state && !squelch) {
|
||||
DemodulatorThreadControlCommand command;
|
||||
command.cmd = DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_AUTO;
|
||||
command.cmd = DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_ON;
|
||||
threadQueueControl->push(command);
|
||||
}
|
||||
|
||||
|
@ -7,18 +7,14 @@
|
||||
|
||||
#include "DemodulatorPreThread.h"
|
||||
|
||||
DemodulatorPreThread::DemodulatorPreThread(DemodulatorThreadInputQueue* pQueueIn, DemodulatorThreadPostInputQueue* pQueueOut,
|
||||
DemodulatorPreThread::DemodulatorPreThread(DemodulatorThreadInputQueue* iqInputQueue, DemodulatorThreadPostInputQueue* iqOutputQueue,
|
||||
DemodulatorThreadControlCommandQueue *threadQueueControl, DemodulatorThreadCommandQueue* threadQueueNotify) :
|
||||
inputQueue(pQueueIn), postInputQueue(pQueueOut), terminated(false), initialized(false), audio_resampler(NULL), stereo_resampler(NULL), resample_ratio(
|
||||
1), audio_resample_ratio(1), resampler(NULL), commandQueue(NULL), audioInputQueue(NULL), threadQueueNotify(threadQueueNotify), threadQueueControl(
|
||||
iqInputQueue(iqInputQueue), iqOutputQueue(iqOutputQueue), terminated(false), initialized(false), audioResampler(NULL), stereoResampler(NULL), iqResampleRatio(
|
||||
1), audioResampleRatio(1), iqResampler(NULL), commandQueue(NULL), threadQueueNotify(threadQueueNotify), threadQueueControl(
|
||||
threadQueueControl) {
|
||||
|
||||
float kf = 0.5; // modulation factor
|
||||
fdem = freqdem_create(kf);
|
||||
// freqdem_print(fdem);
|
||||
|
||||
nco_shift = nco_crcf_create(LIQUID_VCO);
|
||||
shift_freq = 0;
|
||||
freqShifter = nco_crcf_create(LIQUID_VCO);
|
||||
shiftFrequency = 0;
|
||||
|
||||
workerQueue = new DemodulatorThreadWorkerCommandQueue;
|
||||
workerResults = new DemodulatorThreadWorkerResultQueue;
|
||||
@ -30,18 +26,18 @@ DemodulatorPreThread::DemodulatorPreThread(DemodulatorThreadInputQueue* pQueueIn
|
||||
void DemodulatorPreThread::initialize() {
|
||||
initialized = false;
|
||||
|
||||
resample_ratio = (double) (params.bandwidth) / (double) params.inputRate;
|
||||
audio_resample_ratio = (double) (params.audioSampleRate) / (double) params.bandwidth;
|
||||
iqResampleRatio = (double) (params.bandwidth) / (double) params.inputRate;
|
||||
audioResampleRatio = (double) (params.audioSampleRate) / (double) params.bandwidth;
|
||||
|
||||
float As = 60.0f; // stop-band attenuation [dB]
|
||||
float As = 120.0f; // stop-band attenuation [dB]
|
||||
|
||||
resampler = msresamp_crcf_create(resample_ratio, As);
|
||||
audio_resampler = msresamp_rrrf_create(audio_resample_ratio, As);
|
||||
stereo_resampler = msresamp_rrrf_create(audio_resample_ratio, As);
|
||||
iqResampler = msresamp_crcf_create(iqResampleRatio, As);
|
||||
audioResampler = msresamp_rrrf_create(audioResampleRatio, As);
|
||||
stereoResampler = msresamp_rrrf_create(audioResampleRatio, As);
|
||||
|
||||
initialized = true;
|
||||
// std::cout << "inputResampleRate " << params.bandwidth << std::endl;
|
||||
last_params = params;
|
||||
lastParams = params;
|
||||
}
|
||||
|
||||
DemodulatorPreThread::~DemodulatorPreThread() {
|
||||
@ -76,7 +72,7 @@ void DemodulatorPreThread::threadMain() {
|
||||
|
||||
while (!terminated) {
|
||||
DemodulatorThreadIQData *inp;
|
||||
inputQueue->pop(inp);
|
||||
iqInputQueue->pop(inp);
|
||||
|
||||
bool bandwidthChanged = false;
|
||||
DemodulatorThreadParameters bandwidthParams = params;
|
||||
@ -120,15 +116,15 @@ void DemodulatorPreThread::threadMain() {
|
||||
|
||||
// Requested frequency is not center, shift it into the center!
|
||||
if (inp->frequency != params.frequency) {
|
||||
if ((params.frequency - inp->frequency) != shift_freq) {
|
||||
shift_freq = params.frequency - inp->frequency;
|
||||
if (abs(shift_freq) <= (int) ((double) (SRATE / 2) * 1.5)) {
|
||||
nco_crcf_set_frequency(nco_shift, (2.0 * M_PI) * (((double) abs(shift_freq)) / ((double) SRATE)));
|
||||
if ((params.frequency - inp->frequency) != shiftFrequency) {
|
||||
shiftFrequency = params.frequency - inp->frequency;
|
||||
if (abs(shiftFrequency) <= (int) ((double) (SRATE / 2) * 1.5)) {
|
||||
nco_crcf_set_frequency(freqShifter, (2.0 * M_PI) * (((double) abs(shiftFrequency)) / ((double) SRATE)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (abs(shift_freq) > (int) ((double) (SRATE / 2) * 1.5)) {
|
||||
if (abs(shiftFrequency) > (int) ((double) (SRATE / 2) * 1.5)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -152,11 +148,11 @@ void DemodulatorPreThread::threadMain() {
|
||||
liquid_float_complex *out_buf = &out_buf_data[0];
|
||||
liquid_float_complex *temp_buf = NULL;
|
||||
|
||||
if (shift_freq != 0) {
|
||||
if (shift_freq < 0) {
|
||||
nco_crcf_mix_block_up(nco_shift, in_buf, out_buf, bufSize);
|
||||
if (shiftFrequency != 0) {
|
||||
if (shiftFrequency < 0) {
|
||||
nco_crcf_mix_block_up(freqShifter, in_buf, out_buf, bufSize);
|
||||
} else {
|
||||
nco_crcf_mix_block_down(nco_shift, in_buf, out_buf, bufSize);
|
||||
nco_crcf_mix_block_down(freqShifter, in_buf, out_buf, bufSize);
|
||||
}
|
||||
temp_buf = in_buf;
|
||||
in_buf = out_buf;
|
||||
@ -182,14 +178,14 @@ void DemodulatorPreThread::threadMain() {
|
||||
|
||||
// firfilt_crcf_execute_block(fir_filter, in_buf, bufSize, &((*resamp.data)[0]));
|
||||
|
||||
resamp->audio_resample_ratio = audio_resample_ratio;
|
||||
resamp->audio_resampler = audio_resampler;
|
||||
resamp->stereo_resampler = stereo_resampler;
|
||||
resamp->resample_ratio = resample_ratio;
|
||||
resamp->resampler = resampler;
|
||||
resamp->audioResampleRatio = audioResampleRatio;
|
||||
resamp->audioResampler = audioResampler;
|
||||
resamp->stereoResampler = stereoResampler;
|
||||
resamp->resamplerRatio = iqResampleRatio;
|
||||
resamp->resampler = iqResampler;
|
||||
resamp->bandwidth = params.bandwidth;
|
||||
|
||||
postInputQueue->push(resamp);
|
||||
iqOutputQueue->push(resamp);
|
||||
}
|
||||
|
||||
inp->decRefCount();
|
||||
@ -201,12 +197,12 @@ void DemodulatorPreThread::threadMain() {
|
||||
|
||||
switch (result.cmd) {
|
||||
case DemodulatorWorkerThreadResult::DEMOD_WORKER_THREAD_RESULT_FILTERS:
|
||||
resampler = result.resampler;
|
||||
audio_resampler = result.audio_resampler;
|
||||
stereo_resampler = result.stereo_resampler;
|
||||
iqResampler = result.resampler;
|
||||
audioResampler = result.audioResampler;
|
||||
stereoResampler = result.stereoResampler;
|
||||
|
||||
resample_ratio = result.resample_ratio;
|
||||
audio_resample_ratio = result.audio_resample_ratio;
|
||||
iqResampleRatio = result.resamplerRatio;
|
||||
audioResampleRatio = result.audioResamplerRatio;
|
||||
|
||||
params.audioSampleRate = result.audioSampleRate;
|
||||
params.bandwidth = result.bandwidth;
|
||||
@ -233,6 +229,6 @@ void DemodulatorPreThread::threadMain() {
|
||||
void DemodulatorPreThread::terminate() {
|
||||
terminated = true;
|
||||
DemodulatorThreadIQData *inp = new DemodulatorThreadIQData; // push dummy to nudge queue
|
||||
inputQueue->push(inp);
|
||||
iqInputQueue->push(inp);
|
||||
workerThread->terminate();
|
||||
}
|
||||
|
@ -10,7 +10,7 @@
|
||||
class DemodulatorPreThread {
|
||||
public:
|
||||
|
||||
DemodulatorPreThread(DemodulatorThreadInputQueue* pQueueIn, DemodulatorThreadPostInputQueue* pQueueOut,
|
||||
DemodulatorPreThread(DemodulatorThreadInputQueue* iqInputQueue, DemodulatorThreadPostInputQueue* iqOutputQueue,
|
||||
DemodulatorThreadControlCommandQueue *threadQueueControl, DemodulatorThreadCommandQueue* threadQueueNotify);
|
||||
~DemodulatorPreThread();
|
||||
|
||||
@ -24,10 +24,6 @@ public:
|
||||
commandQueue = tQueue;
|
||||
}
|
||||
|
||||
void setAudioInputQueue(AudioThreadInputQueue *tQueue) {
|
||||
audioInputQueue = tQueue;
|
||||
}
|
||||
|
||||
void setDemodulatorControlQueue(DemodulatorThreadControlCommandQueue *tQueue) {
|
||||
threadQueueControl = tQueue;
|
||||
}
|
||||
@ -37,7 +33,6 @@ public:
|
||||
}
|
||||
|
||||
void initialize();
|
||||
|
||||
void terminate();
|
||||
|
||||
#ifdef __APPLE__
|
||||
@ -47,24 +42,22 @@ public:
|
||||
#endif
|
||||
|
||||
protected:
|
||||
DemodulatorThreadInputQueue* inputQueue;
|
||||
DemodulatorThreadPostInputQueue* postInputQueue;
|
||||
DemodulatorThreadInputQueue* iqInputQueue;
|
||||
DemodulatorThreadPostInputQueue* iqOutputQueue;
|
||||
DemodulatorThreadCommandQueue* commandQueue;
|
||||
AudioThreadInputQueue *audioInputQueue;
|
||||
|
||||
msresamp_crcf resampler;
|
||||
double resample_ratio;
|
||||
msresamp_crcf iqResampler;
|
||||
double iqResampleRatio;
|
||||
|
||||
msresamp_rrrf audio_resampler;
|
||||
msresamp_rrrf stereo_resampler;
|
||||
double audio_resample_ratio;
|
||||
msresamp_rrrf audioResampler;
|
||||
msresamp_rrrf stereoResampler;
|
||||
double audioResampleRatio;
|
||||
|
||||
DemodulatorThreadParameters params;
|
||||
DemodulatorThreadParameters last_params;
|
||||
DemodulatorThreadParameters lastParams;
|
||||
|
||||
freqdem fdem;
|
||||
nco_crcf nco_shift;
|
||||
int shift_freq;
|
||||
nco_crcf freqShifter;
|
||||
int shiftFrequency;
|
||||
|
||||
std::atomic<bool> terminated;
|
||||
std::atomic<bool> initialized;
|
||||
|
@ -6,17 +6,18 @@
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
DemodulatorThread::DemodulatorThread(DemodulatorThreadPostInputQueue* pQueue, DemodulatorThreadControlCommandQueue *threadQueueControl,
|
||||
DemodulatorThread::DemodulatorThread(DemodulatorThreadPostInputQueue* iqInputQueue, DemodulatorThreadControlCommandQueue *threadQueueControl,
|
||||
DemodulatorThreadCommandQueue* threadQueueNotify) :
|
||||
postInputQueue(pQueue), visOutQueue(NULL), audioInputQueue(NULL), agc(NULL), am_max(1), am_max_ma(1), am_max_maa(1), stereo(false), terminated(
|
||||
false), demodulatorType(DEMOD_TYPE_FM), threadQueueNotify(threadQueueNotify), threadQueueControl(threadQueueControl), squelch_level(0), squelch_tolerance(
|
||||
0), signal_level(0), squelch_enabled(false) {
|
||||
iqInputQueue(iqInputQueue), audioVisOutputQueue(NULL), audioOutputQueue(NULL), iqAutoGain(NULL), amOutputCeil(1), amOutputCeilMA(1), amOutputCeilMAA(
|
||||
1), stereo(false), terminated(
|
||||
false), demodulatorType(DEMOD_TYPE_FM), threadQueueNotify(threadQueueNotify), threadQueueControl(threadQueueControl), squelchLevel(0), signalLevel(
|
||||
0), squelchEnabled(false) {
|
||||
|
||||
fdem = freqdem_create(0.5);
|
||||
ampdem_lsb = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_LSB, 1);
|
||||
ampdem_usb = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_USB, 1);
|
||||
ampdem = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_DSB, 0);
|
||||
ampdem_active = ampdem;
|
||||
demodFM = freqdem_create(0.5);
|
||||
demodAM_USB = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_LSB, 1);
|
||||
demodAM_LSB = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_USB, 1);
|
||||
demodAM_DSB_CSP = ampmodem_create(0.5, 0.0, LIQUID_AMPMODEM_DSB, 0);
|
||||
demodAM = demodAM_DSB_CSP;
|
||||
|
||||
}
|
||||
DemodulatorThread::~DemodulatorThread() {
|
||||
@ -34,64 +35,66 @@ void DemodulatorThread::threadMain() {
|
||||
pthread_setschedparam(tID, SCHED_FIFO, &prio);
|
||||
#endif
|
||||
|
||||
msresamp_rrrf audio_resampler = NULL;
|
||||
msresamp_rrrf stereo_resampler = NULL;
|
||||
firfilt_rrrf fir_filter = NULL;
|
||||
firfilt_rrrf fir_filter2 = NULL;
|
||||
msresamp_crcf resampler = NULL;
|
||||
msresamp_rrrf audioResampler = NULL;
|
||||
msresamp_rrrf stereoResampler = NULL;
|
||||
firfilt_rrrf firStereoLeft = NULL;
|
||||
firfilt_rrrf firStereoRight = NULL;
|
||||
|
||||
double fc = 0.5 * ((double) 36000 / (double) AUDIO_FREQUENCY); // filter cutoff frequency
|
||||
if (fc <= 0) {
|
||||
fc = 0;
|
||||
}
|
||||
if (fc >= 0.5) {
|
||||
fc = 0.5;
|
||||
}
|
||||
// Stereo filters / shifters
|
||||
double firStereoCutoff = 0.5 * ((double) 36000 / (double) AUDIO_FREQUENCY); // filter cutoff frequency
|
||||
float ft = 0.05f; // filter transition
|
||||
float As = 60.0f; // stop-band attenuation [dB]
|
||||
float As = 120.0f; // stop-band attenuation [dB]
|
||||
float mu = 0.0f; // fractional timing offset
|
||||
// estimate required filter length and generate filter
|
||||
|
||||
if (firStereoCutoff < 0) {
|
||||
firStereoCutoff = 0;
|
||||
}
|
||||
|
||||
if (firStereoCutoff > 0.5) {
|
||||
firStereoCutoff = 0.5;
|
||||
}
|
||||
|
||||
unsigned int h_len = estimate_req_filter_len(ft, As);
|
||||
float h[h_len];
|
||||
liquid_firdes_kaiser(h_len, fc, As, mu, h);
|
||||
fir_filter = firfilt_rrrf_create(h, h_len);
|
||||
fir_filter2 = firfilt_rrrf_create(h, h_len);
|
||||
liquid_firdes_kaiser(h_len, firStereoCutoff, As, mu, h);
|
||||
|
||||
firStereoLeft = firfilt_rrrf_create(h, h_len);
|
||||
firStereoRight = firfilt_rrrf_create(h, h_len);
|
||||
|
||||
unsigned int m = 5; // filter semi-length
|
||||
float slsl = 60.0f; // filter sidelobe suppression level
|
||||
liquid_float_complex x, y;
|
||||
|
||||
firhilbf firR2C = firhilbf_create(m, slsl);
|
||||
firhilbf firC2R = firhilbf_create(m, slsl);
|
||||
firhilbf firStereoR2C = firhilbf_create(5, 60.0f);
|
||||
firhilbf firStereoC2R = firhilbf_create(5, 60.0f);
|
||||
|
||||
nco_crcf nco_stereo_shift = nco_crcf_create(LIQUID_NCO);
|
||||
double nco_stereo_shift_freq = 0;
|
||||
nco_crcf stereoShifter = nco_crcf_create(LIQUID_NCO);
|
||||
double stereoShiftFrequency = 0;
|
||||
|
||||
nco_crcf nco_ssb_shift_up = nco_crcf_create(LIQUID_NCO);
|
||||
nco_crcf_set_frequency(nco_ssb_shift_up, (2.0 * M_PI) * 0.25);
|
||||
// SSB Half-band filter
|
||||
nco_crcf ssbShifterUp = nco_crcf_create(LIQUID_NCO);
|
||||
nco_crcf_set_frequency(ssbShifterUp, (2.0 * M_PI) * 0.25);
|
||||
|
||||
nco_crcf ssbShifterDown = nco_crcf_create(LIQUID_NCO);
|
||||
nco_crcf_set_frequency(ssbShifterDown, (2.0 * M_PI) * 0.25);
|
||||
|
||||
nco_crcf nco_ssb_shift_down = nco_crcf_create(LIQUID_NCO);
|
||||
nco_crcf_set_frequency(nco_ssb_shift_down, (2.0 * M_PI) * 0.25);
|
||||
float ssbFt = 0.001f; // filter transition
|
||||
float ssbAs = 120.0f; // stop-band attenuation [dB]
|
||||
|
||||
// estimate required filter length and generate filter
|
||||
h_len = estimate_req_filter_len(ft,100.0);
|
||||
float h2[h_len];
|
||||
liquid_firdes_kaiser(h_len,0.25,As,0.0,h2);
|
||||
h_len = estimate_req_filter_len(ssbFt, ssbAs);
|
||||
float ssb_h[h_len];
|
||||
liquid_firdes_kaiser(h_len, 0.25, ssbAs, 0.0, ssb_h);
|
||||
|
||||
firfilt_crcf ssb_fir_filter = firfilt_crcf_create(h2, h_len);
|
||||
firfilt_crcf firSSB = firfilt_crcf_create(ssb_h, h_len);
|
||||
|
||||
|
||||
agc = agc_crcf_create();
|
||||
agc_crcf_set_bandwidth(agc, 0.9);
|
||||
// Automatic IQ gain
|
||||
iqAutoGain = agc_crcf_create();
|
||||
agc_crcf_set_bandwidth(iqAutoGain, 0.9);
|
||||
|
||||
std::cout << "Demodulator thread started.." << std::endl;
|
||||
|
||||
double freq_index = 0;
|
||||
|
||||
while (!terminated) {
|
||||
DemodulatorThreadPostIQData *inp;
|
||||
postInputQueue->pop(inp);
|
||||
iqInputQueue->pop(inp);
|
||||
std::lock_guard < std::mutex > lock(inp->m_mutex);
|
||||
|
||||
int bufSize = inp->data.size();
|
||||
@ -103,201 +106,201 @@ void DemodulatorThread::threadMain() {
|
||||
|
||||
if (resampler == NULL) {
|
||||
resampler = inp->resampler;
|
||||
audio_resampler = inp->audio_resampler;
|
||||
stereo_resampler = inp->stereo_resampler;
|
||||
audioResampler = inp->audioResampler;
|
||||
stereoResampler = inp->stereoResampler;
|
||||
} else if (resampler != inp->resampler) {
|
||||
msresamp_crcf_destroy(resampler);
|
||||
msresamp_rrrf_destroy(audio_resampler);
|
||||
msresamp_rrrf_destroy(stereo_resampler);
|
||||
msresamp_rrrf_destroy(audioResampler);
|
||||
msresamp_rrrf_destroy(stereoResampler);
|
||||
resampler = inp->resampler;
|
||||
audio_resampler = inp->audio_resampler;
|
||||
stereo_resampler = inp->stereo_resampler;
|
||||
audioResampler = inp->audioResampler;
|
||||
stereoResampler = inp->stereoResampler;
|
||||
|
||||
ampmodem_reset(ampdem_lsb);
|
||||
ampmodem_reset(ampdem_usb);
|
||||
ampmodem_reset(ampdem);
|
||||
freqdem_reset(fdem);
|
||||
ampmodem_reset(demodAM_USB);
|
||||
ampmodem_reset(demodAM_LSB);
|
||||
ampmodem_reset(demodAM_DSB_CSP);
|
||||
freqdem_reset(demodFM);
|
||||
}
|
||||
|
||||
int out_size = ceil((double) (bufSize) * inp->resample_ratio) + 512;
|
||||
int out_size = ceil((double) (bufSize) * inp->resamplerRatio) + 512;
|
||||
|
||||
if (agc_data.size() != out_size) {
|
||||
if (agc_data.capacity() < out_size) {
|
||||
agc_data.reserve(out_size);
|
||||
agc_am_data.reserve(out_size);
|
||||
resampled_data.reserve(out_size);
|
||||
if (agcData.size() != out_size) {
|
||||
if (agcData.capacity() < out_size) {
|
||||
agcData.reserve(out_size);
|
||||
agcAMData.reserve(out_size);
|
||||
resampledData.reserve(out_size);
|
||||
}
|
||||
agc_data.resize(out_size);
|
||||
resampled_data.resize(out_size);
|
||||
agc_am_data.resize(out_size);
|
||||
agcData.resize(out_size);
|
||||
resampledData.resize(out_size);
|
||||
agcAMData.resize(out_size);
|
||||
}
|
||||
|
||||
unsigned int num_written;
|
||||
msresamp_crcf_execute(resampler, &(inp->data[0]), bufSize, &resampled_data[0], &num_written);
|
||||
unsigned int numWritten;
|
||||
msresamp_crcf_execute(resampler, &(inp->data[0]), bufSize, &resampledData[0], &numWritten);
|
||||
|
||||
double audio_resample_ratio = inp->audio_resample_ratio;
|
||||
double audio_resample_ratio = inp->audioResampleRatio;
|
||||
|
||||
if (demod_output.size() != num_written) {
|
||||
if (demod_output.capacity() < num_written) {
|
||||
demod_output.reserve(num_written);
|
||||
if (demodOutputData.size() != numWritten) {
|
||||
if (demodOutputData.capacity() < numWritten) {
|
||||
demodOutputData.reserve(numWritten);
|
||||
}
|
||||
demod_output.resize(num_written);
|
||||
demodOutputData.resize(numWritten);
|
||||
}
|
||||
|
||||
int audio_out_size = ceil((double) (num_written) * audio_resample_ratio) + 512;
|
||||
int audio_out_size = ceil((double) (numWritten) * audio_resample_ratio) + 512;
|
||||
|
||||
agc_crcf_execute_block(agc, &resampled_data[0], num_written, &agc_data[0]);
|
||||
agc_crcf_execute_block(iqAutoGain, &resampledData[0], numWritten, &agcData[0]);
|
||||
|
||||
float current_level = 0;
|
||||
float currentSignalLevel = 0;
|
||||
|
||||
current_level = ((60.0 / fabs(agc_crcf_get_rssi(agc))) / 15.0 - signal_level);
|
||||
currentSignalLevel = ((60.0 / fabs(agc_crcf_get_rssi(iqAutoGain))) / 15.0 - signalLevel);
|
||||
|
||||
if (agc_crcf_get_signal_level(agc) > current_level) {
|
||||
current_level = agc_crcf_get_signal_level(agc);
|
||||
if (agc_crcf_get_signal_level(iqAutoGain) > currentSignalLevel) {
|
||||
currentSignalLevel = agc_crcf_get_signal_level(iqAutoGain);
|
||||
}
|
||||
|
||||
if (demodulatorType == DEMOD_TYPE_FM) {
|
||||
freqdem_demodulate_block(fdem, &agc_data[0], num_written, &demod_output[0]);
|
||||
freqdem_demodulate_block(demodFM, &agcData[0], numWritten, &demodOutputData[0]);
|
||||
} else {
|
||||
float p;
|
||||
switch (demodulatorType) {
|
||||
case DEMOD_TYPE_LSB:
|
||||
for (int i = 0; i < num_written; i++) { // Reject upper band
|
||||
nco_crcf_mix_up(nco_ssb_shift_up, resampled_data[i], &x);
|
||||
nco_crcf_step(nco_ssb_shift_up);
|
||||
firfilt_crcf_push(ssb_fir_filter, x);
|
||||
firfilt_crcf_execute(ssb_fir_filter, &x);
|
||||
nco_crcf_mix_down(nco_ssb_shift_down, x, &resampled_data[i]);
|
||||
nco_crcf_step(nco_ssb_shift_down);
|
||||
for (int i = 0; i < numWritten; i++) { // Reject upper band
|
||||
nco_crcf_mix_up(ssbShifterUp, resampledData[i], &x);
|
||||
nco_crcf_step(ssbShifterUp);
|
||||
firfilt_crcf_push(firSSB, x);
|
||||
firfilt_crcf_execute(firSSB, &x);
|
||||
nco_crcf_mix_down(ssbShifterDown, x, &resampledData[i]);
|
||||
nco_crcf_step(ssbShifterDown);
|
||||
}
|
||||
break;
|
||||
case DEMOD_TYPE_USB:
|
||||
for (int i = 0; i < num_written; i++) { // Reject lower band
|
||||
nco_crcf_mix_down(nco_ssb_shift_down, resampled_data[i], &x);
|
||||
nco_crcf_step(nco_ssb_shift_down);
|
||||
firfilt_crcf_push(ssb_fir_filter, x);
|
||||
firfilt_crcf_execute(ssb_fir_filter, &x);
|
||||
nco_crcf_mix_up(nco_ssb_shift_up, x, &resampled_data[i]);
|
||||
nco_crcf_step(nco_ssb_shift_up);
|
||||
for (int i = 0; i < numWritten; i++) { // Reject lower band
|
||||
nco_crcf_mix_down(ssbShifterDown, resampledData[i], &x);
|
||||
nco_crcf_step(ssbShifterDown);
|
||||
firfilt_crcf_push(firSSB, x);
|
||||
firfilt_crcf_execute(firSSB, &x);
|
||||
nco_crcf_mix_up(ssbShifterUp, x, &resampledData[i]);
|
||||
nco_crcf_step(ssbShifterUp);
|
||||
}
|
||||
break;
|
||||
case DEMOD_TYPE_AM:
|
||||
break;
|
||||
}
|
||||
|
||||
am_max = 0;
|
||||
amOutputCeil = 0;
|
||||
|
||||
for (int i = 0; i < num_written; i++) {
|
||||
ampmodem_demodulate(ampdem_active, resampled_data[i], &demod_output[i]);
|
||||
if (demod_output[i] > am_max) {
|
||||
am_max = demod_output[i];
|
||||
for (int i = 0; i < numWritten; i++) {
|
||||
ampmodem_demodulate(demodAM, resampledData[i], &demodOutputData[i]);
|
||||
if (demodOutputData[i] > amOutputCeil) {
|
||||
amOutputCeil = demodOutputData[i];
|
||||
}
|
||||
}
|
||||
am_max_ma = am_max_ma + (am_max - am_max_ma) * 0.05;
|
||||
am_max_maa = am_max_maa + (am_max_ma - am_max_maa) * 0.05;
|
||||
amOutputCeilMA = amOutputCeilMA + (amOutputCeil - amOutputCeilMA) * 0.05;
|
||||
amOutputCeilMAA = amOutputCeilMAA + (amOutputCeilMA - amOutputCeilMAA) * 0.05;
|
||||
|
||||
float gain = 0.95 / am_max_maa;
|
||||
float gain = 0.95 / amOutputCeilMAA;
|
||||
|
||||
for (int i = 0; i < num_written; i++) {
|
||||
demod_output[i] *= gain;
|
||||
for (int i = 0; i < numWritten; i++) {
|
||||
demodOutputData[i] *= gain;
|
||||
}
|
||||
}
|
||||
|
||||
if (audio_out_size != resampled_audio_output.size()) {
|
||||
if (resampled_audio_output.capacity() < audio_out_size) {
|
||||
resampled_audio_output.reserve(audio_out_size);
|
||||
if (audio_out_size != resampledOutputData.size()) {
|
||||
if (resampledOutputData.capacity() < audio_out_size) {
|
||||
resampledOutputData.reserve(audio_out_size);
|
||||
}
|
||||
resampled_audio_output.resize(audio_out_size);
|
||||
resampledOutputData.resize(audio_out_size);
|
||||
}
|
||||
|
||||
unsigned int num_audio_written;
|
||||
msresamp_rrrf_execute(audio_resampler, &demod_output[0], num_written, &resampled_audio_output[0], &num_audio_written);
|
||||
unsigned int numAudioWritten;
|
||||
msresamp_rrrf_execute(audioResampler, &demodOutputData[0], numWritten, &resampledOutputData[0], &numAudioWritten);
|
||||
|
||||
if (stereo) {
|
||||
if (demod_output_stereo.size() != num_written) {
|
||||
if (demod_output_stereo.capacity() < num_written) {
|
||||
demod_output_stereo.reserve(num_written);
|
||||
if (demodStereoData.size() != numWritten) {
|
||||
if (demodStereoData.capacity() < numWritten) {
|
||||
demodStereoData.reserve(numWritten);
|
||||
}
|
||||
demod_output_stereo.resize(num_written);
|
||||
demodStereoData.resize(numWritten);
|
||||
}
|
||||
|
||||
double freq = (2.0 * M_PI) * (((double) abs(38000)) / ((double) inp->bandwidth));
|
||||
|
||||
if (nco_stereo_shift_freq != freq) {
|
||||
nco_crcf_set_frequency(nco_stereo_shift, freq);
|
||||
nco_stereo_shift_freq = freq;
|
||||
if (stereoShiftFrequency != freq) {
|
||||
nco_crcf_set_frequency(stereoShifter, freq);
|
||||
stereoShiftFrequency = freq;
|
||||
}
|
||||
|
||||
for (int i = 0; i < num_written; i++) {
|
||||
firhilbf_r2c_execute(firR2C, demod_output[i], &x);
|
||||
nco_crcf_mix_down(nco_stereo_shift, x, &y);
|
||||
nco_crcf_step(nco_stereo_shift);
|
||||
firhilbf_c2r_execute(firC2R, y, &demod_output_stereo[i]);
|
||||
for (int i = 0; i < numWritten; i++) {
|
||||
firhilbf_r2c_execute(firStereoR2C, demodOutputData[i], &x);
|
||||
nco_crcf_mix_down(stereoShifter, x, &y);
|
||||
nco_crcf_step(stereoShifter);
|
||||
firhilbf_c2r_execute(firStereoC2R, y, &demodStereoData[i]);
|
||||
}
|
||||
|
||||
if (audio_out_size != resampled_audio_output_stereo.size()) {
|
||||
if (resampled_audio_output_stereo.capacity() < audio_out_size) {
|
||||
resampled_audio_output_stereo.reserve(audio_out_size);
|
||||
if (audio_out_size != resampledStereoData.size()) {
|
||||
if (resampledStereoData.capacity() < audio_out_size) {
|
||||
resampledStereoData.reserve(audio_out_size);
|
||||
}
|
||||
resampled_audio_output_stereo.resize(audio_out_size);
|
||||
resampledStereoData.resize(audio_out_size);
|
||||
}
|
||||
|
||||
msresamp_rrrf_execute(stereo_resampler, &demod_output_stereo[0], num_written, &resampled_audio_output_stereo[0], &num_audio_written);
|
||||
msresamp_rrrf_execute(stereoResampler, &demodStereoData[0], numWritten, &resampledStereoData[0], &numAudioWritten);
|
||||
}
|
||||
|
||||
if (current_level > signal_level) {
|
||||
signal_level = signal_level + (current_level - signal_level) * 0.5;
|
||||
if (currentSignalLevel > signalLevel) {
|
||||
signalLevel = signalLevel + (currentSignalLevel - signalLevel) * 0.5;
|
||||
} else {
|
||||
signal_level = signal_level + (current_level - signal_level) * 0.05;
|
||||
signalLevel = signalLevel + (currentSignalLevel - signalLevel) * 0.05;
|
||||
}
|
||||
|
||||
AudioThreadInput *ati = NULL;
|
||||
|
||||
if (audioInputQueue != NULL) {
|
||||
if (!squelch_enabled || (signal_level >= squelch_level)) {
|
||||
if (audioOutputQueue != NULL) {
|
||||
if (!squelchEnabled || (signalLevel >= squelchLevel)) {
|
||||
|
||||
for (buffers_i = buffers.begin(); buffers_i != buffers.end(); buffers_i++) {
|
||||
if ((*buffers_i)->getRefCount() <= 0) {
|
||||
ati = (*buffers_i);
|
||||
for (outputBuffersI = outputBuffers.begin(); outputBuffersI != outputBuffers.end(); outputBuffersI++) {
|
||||
if ((*outputBuffersI)->getRefCount() <= 0) {
|
||||
ati = (*outputBuffersI);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (ati == NULL) {
|
||||
ati = new AudioThreadInput;
|
||||
buffers.push_back(ati);
|
||||
outputBuffers.push_back(ati);
|
||||
}
|
||||
|
||||
ati->setRefCount(1);
|
||||
|
||||
if (stereo) {
|
||||
ati->channels = 2;
|
||||
if (ati->data.capacity() < (num_audio_written * 2)) {
|
||||
ati->data.reserve(num_audio_written * 2);
|
||||
if (ati->data.capacity() < (numAudioWritten * 2)) {
|
||||
ati->data.reserve(numAudioWritten * 2);
|
||||
}
|
||||
ati->data.resize(num_audio_written * 2);
|
||||
for (int i = 0; i < num_audio_written; i++) {
|
||||
ati->data.resize(numAudioWritten * 2);
|
||||
for (int i = 0; i < numAudioWritten; i++) {
|
||||
float l, r;
|
||||
|
||||
firfilt_rrrf_push(fir_filter, (resampled_audio_output[i] - (resampled_audio_output_stereo[i])));
|
||||
firfilt_rrrf_execute(fir_filter, &l);
|
||||
firfilt_rrrf_push(firStereoLeft, (resampledOutputData[i] - (resampledStereoData[i])));
|
||||
firfilt_rrrf_execute(firStereoLeft, &l);
|
||||
|
||||
firfilt_rrrf_push(fir_filter2, (resampled_audio_output[i] + (resampled_audio_output_stereo[i])));
|
||||
firfilt_rrrf_execute(fir_filter2, &r);
|
||||
firfilt_rrrf_push(firStereoRight, (resampledOutputData[i] + (resampledStereoData[i])));
|
||||
firfilt_rrrf_execute(firStereoRight, &r);
|
||||
|
||||
ati->data[i * 2] = l;
|
||||
ati->data[i * 2 + 1] = r;
|
||||
}
|
||||
} else {
|
||||
ati->channels = 1;
|
||||
ati->data.assign(resampled_audio_output.begin(), resampled_audio_output.begin() + num_audio_written);
|
||||
ati->data.assign(resampledOutputData.begin(), resampledOutputData.begin() + numAudioWritten);
|
||||
}
|
||||
|
||||
audioInputQueue->push(ati);
|
||||
audioOutputQueue->push(ati);
|
||||
}
|
||||
}
|
||||
|
||||
if (ati && visOutQueue != NULL && visOutQueue->empty()) {
|
||||
if (ati && audioVisOutputQueue != NULL && audioVisOutputQueue->empty()) {
|
||||
AudioThreadInput *ati_vis = new AudioThreadInput;
|
||||
|
||||
int num_vis = DEMOD_VIS_SIZE;
|
||||
@ -315,23 +318,23 @@ void DemodulatorThread::threadMain() {
|
||||
}
|
||||
} else {
|
||||
ati_vis->channels = 1;
|
||||
if (num_audio_written > num_written) {
|
||||
if (numAudioWritten > numWritten) {
|
||||
|
||||
if (num_vis > num_audio_written) {
|
||||
num_vis = num_audio_written;
|
||||
if (num_vis > numAudioWritten) {
|
||||
num_vis = numAudioWritten;
|
||||
}
|
||||
ati_vis->data.assign(resampled_audio_output.begin(), resampled_audio_output.begin() + num_vis);
|
||||
ati_vis->data.assign(resampledOutputData.begin(), resampledOutputData.begin() + num_vis);
|
||||
} else {
|
||||
if (num_vis > num_written) {
|
||||
num_vis = num_written;
|
||||
if (num_vis > numWritten) {
|
||||
num_vis = numWritten;
|
||||
}
|
||||
ati_vis->data.assign(demod_output.begin(), demod_output.begin() + num_vis);
|
||||
ati_vis->data.assign(demodOutputData.begin(), demodOutputData.begin() + num_vis);
|
||||
}
|
||||
|
||||
// std::cout << "Signal: " << agc_crcf_get_signal_level(agc) << " -- " << agc_crcf_get_rssi(agc) << "dB " << std::endl;
|
||||
}
|
||||
|
||||
visOutQueue->push(ati_vis);
|
||||
audioVisOutputQueue->push(ati_vis);
|
||||
}
|
||||
if (!threadQueueControl->empty()) {
|
||||
int newDemodType = DEMOD_TYPE_NULL;
|
||||
@ -341,15 +344,11 @@ void DemodulatorThread::threadMain() {
|
||||
threadQueueControl->pop(command);
|
||||
|
||||
switch (command.cmd) {
|
||||
case DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_AUTO:
|
||||
squelch_level = agc_crcf_get_signal_level(agc);
|
||||
squelch_tolerance = agc_crcf_get_signal_level(agc) / 2.0;
|
||||
squelch_enabled = true;
|
||||
case DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_ON:
|
||||
squelchEnabled = true;
|
||||
break;
|
||||
case DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_SQUELCH_OFF:
|
||||
squelch_level = 0;
|
||||
squelch_tolerance = 1;
|
||||
squelch_enabled = false;
|
||||
squelchEnabled = false;
|
||||
break;
|
||||
case DemodulatorThreadControlCommand::DEMOD_THREAD_CMD_CTL_TYPE:
|
||||
newDemodType = command.demodType;
|
||||
@ -364,13 +363,13 @@ void DemodulatorThread::threadMain() {
|
||||
case DEMOD_TYPE_FM:
|
||||
break;
|
||||
case DEMOD_TYPE_LSB:
|
||||
ampdem_active = ampdem_lsb;
|
||||
demodAM = demodAM_USB;
|
||||
break;
|
||||
case DEMOD_TYPE_USB:
|
||||
ampdem_active = ampdem_usb;
|
||||
demodAM = demodAM_LSB;
|
||||
break;
|
||||
case DEMOD_TYPE_AM:
|
||||
ampdem_active = ampdem;
|
||||
demodAM = demodAM_DSB_CSP;
|
||||
break;
|
||||
}
|
||||
demodulatorType = newDemodType;
|
||||
@ -383,31 +382,29 @@ void DemodulatorThread::threadMain() {
|
||||
if (resampler != NULL) {
|
||||
msresamp_crcf_destroy(resampler);
|
||||
}
|
||||
if (audio_resampler != NULL) {
|
||||
msresamp_rrrf_destroy(audio_resampler);
|
||||
if (audioResampler != NULL) {
|
||||
msresamp_rrrf_destroy(audioResampler);
|
||||
}
|
||||
if (stereo_resampler != NULL) {
|
||||
msresamp_rrrf_destroy(stereo_resampler);
|
||||
if (stereoResampler != NULL) {
|
||||
msresamp_rrrf_destroy(stereoResampler);
|
||||
}
|
||||
if (fir_filter != NULL) {
|
||||
firfilt_rrrf_destroy(fir_filter);
|
||||
if (firStereoLeft != NULL) {
|
||||
firfilt_rrrf_destroy(firStereoLeft);
|
||||
}
|
||||
if (fir_filter2 != NULL) {
|
||||
firfilt_rrrf_destroy(fir_filter2);
|
||||
if (firStereoRight != NULL) {
|
||||
firfilt_rrrf_destroy(firStereoRight);
|
||||
}
|
||||
|
||||
agc_crcf_destroy(agc);
|
||||
firhilbf_destroy(firR2C);
|
||||
firhilbf_destroy(firC2R);
|
||||
// firhilbf_destroy(firR2Cssb);
|
||||
// firhilbf_destroy(firC2Rssb);
|
||||
nco_crcf_destroy(nco_stereo_shift);
|
||||
nco_crcf_destroy(nco_ssb_shift_up);
|
||||
nco_crcf_destroy(nco_ssb_shift_down);
|
||||
agc_crcf_destroy(iqAutoGain);
|
||||
firhilbf_destroy(firStereoR2C);
|
||||
firhilbf_destroy(firStereoC2R);
|
||||
nco_crcf_destroy(stereoShifter);
|
||||
nco_crcf_destroy(ssbShifterUp);
|
||||
nco_crcf_destroy(ssbShifterDown);
|
||||
|
||||
while (!buffers.empty()) {
|
||||
AudioThreadInput *audioDataDel = buffers.front();
|
||||
buffers.pop_front();
|
||||
while (!outputBuffers.empty()) {
|
||||
AudioThreadInput *audioDataDel = outputBuffers.front();
|
||||
outputBuffers.pop_front();
|
||||
delete audioDataDel;
|
||||
}
|
||||
|
||||
@ -417,10 +414,18 @@ void DemodulatorThread::threadMain() {
|
||||
threadQueueNotify->push(tCmd);
|
||||
}
|
||||
|
||||
void DemodulatorThread::setVisualOutputQueue(DemodulatorThreadOutputQueue *tQueue) {
|
||||
audioVisOutputQueue = tQueue;
|
||||
}
|
||||
|
||||
void DemodulatorThread::setAudioOutputQueue(AudioThreadInputQueue *tQueue) {
|
||||
audioOutputQueue = tQueue;
|
||||
}
|
||||
|
||||
void DemodulatorThread::terminate() {
|
||||
terminated = true;
|
||||
DemodulatorThreadPostIQData *inp = new DemodulatorThreadPostIQData; // push dummy to nudge queue
|
||||
postInputQueue->push(inp);
|
||||
iqInputQueue->push(inp);
|
||||
}
|
||||
|
||||
void DemodulatorThread::setStereo(bool state) {
|
||||
@ -433,18 +438,18 @@ bool DemodulatorThread::isStereo() {
|
||||
}
|
||||
|
||||
float DemodulatorThread::getSignalLevel() {
|
||||
return signal_level;
|
||||
return signalLevel;
|
||||
}
|
||||
|
||||
void DemodulatorThread::setSquelchLevel(float signal_level_in) {
|
||||
if (!squelch_enabled) {
|
||||
squelch_enabled = true;
|
||||
if (!squelchEnabled) {
|
||||
squelchEnabled = true;
|
||||
}
|
||||
squelch_level = signal_level_in;
|
||||
squelchLevel = signal_level_in;
|
||||
}
|
||||
|
||||
float DemodulatorThread::getSquelchLevel() {
|
||||
return squelch_level;
|
||||
return squelchLevel;
|
||||
}
|
||||
|
||||
void DemodulatorThread::setDemodulatorType(int demod_type_in) {
|
||||
|
@ -13,7 +13,7 @@ typedef ThreadQueue<AudioThreadInput *> DemodulatorThreadOutputQueue;
|
||||
class DemodulatorThread {
|
||||
public:
|
||||
|
||||
DemodulatorThread(DemodulatorThreadPostInputQueue* pQueueIn, DemodulatorThreadControlCommandQueue *threadQueueControl,
|
||||
DemodulatorThread(DemodulatorThreadPostInputQueue* iqInputQueue, DemodulatorThreadControlCommandQueue *threadQueueControl,
|
||||
DemodulatorThreadCommandQueue* threadQueueNotify);
|
||||
~DemodulatorThread();
|
||||
|
||||
@ -23,15 +23,9 @@ public:
|
||||
void threadMain();
|
||||
#endif
|
||||
|
||||
void setVisualOutputQueue(DemodulatorThreadOutputQueue *tQueue) {
|
||||
visOutQueue = tQueue;
|
||||
}
|
||||
void setVisualOutputQueue(DemodulatorThreadOutputQueue *tQueue);
|
||||
void setAudioOutputQueue(AudioThreadInputQueue *tQueue);
|
||||
|
||||
void setAudioInputQueue(AudioThreadInputQueue *tQueue) {
|
||||
audioInputQueue = tQueue;
|
||||
}
|
||||
|
||||
void initialize();
|
||||
void terminate();
|
||||
|
||||
void setStereo(bool state);
|
||||
@ -51,32 +45,32 @@ public:
|
||||
#endif
|
||||
|
||||
protected:
|
||||
std::deque<AudioThreadInput *> buffers;
|
||||
std::deque<AudioThreadInput *>::iterator buffers_i;
|
||||
std::deque<AudioThreadInput *> outputBuffers;
|
||||
std::deque<AudioThreadInput *>::iterator outputBuffersI;
|
||||
|
||||
std::vector<liquid_float_complex> resampled_data;
|
||||
std::vector<liquid_float_complex> agc_data;
|
||||
std::vector<float> agc_am_data;
|
||||
std::vector<float> demod_output;
|
||||
std::vector<float> demod_output_stereo;
|
||||
std::vector<float> resampled_audio_output;
|
||||
std::vector<float> resampled_audio_output_stereo;
|
||||
std::vector<liquid_float_complex> resampledData;
|
||||
std::vector<liquid_float_complex> agcData;
|
||||
std::vector<float> agcAMData;
|
||||
std::vector<float> demodOutputData;
|
||||
std::vector<float> demodStereoData;
|
||||
std::vector<float> resampledOutputData;
|
||||
std::vector<float> resampledStereoData;
|
||||
|
||||
DemodulatorThreadPostInputQueue* postInputQueue;
|
||||
DemodulatorThreadOutputQueue* visOutQueue;
|
||||
AudioThreadInputQueue *audioInputQueue;
|
||||
DemodulatorThreadPostInputQueue* iqInputQueue;
|
||||
DemodulatorThreadOutputQueue* audioVisOutputQueue;
|
||||
AudioThreadInputQueue *audioOutputQueue;
|
||||
|
||||
freqdem fdem;
|
||||
ampmodem ampdem_active;
|
||||
ampmodem ampdem;
|
||||
ampmodem ampdem_usb;
|
||||
ampmodem ampdem_lsb;
|
||||
freqdem demodFM;
|
||||
ampmodem demodAM;
|
||||
ampmodem demodAM_DSB_CSP;
|
||||
ampmodem demodAM_LSB;
|
||||
ampmodem demodAM_USB;
|
||||
|
||||
agc_crcf agc;
|
||||
agc_crcf iqAutoGain;
|
||||
|
||||
float am_max;
|
||||
float am_max_ma;
|
||||
float am_max_maa;
|
||||
float amOutputCeil;
|
||||
float amOutputCeilMA;
|
||||
float amOutputCeilMAA;
|
||||
|
||||
std::atomic<bool> stereo;
|
||||
std::atomic<bool> terminated;
|
||||
@ -84,8 +78,7 @@ protected:
|
||||
|
||||
DemodulatorThreadCommandQueue* threadQueueNotify;
|
||||
DemodulatorThreadControlCommandQueue *threadQueueControl;
|
||||
std::atomic<float> squelch_level;
|
||||
float squelch_tolerance;
|
||||
std::atomic<float> signal_level;
|
||||
bool squelch_enabled;
|
||||
std::atomic<float> squelchLevel;
|
||||
std::atomic<float> signalLevel;
|
||||
bool squelchEnabled;
|
||||
};
|
||||
|
@ -34,14 +34,14 @@ void DemodulatorWorkerThread::threadMain() {
|
||||
if (filterChanged) {
|
||||
DemodulatorWorkerThreadResult result(DemodulatorWorkerThreadResult::DEMOD_WORKER_THREAD_RESULT_FILTERS);
|
||||
|
||||
result.resample_ratio = (double) (filterCommand.bandwidth) / (double) filterCommand.inputRate;
|
||||
result.audio_resample_ratio = (double) (filterCommand.audioSampleRate) / (double) filterCommand.bandwidth;
|
||||
result.resamplerRatio = (double) (filterCommand.bandwidth) / (double) filterCommand.inputRate;
|
||||
result.audioResamplerRatio = (double) (filterCommand.audioSampleRate) / (double) filterCommand.bandwidth;
|
||||
|
||||
float As = 60.0f; // stop-band attenuation [dB]
|
||||
|
||||
result.resampler = msresamp_crcf_create(result.resample_ratio, As);
|
||||
result.audio_resampler = msresamp_rrrf_create(result.audio_resample_ratio, As);
|
||||
result.stereo_resampler = msresamp_rrrf_create(result.audio_resample_ratio, As);
|
||||
result.resampler = msresamp_crcf_create(result.resamplerRatio, As);
|
||||
result.audioResampler = msresamp_rrrf_create(result.audioResamplerRatio, As);
|
||||
result.stereoResampler = msresamp_rrrf_create(result.audioResamplerRatio, As);
|
||||
|
||||
result.audioSampleRate = filterCommand.audioSampleRate;
|
||||
result.bandwidth = filterCommand.bandwidth;
|
||||
|
@ -22,13 +22,13 @@ public:
|
||||
};
|
||||
|
||||
DemodulatorWorkerThreadResult() :
|
||||
cmd(DEMOD_WORKER_THREAD_RESULT_NULL), resampler(NULL), resample_ratio(0), audio_resampler(NULL), stereo_resampler(NULL), audio_resample_ratio(
|
||||
cmd(DEMOD_WORKER_THREAD_RESULT_NULL), resampler(NULL), resamplerRatio(0), audioResampler(NULL), stereoResampler(NULL), audioResamplerRatio(
|
||||
0), inputRate(0), bandwidth(0), audioSampleRate(0) {
|
||||
|
||||
}
|
||||
|
||||
DemodulatorWorkerThreadResult(DemodulatorThreadResultEnum cmd) :
|
||||
cmd(cmd), resampler(NULL), resample_ratio(0), audio_resampler(NULL), stereo_resampler(NULL), audio_resample_ratio(0), inputRate(0), bandwidth(
|
||||
cmd(cmd), resampler(NULL), resamplerRatio(0), audioResampler(NULL), stereoResampler(NULL), audioResamplerRatio(0), inputRate(0), bandwidth(
|
||||
0), audioSampleRate(0) {
|
||||
|
||||
}
|
||||
@ -36,10 +36,10 @@ public:
|
||||
DemodulatorThreadResultEnum cmd;
|
||||
|
||||
msresamp_crcf resampler;
|
||||
double resample_ratio;
|
||||
msresamp_rrrf audio_resampler;
|
||||
msresamp_rrrf stereo_resampler;
|
||||
double audio_resample_ratio;
|
||||
double resamplerRatio;
|
||||
msresamp_rrrf audioResampler;
|
||||
msresamp_rrrf stereoResampler;
|
||||
double audioResamplerRatio;
|
||||
|
||||
unsigned int inputRate;
|
||||
unsigned int bandwidth;
|
||||
|
@ -4,9 +4,9 @@
|
||||
#include "CubicSDR.h"
|
||||
|
||||
SDRThread::SDRThread(SDRThreadCommandQueue* pQueue) :
|
||||
m_pQueue(pQueue), iqDataOutQueue(NULL), terminated(false) {
|
||||
commandQueue(pQueue), iqDataOutQueue(NULL), terminated(false) {
|
||||
dev = NULL;
|
||||
sample_rate = SRATE;
|
||||
sampleRate = SRATE;
|
||||
}
|
||||
|
||||
SDRThread::~SDRThread() {
|
||||
@ -98,14 +98,14 @@ void SDRThread::threadMain() {
|
||||
|
||||
std::cout << "SDR thread initializing.." << std::endl;
|
||||
|
||||
int dev_count = rtlsdr_get_device_count();
|
||||
int first_available = enumerate_rtl();
|
||||
int devCount = rtlsdr_get_device_count();
|
||||
int firstDevAvailable = enumerate_rtl();
|
||||
|
||||
if (first_available == -1) {
|
||||
if (firstDevAvailable == -1) {
|
||||
std::cout << "No devices found.. SDR Thread exiting.." << std::endl;
|
||||
return;
|
||||
} else {
|
||||
std::cout << "Using first available RTL-SDR device #" << first_available << std::endl;
|
||||
std::cout << "Using first available RTL-SDR device #" << firstDevAvailable << std::endl;
|
||||
}
|
||||
|
||||
signed char buf[BUF_SIZE];
|
||||
@ -113,16 +113,16 @@ void SDRThread::threadMain() {
|
||||
unsigned int frequency = DEFAULT_FREQ;
|
||||
unsigned int bandwidth = SRATE;
|
||||
|
||||
rtlsdr_open(&dev, first_available);
|
||||
rtlsdr_open(&dev, firstDevAvailable);
|
||||
rtlsdr_set_sample_rate(dev, bandwidth);
|
||||
rtlsdr_set_center_freq(dev, frequency);
|
||||
rtlsdr_set_agc_mode(dev, 1);
|
||||
rtlsdr_set_offset_tuning(dev, 0);
|
||||
rtlsdr_reset_buffer(dev);
|
||||
|
||||
sample_rate = rtlsdr_get_sample_rate(dev);
|
||||
sampleRate = rtlsdr_get_sample_rate(dev);
|
||||
|
||||
std::cout << "Sample Rate is: " << sample_rate << std::endl;
|
||||
std::cout << "Sample Rate is: " << sampleRate << std::endl;
|
||||
|
||||
int n_read;
|
||||
double seconds = 0.0;
|
||||
@ -133,7 +133,7 @@ void SDRThread::threadMain() {
|
||||
std::deque<SDRThreadIQData *>::iterator buffers_i;
|
||||
|
||||
while (!terminated) {
|
||||
SDRThreadCommandQueue *cmdQueue = m_pQueue.load();
|
||||
SDRThreadCommandQueue *cmdQueue = commandQueue.load();
|
||||
|
||||
if (!cmdQueue->empty()) {
|
||||
bool freq_changed = false;
|
||||
@ -193,7 +193,7 @@ void SDRThread::threadMain() {
|
||||
dataOut->data[i] = buf[i] - 127;
|
||||
}
|
||||
|
||||
double time_slice = (double) n_read / (double) sample_rate;
|
||||
double time_slice = (double) n_read / (double) sampleRate;
|
||||
seconds += time_slice;
|
||||
|
||||
if (iqDataOutQueue != NULL) {
|
||||
|
@ -34,7 +34,7 @@ public:
|
||||
int int_value;
|
||||
};
|
||||
|
||||
class SDRThreadIQData : public ReferenceCounter {
|
||||
class SDRThreadIQData: public ReferenceCounter {
|
||||
public:
|
||||
unsigned int frequency;
|
||||
unsigned int bandwidth;
|
||||
@ -75,8 +75,8 @@ public:
|
||||
|
||||
void terminate();
|
||||
protected:
|
||||
uint32_t sample_rate;
|
||||
std::atomic<SDRThreadCommandQueue*> m_pQueue;
|
||||
uint32_t sampleRate;
|
||||
std::atomic<SDRThreadCommandQueue*> commandQueue;
|
||||
std::atomic<SDRThreadIQDataQueue*> iqDataOutQueue;
|
||||
|
||||
std::atomic<bool> terminated;
|
||||
|
@ -1,6 +1,17 @@
|
||||
#include "MouseTracker.h"
|
||||
#include <iostream>
|
||||
|
||||
MouseTracker::MouseTracker(wxWindow *target) :
|
||||
mouseX(0), mouseY(0), lastMouseX(0), lastMouseY(0), originMouseX(0), originMouseY(0), deltaMouseX(0), deltaMouseY(0), vertDragLock(false), horizDragLock(
|
||||
false), isMouseDown(false), isMouseRightDown(false), isMouseInView(false), target(target) {
|
||||
|
||||
}
|
||||
|
||||
MouseTracker::MouseTracker() :
|
||||
MouseTracker(NULL) {
|
||||
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseMoved(wxMouseEvent& event) {
|
||||
if (target == NULL) {
|
||||
return;
|
||||
@ -14,14 +25,14 @@ void MouseTracker::OnMouseMoved(wxMouseEvent& event) {
|
||||
deltaMouseX = mouseX - lastMouseX;
|
||||
deltaMouseY = mouseY - lastMouseY;
|
||||
|
||||
if (isMouseDown) {
|
||||
if (isMouseDown || isMouseRightDown) {
|
||||
#ifndef __APPLE__
|
||||
if (horizDragLock && vertDragLock) {
|
||||
target->WarpPointer(originMouseX * ClientSize.x, (1.0-originMouseY) * ClientSize.y);
|
||||
target->WarpPointer(originMouseX * ClientSize.x, (1.0 - originMouseY) * ClientSize.y);
|
||||
mouseX = originMouseX;
|
||||
mouseY = originMouseY;
|
||||
} else if (vertDragLock && mouseY != lastMouseY) {
|
||||
target->WarpPointer(event.m_x, (1.0-originMouseY) * ClientSize.y);
|
||||
} else if (vertDragLock && mouseY != lastMouseY) {
|
||||
target->WarpPointer(event.m_x, (1.0 - originMouseY) * ClientSize.y);
|
||||
mouseY = originMouseY;
|
||||
} else if (horizDragLock && mouseX != lastMouseX) {
|
||||
target->WarpPointer(originMouseX * ClientSize.x, event.m_y);
|
||||
@ -34,8 +45,12 @@ void MouseTracker::OnMouseMoved(wxMouseEvent& event) {
|
||||
lastMouseY = mouseY;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
// std::cout << "wheel?" << std::endl;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseDown(wxMouseEvent& event) {
|
||||
if (target == NULL) {
|
||||
if (isMouseRightDown || target == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
@ -50,20 +65,39 @@ void MouseTracker::OnMouseDown(wxMouseEvent& event) {
|
||||
isMouseDown = true;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
// std::cout << "wheel?" << std::endl;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseReleased(wxMouseEvent& event) {
|
||||
isMouseDown = false;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseRightDown(wxMouseEvent& event) {
|
||||
if (isMouseDown || target == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
const wxSize ClientSize = target->GetClientSize();
|
||||
|
||||
mouseX = lastMouseX = (float) event.m_x / (float) ClientSize.x;
|
||||
mouseY = lastMouseY = 1.0 - (float) event.m_y / (float) ClientSize.y;
|
||||
|
||||
originMouseX = mouseX;
|
||||
originMouseY = mouseY;
|
||||
|
||||
isMouseRightDown = true;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseRightReleased(wxMouseEvent& event) {
|
||||
isMouseRightDown = false;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseEnterWindow(wxMouseEvent& event) {
|
||||
isMouseInView = true;
|
||||
isMouseDown = false;
|
||||
isMouseRightDown = false;
|
||||
}
|
||||
|
||||
void MouseTracker::OnMouseLeftWindow(wxMouseEvent& event) {
|
||||
isMouseDown = false;
|
||||
isMouseRightDown = false;
|
||||
isMouseInView = false;
|
||||
}
|
||||
|
||||
@ -126,3 +160,8 @@ bool MouseTracker::mouseInView() {
|
||||
void MouseTracker::setTarget(wxWindow *target_in) {
|
||||
target = target_in;
|
||||
}
|
||||
|
||||
|
||||
bool MouseTracker::mouseRightDown() {
|
||||
return isMouseRightDown;
|
||||
}
|
||||
|
@ -4,20 +4,15 @@
|
||||
|
||||
class MouseTracker {
|
||||
public:
|
||||
MouseTracker(wxWindow *target) :
|
||||
mouseX(0), mouseY(0), lastMouseX(0), lastMouseY(0), originMouseX(0), originMouseY(0), deltaMouseX(0), deltaMouseY(0), vertDragLock(false), horizDragLock(false), isMouseDown(false), isMouseInView(false), target(target) {
|
||||
|
||||
}
|
||||
|
||||
MouseTracker() :
|
||||
mouseX(0), mouseY(0), lastMouseX(0), lastMouseY(0), originMouseX(0), originMouseY(0), deltaMouseX(0), deltaMouseY(0), vertDragLock(false), horizDragLock(false), isMouseDown(false), isMouseInView(false), target(NULL) {
|
||||
|
||||
}
|
||||
MouseTracker(wxWindow *target);
|
||||
MouseTracker();
|
||||
|
||||
void OnMouseMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseWheelMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseReleased(wxMouseEvent& event);
|
||||
void OnMouseRightDown(wxMouseEvent& event);
|
||||
void OnMouseRightReleased(wxMouseEvent& event);
|
||||
void OnMouseEnterWindow(wxMouseEvent& event);
|
||||
void OnMouseLeftWindow(wxMouseEvent& event);
|
||||
|
||||
@ -35,6 +30,7 @@ public:
|
||||
void setVertDragLock(bool dragLock);
|
||||
void setHorizDragLock(bool dragLock);
|
||||
bool mouseDown();
|
||||
bool mouseRightDown();
|
||||
bool mouseInView();
|
||||
void setTarget(wxWindow *target_in);
|
||||
|
||||
@ -45,6 +41,6 @@ private:
|
||||
float deltaMouseX, deltaMouseY;
|
||||
|
||||
bool vertDragLock, horizDragLock;
|
||||
bool isMouseDown, isMouseInView;
|
||||
bool isMouseDown, isMouseRightDown, isMouseInView;
|
||||
wxWindow *target;
|
||||
};
|
||||
|
@ -19,53 +19,53 @@
|
||||
|
||||
InteractiveCanvas::InteractiveCanvas(wxWindow *parent, int *attribList) :
|
||||
wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize,
|
||||
wxFULL_REPAINT_ON_RESIZE), parent(parent), shiftDown(false), altDown(false), ctrlDown(false), center_freq(0), bandwidth(0), last_bandwidth(0), isView(
|
||||
wxFULL_REPAINT_ON_RESIZE), parent(parent), shiftDown(false), altDown(false), ctrlDown(false), centerFreq(0), bandwidth(0), lastBandwidth(0), isView(
|
||||
false) {
|
||||
mTracker.setTarget(this);
|
||||
mouseTracker.setTarget(this);
|
||||
}
|
||||
|
||||
InteractiveCanvas::~InteractiveCanvas() {
|
||||
}
|
||||
|
||||
void InteractiveCanvas::SetView(int center_freq_in, int bandwidth_in) {
|
||||
void InteractiveCanvas::setView(int center_freq_in, int bandwidth_in) {
|
||||
isView = true;
|
||||
center_freq = center_freq_in;
|
||||
centerFreq = center_freq_in;
|
||||
bandwidth = bandwidth_in;
|
||||
last_bandwidth = 0;
|
||||
lastBandwidth = 0;
|
||||
}
|
||||
|
||||
void InteractiveCanvas::DisableView() {
|
||||
void InteractiveCanvas::disableView() {
|
||||
isView = false;
|
||||
center_freq = wxGetApp().getFrequency();
|
||||
centerFreq = wxGetApp().getFrequency();
|
||||
bandwidth = SRATE;
|
||||
last_bandwidth = 0;
|
||||
lastBandwidth = 0;
|
||||
}
|
||||
|
||||
int InteractiveCanvas::GetFrequencyAt(float x) {
|
||||
int iqCenterFreq = GetCenterFrequency();
|
||||
int iqBandwidth = GetBandwidth();
|
||||
int InteractiveCanvas::getFrequencyAt(float x) {
|
||||
int iqCenterFreq = getCenterFrequency();
|
||||
int iqBandwidth = getBandwidth();
|
||||
int freq = iqCenterFreq - (int) (0.5 * (float) iqBandwidth) + (int) ((float) x * (float) iqBandwidth);
|
||||
|
||||
return freq;
|
||||
}
|
||||
|
||||
void InteractiveCanvas::SetCenterFrequency(unsigned int center_freq_in) {
|
||||
center_freq = center_freq_in;
|
||||
void InteractiveCanvas::setCenterFrequency(unsigned int center_freq_in) {
|
||||
centerFreq = center_freq_in;
|
||||
}
|
||||
|
||||
unsigned int InteractiveCanvas::GetCenterFrequency() {
|
||||
unsigned int InteractiveCanvas::getCenterFrequency() {
|
||||
if (isView) {
|
||||
return center_freq;
|
||||
return centerFreq;
|
||||
} else {
|
||||
return (unsigned int) wxGetApp().getFrequency();
|
||||
}
|
||||
}
|
||||
|
||||
void InteractiveCanvas::SetBandwidth(unsigned int bandwidth_in) {
|
||||
void InteractiveCanvas::setBandwidth(unsigned int bandwidth_in) {
|
||||
bandwidth = bandwidth_in;
|
||||
}
|
||||
|
||||
unsigned int InteractiveCanvas::GetBandwidth() {
|
||||
unsigned int InteractiveCanvas::getBandwidth() {
|
||||
if (isView) {
|
||||
return bandwidth;
|
||||
} else {
|
||||
@ -87,40 +87,40 @@ void InteractiveCanvas::OnKeyDown(wxKeyEvent& event) {
|
||||
ctrlDown = event.ControlDown();
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
mTracker.OnMouseMoved(event);
|
||||
void InteractiveCanvas::OnMouseMoved(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseMoved(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
altDown = event.AltDown();
|
||||
ctrlDown = event.ControlDown();
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseDown(wxMouseEvent& event) {
|
||||
mTracker.OnMouseDown(event);
|
||||
void InteractiveCanvas::OnMouseDown(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseDown(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
altDown = event.AltDown();
|
||||
ctrlDown = event.ControlDown();
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseWheelMoved(wxMouseEvent& event) {
|
||||
mTracker.OnMouseWheelMoved(event);
|
||||
void InteractiveCanvas::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseWheelMoved(event);
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
mTracker.OnMouseReleased(event);
|
||||
void InteractiveCanvas::OnMouseReleased(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseReleased(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
altDown = event.AltDown();
|
||||
ctrlDown = event.ControlDown();
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseLeftWindow(wxMouseEvent& event) {
|
||||
mTracker.OnMouseLeftWindow(event);
|
||||
void InteractiveCanvas::OnMouseLeftWindow(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseLeftWindow(event);
|
||||
}
|
||||
|
||||
void InteractiveCanvas::mouseEnterWindow(wxMouseEvent& event) {
|
||||
mTracker.OnMouseEnterWindow(event);
|
||||
void InteractiveCanvas::OnMouseEnterWindow(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseEnterWindow(event);
|
||||
}
|
||||
|
||||
void InteractiveCanvas::setStatusText(std::string statusText) {
|
||||
@ -131,3 +131,11 @@ void InteractiveCanvas::setStatusText(std::string statusText, int value) {
|
||||
((wxFrame*) parent)->GetStatusBar()->SetStatusText(
|
||||
wxString::Format(statusText.c_str(), wxNumberFormatter::ToString((long) value, wxNumberFormatter::Style_WithThousandsSep)));
|
||||
}
|
||||
|
||||
void InteractiveCanvas::OnMouseRightDown(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseRightDown(event);
|
||||
}
|
||||
|
||||
void InteractiveCanvas::OnMouseRightReleased(wxMouseEvent& event) {
|
||||
mouseTracker.OnMouseRightReleased(event);
|
||||
}
|
||||
|
@ -11,41 +11,43 @@ public:
|
||||
InteractiveCanvas(wxWindow *parent, int *attribList = NULL);
|
||||
~InteractiveCanvas();
|
||||
|
||||
int GetFrequencyAt(float x);
|
||||
int getFrequencyAt(float x);
|
||||
|
||||
void SetView(int center_freq_in, int bandwidth_in);
|
||||
void DisableView();
|
||||
void setView(int center_freq_in, int bandwidth_in);
|
||||
void disableView();
|
||||
|
||||
void SetCenterFrequency(unsigned int center_freq_in);
|
||||
unsigned int GetCenterFrequency();
|
||||
void setCenterFrequency(unsigned int center_freq_in);
|
||||
unsigned int getCenterFrequency();
|
||||
|
||||
void SetBandwidth(unsigned int bandwidth_in);
|
||||
unsigned int GetBandwidth();
|
||||
void setBandwidth(unsigned int bandwidth_in);
|
||||
unsigned int getBandwidth();
|
||||
|
||||
protected:
|
||||
void OnKeyDown(wxKeyEvent& event);
|
||||
void OnKeyUp(wxKeyEvent& event);
|
||||
|
||||
void mouseMoved(wxMouseEvent& event);
|
||||
void mouseDown(wxMouseEvent& event);
|
||||
void mouseWheelMoved(wxMouseEvent& event);
|
||||
void mouseReleased(wxMouseEvent& event);
|
||||
void mouseEnterWindow(wxMouseEvent& event);
|
||||
void mouseLeftWindow(wxMouseEvent& event);
|
||||
void OnMouseMoved(wxMouseEvent& event);
|
||||
void OnMouseWheelMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseReleased(wxMouseEvent& event);
|
||||
void OnMouseRightDown(wxMouseEvent& event);
|
||||
void OnMouseRightReleased(wxMouseEvent& event);
|
||||
void OnMouseEnterWindow(wxMouseEvent& event);
|
||||
void OnMouseLeftWindow(wxMouseEvent& event);
|
||||
|
||||
void setStatusText(std::string statusText);
|
||||
void setStatusText(std::string statusText, int value);
|
||||
|
||||
wxWindow *parent;
|
||||
MouseTracker mTracker;
|
||||
MouseTracker mouseTracker;
|
||||
|
||||
bool shiftDown;
|
||||
bool altDown;
|
||||
bool ctrlDown;
|
||||
|
||||
unsigned int center_freq;
|
||||
unsigned int centerFreq;
|
||||
unsigned int bandwidth;
|
||||
unsigned int last_bandwidth;
|
||||
unsigned int lastBandwidth;
|
||||
|
||||
bool isView;
|
||||
};
|
||||
|
@ -17,11 +17,11 @@
|
||||
|
||||
wxBEGIN_EVENT_TABLE(MeterCanvas, wxGLCanvas) EVT_PAINT(MeterCanvas::OnPaint)
|
||||
EVT_IDLE(MeterCanvas::OnIdle)
|
||||
EVT_MOTION(MeterCanvas::mouseMoved)
|
||||
EVT_LEFT_DOWN(MeterCanvas::mouseDown)
|
||||
EVT_LEFT_UP(MeterCanvas::mouseReleased)
|
||||
EVT_LEAVE_WINDOW(MeterCanvas::mouseLeftWindow)
|
||||
EVT_ENTER_WINDOW(MeterCanvas::mouseEnterWindow)
|
||||
EVT_MOTION(MeterCanvas::OnMouseMoved)
|
||||
EVT_LEFT_DOWN(MeterCanvas::OnMouseDown)
|
||||
EVT_LEFT_UP(MeterCanvas::OnMouseReleased)
|
||||
EVT_LEAVE_WINDOW(MeterCanvas::OnMouseLeftWindow)
|
||||
EVT_ENTER_WINDOW(MeterCanvas::OnMouseEnterWindow)
|
||||
wxEND_EVENT_TABLE()
|
||||
|
||||
MeterCanvas::MeterCanvas(wxWindow *parent, int *attribList) :
|
||||
@ -83,7 +83,7 @@ void MeterCanvas::OnIdle(wxIdleEvent &event) {
|
||||
Refresh(false);
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseMoved(wxMouseEvent& event) {
|
||||
mTracker.OnMouseMoved(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
@ -95,7 +95,7 @@ void MeterCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
}
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseDown(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseDown(wxMouseEvent& event) {
|
||||
mTracker.OnMouseDown(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
@ -106,11 +106,11 @@ void MeterCanvas::mouseDown(wxMouseEvent& event) {
|
||||
mTracker.setHorizDragLock(true);
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseWheelMoved(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
mTracker.OnMouseWheelMoved(event);
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseReleased(wxMouseEvent& event) {
|
||||
mTracker.OnMouseReleased(event);
|
||||
|
||||
shiftDown = event.ShiftDown();
|
||||
@ -120,12 +120,12 @@ void MeterCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
userInputValue = mTracker.getMouseY()*level_max;
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseLeftWindow(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseLeftWindow(wxMouseEvent& event) {
|
||||
mTracker.OnMouseLeftWindow(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
}
|
||||
|
||||
void MeterCanvas::mouseEnterWindow(wxMouseEvent& event) {
|
||||
void MeterCanvas::OnMouseEnterWindow(wxMouseEvent& event) {
|
||||
mTracker.OnMouseEnterWindow(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
}
|
||||
|
@ -32,12 +32,12 @@ private:
|
||||
void OnPaint(wxPaintEvent& event);
|
||||
void OnIdle(wxIdleEvent &event);
|
||||
|
||||
void mouseMoved(wxMouseEvent& event);
|
||||
void mouseDown(wxMouseEvent& event);
|
||||
void mouseWheelMoved(wxMouseEvent& event);
|
||||
void mouseReleased(wxMouseEvent& event);
|
||||
void mouseEnterWindow(wxMouseEvent& event);
|
||||
void mouseLeftWindow(wxMouseEvent& event);
|
||||
void OnMouseMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseWheelMoved(wxMouseEvent& event);
|
||||
void OnMouseReleased(wxMouseEvent& event);
|
||||
void OnMouseEnterWindow(wxMouseEvent& event);
|
||||
void OnMouseLeftWindow(wxMouseEvent& event);
|
||||
|
||||
MouseTracker mTracker;
|
||||
wxWindow *parent;
|
||||
|
@ -19,11 +19,11 @@
|
||||
|
||||
wxBEGIN_EVENT_TABLE(SpectrumCanvas, wxGLCanvas) EVT_PAINT(SpectrumCanvas::OnPaint)
|
||||
EVT_IDLE(SpectrumCanvas::OnIdle)
|
||||
EVT_MOTION(SpectrumCanvas::mouseMoved)
|
||||
EVT_LEFT_DOWN(SpectrumCanvas::mouseDown)
|
||||
EVT_LEFT_UP(SpectrumCanvas::mouseReleased)
|
||||
EVT_LEAVE_WINDOW(SpectrumCanvas::mouseLeftWindow)
|
||||
EVT_MOUSEWHEEL(SpectrumCanvas::mouseWheelMoved)
|
||||
EVT_MOTION(SpectrumCanvas::OnMouseMoved)
|
||||
EVT_LEFT_DOWN(SpectrumCanvas::OnMouseDown)
|
||||
EVT_LEFT_UP(SpectrumCanvas::OnMouseReleased)
|
||||
EVT_LEAVE_WINDOW(SpectrumCanvas::OnMouseLeftWindow)
|
||||
EVT_MOUSEWHEEL(SpectrumCanvas::OnMouseWheelMoved)
|
||||
wxEND_EVENT_TABLE()
|
||||
|
||||
SpectrumCanvas::SpectrumCanvas(wxWindow *parent, int *attribList) :
|
||||
@ -32,12 +32,12 @@ SpectrumCanvas::SpectrumCanvas(wxWindow *parent, int *attribList) :
|
||||
|
||||
glContext = new SpectrumContext(this, &wxGetApp().GetContext(this));
|
||||
|
||||
mTracker.setVertDragLock(true);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
|
||||
SetCursor(wxCURSOR_SIZEWE);
|
||||
}
|
||||
|
||||
void SpectrumCanvas::Setup(int fft_size_in) {
|
||||
void SpectrumCanvas::setup(int fft_size_in) {
|
||||
if (fft_size == fft_size_in) {
|
||||
return;
|
||||
}
|
||||
@ -73,12 +73,12 @@ void SpectrumCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
|
||||
glViewport(0, 0, ClientSize.x, ClientSize.y);
|
||||
|
||||
glContext->BeginDraw();
|
||||
glContext->Draw(spectrum_points, GetCenterFrequency(), GetBandwidth());
|
||||
glContext->Draw(spectrum_points, getCenterFrequency(), getBandwidth());
|
||||
|
||||
std::vector<DemodulatorInstance *> &demods = wxGetApp().getDemodMgr().getDemodulators();
|
||||
|
||||
for (int i = 0, iMax = demods.size(); i < iMax; i++) {
|
||||
glContext->DrawDemodInfo(demods[i], 1, 1, 1, GetCenterFrequency(), GetBandwidth());
|
||||
glContext->DrawDemodInfo(demods[i], 1, 1, 1, getCenterFrequency(), getBandwidth());
|
||||
}
|
||||
|
||||
glContext->EndDraw();
|
||||
@ -93,7 +93,7 @@ void SpectrumCanvas::setData(DemodulatorThreadIQData *input) {
|
||||
std::vector<liquid_float_complex> *data = &input->data;
|
||||
if (data && data->size()) {
|
||||
if (fft_size != data->size()) {
|
||||
Setup(data->size());
|
||||
setup(data->size());
|
||||
}
|
||||
if (spectrum_points.size() < fft_size * 2) {
|
||||
if (spectrum_points.capacity() < fft_size * 2) {
|
||||
@ -173,26 +173,26 @@ void SpectrumCanvas::OnIdle(wxIdleEvent &event) {
|
||||
Refresh(false);
|
||||
}
|
||||
|
||||
void SpectrumCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseMoved(event);
|
||||
if (mTracker.mouseDown()) {
|
||||
int freqChange = mTracker.getDeltaMouseX() * GetBandwidth();
|
||||
void SpectrumCanvas::OnMouseMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseMoved(event);
|
||||
if (mouseTracker.mouseDown()) {
|
||||
int freqChange = mouseTracker.getDeltaMouseX() * getBandwidth();
|
||||
|
||||
if (freqChange != 0) {
|
||||
int freq = wxGetApp().getFrequency();
|
||||
|
||||
if (isView) {
|
||||
center_freq = center_freq - freqChange;
|
||||
centerFreq = centerFreq - freqChange;
|
||||
if (waterfallCanvas) {
|
||||
waterfallCanvas->SetCenterFrequency(center_freq);
|
||||
waterfallCanvas->setCenterFrequency(centerFreq);
|
||||
}
|
||||
|
||||
int bw = (int) bandwidth;
|
||||
int bwOfs = ((int) center_freq > freq) ? ((int) bandwidth / 2) : (-(int) bandwidth / 2);
|
||||
int freqEdge = ((int) center_freq + bwOfs);
|
||||
int bwOfs = ((int) centerFreq > freq) ? ((int) bandwidth / 2) : (-(int) bandwidth / 2);
|
||||
int freqEdge = ((int) centerFreq + bwOfs);
|
||||
|
||||
if (abs(freq - freqEdge) > (SRATE / 2)) {
|
||||
freqChange = -(((int) center_freq > freq) ? (freqEdge - freq - (SRATE / 2)) : (freqEdge - freq + (SRATE / 2)));
|
||||
freqChange = -(((int) centerFreq > freq) ? (freqEdge - freq - (SRATE / 2)) : (freqEdge - freq + (SRATE / 2)));
|
||||
} else {
|
||||
freqChange = 0;
|
||||
}
|
||||
@ -210,22 +210,22 @@ void SpectrumCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
}
|
||||
}
|
||||
|
||||
void SpectrumCanvas::mouseDown(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseDown(event);
|
||||
void SpectrumCanvas::OnMouseDown(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseDown(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
}
|
||||
|
||||
void SpectrumCanvas::mouseWheelMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseWheelMoved(event);
|
||||
void SpectrumCanvas::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseWheelMoved(event);
|
||||
}
|
||||
|
||||
void SpectrumCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseReleased(event);
|
||||
void SpectrumCanvas::OnMouseReleased(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseReleased(event);
|
||||
SetCursor(wxCURSOR_SIZEWE);
|
||||
}
|
||||
|
||||
void SpectrumCanvas::mouseLeftWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseLeftWindow(event);
|
||||
void SpectrumCanvas::OnMouseLeftWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseLeftWindow(event);
|
||||
SetCursor(wxCURSOR_SIZEWE);
|
||||
}
|
||||
|
||||
|
@ -19,7 +19,7 @@ public:
|
||||
std::vector<float> spectrum_points;
|
||||
|
||||
SpectrumCanvas(wxWindow *parent, int *attribList = NULL);
|
||||
void Setup(int fft_size_in);
|
||||
void setup(int fft_size_in);
|
||||
~SpectrumCanvas();
|
||||
|
||||
void setData(DemodulatorThreadIQData *input);
|
||||
@ -30,13 +30,11 @@ private:
|
||||
|
||||
void OnIdle(wxIdleEvent &event);
|
||||
|
||||
void mouseMoved(wxMouseEvent& event);
|
||||
void mouseDown(wxMouseEvent& event);
|
||||
void mouseWheelMoved(wxMouseEvent& event);
|
||||
void mouseReleased(wxMouseEvent& event);
|
||||
|
||||
// void rightClick(wxMouseEvent& event);
|
||||
void mouseLeftWindow(wxMouseEvent& event);
|
||||
void OnMouseMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseWheelMoved(wxMouseEvent& event);
|
||||
void OnMouseReleased(wxMouseEvent& event);
|
||||
void OnMouseLeftWindow(wxMouseEvent& event);
|
||||
|
||||
fftw_complex *in, *out;
|
||||
fftw_plan plan;
|
||||
|
@ -23,22 +23,24 @@ wxBEGIN_EVENT_TABLE(WaterfallCanvas, wxGLCanvas) EVT_PAINT(WaterfallCanvas::OnPa
|
||||
EVT_KEY_DOWN(WaterfallCanvas::OnKeyDown)
|
||||
EVT_KEY_UP(WaterfallCanvas::OnKeyUp)
|
||||
EVT_IDLE(WaterfallCanvas::OnIdle)
|
||||
EVT_MOTION(WaterfallCanvas::mouseMoved)
|
||||
EVT_LEFT_DOWN(WaterfallCanvas::mouseDown)
|
||||
EVT_LEFT_UP(WaterfallCanvas::mouseReleased)
|
||||
EVT_LEAVE_WINDOW(WaterfallCanvas::mouseLeftWindow)
|
||||
EVT_ENTER_WINDOW(WaterfallCanvas::mouseEnterWindow)
|
||||
EVT_MOTION(WaterfallCanvas::OnMouseMoved)
|
||||
EVT_LEFT_DOWN(WaterfallCanvas::OnMouseDown)
|
||||
EVT_LEFT_UP(WaterfallCanvas::OnMouseReleased)
|
||||
EVT_RIGHT_DOWN(WaterfallCanvas::OnMouseRightDown)
|
||||
EVT_RIGHT_UP(WaterfallCanvas::OnMouseRightReleased)
|
||||
EVT_LEAVE_WINDOW(WaterfallCanvas::OnMouseLeftWindow)
|
||||
EVT_ENTER_WINDOW(WaterfallCanvas::OnMouseEnterWindow)
|
||||
wxEND_EVENT_TABLE()
|
||||
|
||||
WaterfallCanvas::WaterfallCanvas(wxWindow *parent, int *attribList) :
|
||||
InteractiveCanvas(parent, attribList), spectrumCanvas(NULL), activeDemodulatorBandwidth(0), activeDemodulatorFrequency(0), dragState(
|
||||
WF_DRAG_NONE), nextDragState(WF_DRAG_NONE), fft_size(0), waterfall_lines(0), plan(
|
||||
NULL), in(NULL), out(NULL), resampler(NULL), resample_ratio(0), last_input_bandwidth(0), zoom(0) {
|
||||
NULL), in(NULL), out(NULL), resampler(NULL), resamplerRatio(0), lastInputBandwidth(0), zoom(1), mouseZoom(1) {
|
||||
|
||||
glContext = new WaterfallContext(this, &wxGetApp().GetContext(this));
|
||||
|
||||
nco_shift = nco_crcf_create(LIQUID_NCO);
|
||||
shift_freq = 0;
|
||||
freqShifter = nco_crcf_create(LIQUID_NCO);
|
||||
shiftFrequency = 0;
|
||||
|
||||
fft_ceil_ma = fft_ceil_maa = 100.0;
|
||||
fft_floor_ma = fft_floor_maa = 0.0;
|
||||
@ -47,10 +49,10 @@ WaterfallCanvas::WaterfallCanvas(wxWindow *parent, int *attribList) :
|
||||
}
|
||||
|
||||
WaterfallCanvas::~WaterfallCanvas() {
|
||||
nco_crcf_destroy(nco_shift);
|
||||
nco_crcf_destroy(freqShifter);
|
||||
}
|
||||
|
||||
void WaterfallCanvas::Setup(int fft_size_in, int waterfall_lines_in) {
|
||||
void WaterfallCanvas::setup(int fft_size_in, int waterfall_lines_in) {
|
||||
if (fft_size == fft_size_in && waterfall_lines_in == waterfall_lines) {
|
||||
return;
|
||||
}
|
||||
@ -103,14 +105,14 @@ void WaterfallCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
|
||||
bool isNew = shiftDown
|
||||
|| (wxGetApp().getDemodMgr().getLastActiveDemodulator() && !wxGetApp().getDemodMgr().getLastActiveDemodulator()->isActive());
|
||||
|
||||
int currentBandwidth = GetBandwidth();
|
||||
int currentCenterFreq = GetCenterFrequency();
|
||||
int currentBandwidth = getBandwidth();
|
||||
int currentCenterFreq = getCenterFrequency();
|
||||
|
||||
if (mTracker.mouseInView()) {
|
||||
if (mouseTracker.mouseInView()) {
|
||||
if (nextDragState == WF_DRAG_RANGE) {
|
||||
if (mTracker.mouseDown()) {
|
||||
float width = mTracker.getOriginDeltaMouseX();
|
||||
float centerPos = mTracker.getOriginMouseX() + width / 2.0;
|
||||
if (mouseTracker.mouseDown()) {
|
||||
float width = mouseTracker.getOriginDeltaMouseX();
|
||||
float centerPos = mouseTracker.getOriginMouseX() + width / 2.0;
|
||||
|
||||
if (isNew) {
|
||||
glContext->DrawDemod(lastActiveDemodulator, 1, 1, 1, currentCenterFreq, currentBandwidth);
|
||||
@ -124,10 +126,10 @@ void WaterfallCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
|
||||
} else {
|
||||
if (isNew) {
|
||||
glContext->DrawDemod(lastActiveDemodulator, 1, 1, 1, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mTracker.getMouseX(), 0, 1, 0, 1.0 / (float) ClientSize.x, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mouseTracker.getMouseX(), 0, 1, 0, 1.0 / (float) ClientSize.x, currentCenterFreq, currentBandwidth);
|
||||
} else {
|
||||
glContext->DrawDemod(lastActiveDemodulator, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mTracker.getMouseX(), 1, 1, 0, 1.0 / (float) ClientSize.x, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mouseTracker.getMouseX(), 1, 1, 0, 1.0 / (float) ClientSize.x, currentCenterFreq, currentBandwidth);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -135,13 +137,13 @@ void WaterfallCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) {
|
||||
if (lastActiveDemodulator) {
|
||||
if (isNew) {
|
||||
glContext->DrawDemod(lastActiveDemodulator, 1, 1, 1, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mTracker.getMouseX(), 0, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mouseTracker.getMouseX(), 0, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
} else {
|
||||
glContext->DrawDemod(lastActiveDemodulator, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mTracker.getMouseX(), 1, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mouseTracker.getMouseX(), 1, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
}
|
||||
} else {
|
||||
glContext->DrawFreqSelector(mTracker.getMouseX(), 1, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
glContext->DrawFreqSelector(mouseTracker.getMouseX(), 1, 1, 0, 0, currentCenterFreq, currentBandwidth);
|
||||
}
|
||||
} else {
|
||||
if (lastActiveDemodulator) {
|
||||
@ -178,10 +180,10 @@ void WaterfallCanvas::OnKeyUp(wxKeyEvent& event) {
|
||||
ctrlDown = event.ControlDown();
|
||||
switch (event.GetKeyCode()) {
|
||||
case 'A':
|
||||
zoom = 0;
|
||||
zoom = 1.0;
|
||||
break;
|
||||
case 'Z':
|
||||
zoom = 0;
|
||||
zoom = 1.0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -196,27 +198,27 @@ void WaterfallCanvas::OnKeyDown(wxKeyEvent& event) {
|
||||
unsigned int bw;
|
||||
switch (event.GetKeyCode()) {
|
||||
case 'A':
|
||||
zoom = 1;
|
||||
zoom = 0.95;
|
||||
break;
|
||||
case 'Z':
|
||||
zoom = -1;
|
||||
zoom = 1.05;
|
||||
break;
|
||||
case WXK_RIGHT:
|
||||
freq = wxGetApp().getFrequency();
|
||||
if (shiftDown) {
|
||||
freq += SRATE * 10;
|
||||
if (isView) {
|
||||
SetView(center_freq + SRATE * 10, GetBandwidth());
|
||||
setView(centerFreq + SRATE * 10, getBandwidth());
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(GetCenterFrequency(), GetBandwidth());
|
||||
spectrumCanvas->setView(getCenterFrequency(), getBandwidth());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
freq += SRATE / 2;
|
||||
if (isView) {
|
||||
SetView(center_freq + SRATE / 2, GetBandwidth());
|
||||
setView(centerFreq + SRATE / 2, getBandwidth());
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(GetCenterFrequency(), GetBandwidth());
|
||||
spectrumCanvas->setView(getCenterFrequency(), getBandwidth());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -228,17 +230,17 @@ void WaterfallCanvas::OnKeyDown(wxKeyEvent& event) {
|
||||
if (shiftDown) {
|
||||
freq -= SRATE * 10;
|
||||
if (isView) {
|
||||
SetView(center_freq - SRATE * 10, GetBandwidth());
|
||||
setView(centerFreq - SRATE * 10, getBandwidth());
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(GetCenterFrequency(), GetBandwidth());
|
||||
spectrumCanvas->setView(getCenterFrequency(), getBandwidth());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
freq -= SRATE / 2;
|
||||
if (isView) {
|
||||
SetView(center_freq - SRATE / 2, GetBandwidth());
|
||||
setView(centerFreq - SRATE / 2, getBandwidth());
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(GetCenterFrequency(), GetBandwidth());
|
||||
spectrumCanvas->setView(getCenterFrequency(), getBandwidth());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -284,59 +286,66 @@ void WaterfallCanvas::setData(DemodulatorThreadIQData *input) {
|
||||
return;
|
||||
}
|
||||
|
||||
float currentZoom = zoom;
|
||||
|
||||
if (mouseZoom != 1) {
|
||||
currentZoom = mouseZoom;
|
||||
mouseZoom = mouseZoom + (1.0 - mouseZoom)*0.2;
|
||||
}
|
||||
|
||||
unsigned int bw;
|
||||
if (zoom) {
|
||||
if (currentZoom != 1) {
|
||||
int freq = wxGetApp().getFrequency();
|
||||
|
||||
if (zoom > 0) {
|
||||
center_freq = GetCenterFrequency();
|
||||
bw = GetBandwidth();
|
||||
bw = (unsigned int) ceil((float) bw * 0.95);
|
||||
if (currentZoom < 1) {
|
||||
centerFreq = getCenterFrequency();
|
||||
bw = getBandwidth();
|
||||
bw = (unsigned int) ceil((float) bw * currentZoom);
|
||||
if (bw < 80000) {
|
||||
bw = 80000;
|
||||
}
|
||||
if (mTracker.mouseInView()) {
|
||||
int mfreqA = GetFrequencyAt(mTracker.getMouseX());
|
||||
SetBandwidth(bw);
|
||||
int mfreqB = GetFrequencyAt(mTracker.getMouseX());
|
||||
center_freq += mfreqA - mfreqB;
|
||||
if (mouseTracker.mouseInView()) {
|
||||
int mfreqA = getFrequencyAt(mouseTracker.getMouseX());
|
||||
setBandwidth(bw);
|
||||
int mfreqB = getFrequencyAt(mouseTracker.getMouseX());
|
||||
centerFreq += mfreqA - mfreqB;
|
||||
}
|
||||
|
||||
SetView(center_freq, bw);
|
||||
setView(centerFreq, bw);
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(center_freq, bw);
|
||||
spectrumCanvas->setView(centerFreq, bw);
|
||||
}
|
||||
} else {
|
||||
if (isView) {
|
||||
bw = GetBandwidth();
|
||||
bw = (unsigned int) ceil((float) bw * 1.05);
|
||||
bw = getBandwidth();
|
||||
bw = (unsigned int) ceil((float) bw * currentZoom);
|
||||
if ((int) bw >= SRATE) {
|
||||
bw = (unsigned int) SRATE;
|
||||
DisableView();
|
||||
disableView();
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->DisableView();
|
||||
spectrumCanvas->disableView();
|
||||
}
|
||||
} else {
|
||||
if (mTracker.mouseInView()) {
|
||||
if (mouseTracker.mouseInView()) {
|
||||
int freq = wxGetApp().getFrequency();
|
||||
int mfreqA = GetFrequencyAt(mTracker.getMouseX());
|
||||
SetBandwidth(bw);
|
||||
int mfreqB = GetFrequencyAt(mTracker.getMouseX());
|
||||
center_freq += mfreqA - mfreqB;
|
||||
int mfreqA = getFrequencyAt(mouseTracker.getMouseX());
|
||||
setBandwidth(bw);
|
||||
int mfreqB = getFrequencyAt(mouseTracker.getMouseX());
|
||||
centerFreq += mfreqA - mfreqB;
|
||||
}
|
||||
|
||||
SetView(GetCenterFrequency(), bw);
|
||||
setView(getCenterFrequency(), bw);
|
||||
if (spectrumCanvas) {
|
||||
spectrumCanvas->SetView(center_freq, bw);
|
||||
spectrumCanvas->setView(centerFreq, bw);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (center_freq < freq && (center_freq - bandwidth / 2) < (freq - SRATE / 2)) {
|
||||
center_freq = (freq - SRATE / 2) + bandwidth / 2;
|
||||
if (centerFreq < freq && (centerFreq - bandwidth / 2) < (freq - SRATE / 2)) {
|
||||
centerFreq = (freq - SRATE / 2) + bandwidth / 2;
|
||||
}
|
||||
if (center_freq > freq && (center_freq + bandwidth / 2) > (freq + SRATE / 2)) {
|
||||
center_freq = (freq + SRATE / 2) - bandwidth / 2;
|
||||
if (centerFreq > freq && (centerFreq + bandwidth / 2) > (freq + SRATE / 2)) {
|
||||
centerFreq = (freq + SRATE / 2) - bandwidth / 2;
|
||||
}
|
||||
}
|
||||
|
||||
@ -360,63 +369,63 @@ void WaterfallCanvas::setData(DemodulatorThreadIQData *input) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (center_freq != input->frequency) {
|
||||
if (((int) center_freq - (int) input->frequency) != shift_freq || last_input_bandwidth != input->bandwidth) {
|
||||
if ((int) input->frequency - abs((int) center_freq) < (int) ((float) ((float) SRATE / 2.0))) {
|
||||
shift_freq = (int) center_freq - (int) input->frequency;
|
||||
nco_crcf_reset(nco_shift);
|
||||
nco_crcf_set_frequency(nco_shift, (2.0 * M_PI) * (((float) abs(shift_freq)) / ((float) input->bandwidth)));
|
||||
if (centerFreq != input->frequency) {
|
||||
if (((int) centerFreq - (int) input->frequency) != shiftFrequency || lastInputBandwidth != input->bandwidth) {
|
||||
if ((int) input->frequency - abs((int) centerFreq) < (int) ((float) ((float) SRATE / 2.0))) {
|
||||
shiftFrequency = (int) centerFreq - (int) input->frequency;
|
||||
nco_crcf_reset(freqShifter);
|
||||
nco_crcf_set_frequency(freqShifter, (2.0 * M_PI) * (((float) abs(shiftFrequency)) / ((float) input->bandwidth)));
|
||||
}
|
||||
}
|
||||
|
||||
if (shift_buffer.size() != input->data.size()) {
|
||||
if (shift_buffer.capacity() < input->data.size()) {
|
||||
shift_buffer.reserve(input->data.size());
|
||||
if (shiftBuffer.size() != input->data.size()) {
|
||||
if (shiftBuffer.capacity() < input->data.size()) {
|
||||
shiftBuffer.reserve(input->data.size());
|
||||
}
|
||||
shift_buffer.resize(input->data.size());
|
||||
shiftBuffer.resize(input->data.size());
|
||||
}
|
||||
|
||||
if (shift_freq < 0) {
|
||||
nco_crcf_mix_block_up(nco_shift, &input->data[0], &shift_buffer[0], input->data.size());
|
||||
if (shiftFrequency < 0) {
|
||||
nco_crcf_mix_block_up(freqShifter, &input->data[0], &shiftBuffer[0], input->data.size());
|
||||
} else {
|
||||
nco_crcf_mix_block_down(nco_shift, &input->data[0], &shift_buffer[0], input->data.size());
|
||||
nco_crcf_mix_block_down(freqShifter, &input->data[0], &shiftBuffer[0], input->data.size());
|
||||
}
|
||||
} else {
|
||||
shift_buffer.assign(input->data.begin(), input->data.end());
|
||||
shiftBuffer.assign(input->data.begin(), input->data.end());
|
||||
}
|
||||
|
||||
if (!resampler || bandwidth != last_bandwidth || last_input_bandwidth != input->bandwidth) {
|
||||
resample_ratio = (double) (bandwidth) / (double) input->bandwidth;
|
||||
if (!resampler || bandwidth != lastBandwidth || lastInputBandwidth != input->bandwidth) {
|
||||
resamplerRatio = (double) (bandwidth) / (double) input->bandwidth;
|
||||
|
||||
float As = 60.0f;
|
||||
float As = 120.0f;
|
||||
|
||||
if (resampler) {
|
||||
msresamp_crcf_destroy(resampler);
|
||||
}
|
||||
resampler = msresamp_crcf_create(resample_ratio, As);
|
||||
resampler = msresamp_crcf_create(resamplerRatio, As);
|
||||
|
||||
last_bandwidth = bandwidth;
|
||||
last_input_bandwidth = input->bandwidth;
|
||||
lastBandwidth = bandwidth;
|
||||
lastInputBandwidth = input->bandwidth;
|
||||
}
|
||||
|
||||
int out_size = ceil((double) (input->data.size()) * resample_ratio) + 512;
|
||||
int out_size = ceil((double) (input->data.size()) * resamplerRatio) + 512;
|
||||
|
||||
if (resampler_buffer.size() != out_size) {
|
||||
if (resampler_buffer.capacity() < out_size) {
|
||||
resampler_buffer.reserve(out_size);
|
||||
if (resampleBuffer.size() != out_size) {
|
||||
if (resampleBuffer.capacity() < out_size) {
|
||||
resampleBuffer.reserve(out_size);
|
||||
}
|
||||
resampler_buffer.resize(out_size);
|
||||
resampleBuffer.resize(out_size);
|
||||
}
|
||||
|
||||
unsigned int num_written;
|
||||
msresamp_crcf_execute(resampler, &shift_buffer[0], input->data.size(), &resampler_buffer[0], &num_written);
|
||||
msresamp_crcf_execute(resampler, &shiftBuffer[0], input->data.size(), &resampleBuffer[0], &num_written);
|
||||
|
||||
resampler_buffer.resize(fft_size);
|
||||
resampleBuffer.resize(fft_size);
|
||||
|
||||
if (num_written < fft_size) {
|
||||
for (int i = 0; i < num_written; i++) {
|
||||
in[i][0] = resampler_buffer[i].real;
|
||||
in[i][1] = resampler_buffer[i].imag;
|
||||
in[i][0] = resampleBuffer[i].real;
|
||||
in[i][1] = resampleBuffer[i].imag;
|
||||
}
|
||||
for (int i = num_written; i < fft_size; i++) {
|
||||
in[i][0] = 0;
|
||||
@ -424,8 +433,8 @@ void WaterfallCanvas::setData(DemodulatorThreadIQData *input) {
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < fft_size; i++) {
|
||||
in[i][0] = resampler_buffer[i].real;
|
||||
in[i][1] = resampler_buffer[i].imag;
|
||||
in[i][0] = resampleBuffer[i].real;
|
||||
in[i][1] = resampleBuffer[i].imag;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -514,17 +523,17 @@ void WaterfallCanvas::OnIdle(wxIdleEvent &event) {
|
||||
Refresh(false);
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseMoved(event);
|
||||
void WaterfallCanvas::OnMouseMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseMoved(event);
|
||||
DemodulatorInstance *demod = wxGetApp().getDemodMgr().getActiveDemodulator();
|
||||
|
||||
if (mTracker.mouseDown()) {
|
||||
if (mouseTracker.mouseDown()) {
|
||||
if (demod == NULL) {
|
||||
return;
|
||||
}
|
||||
if (dragState == WF_DRAG_BANDWIDTH_LEFT || dragState == WF_DRAG_BANDWIDTH_RIGHT) {
|
||||
|
||||
int bwDiff = (int) (mTracker.getDeltaMouseX() * (float) GetBandwidth()) * 2;
|
||||
int bwDiff = (int) (mouseTracker.getDeltaMouseX() * (float) getBandwidth()) * 2;
|
||||
|
||||
if (dragState == WF_DRAG_BANDWIDTH_LEFT) {
|
||||
bwDiff = -bwDiff;
|
||||
@ -550,7 +559,7 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
}
|
||||
|
||||
if (dragState == WF_DRAG_FREQUENCY) {
|
||||
int bwDiff = (int) (mTracker.getDeltaMouseX() * (float) GetBandwidth());
|
||||
int bwDiff = (int) (mouseTracker.getDeltaMouseX() * (float) getBandwidth());
|
||||
|
||||
if (!activeDemodulatorFrequency) {
|
||||
activeDemodulatorFrequency = demod->getParams().frequency;
|
||||
@ -567,8 +576,10 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
|
||||
setStatusText("Set demodulator frequency: %s", activeDemodulatorFrequency);
|
||||
}
|
||||
} else if (mouseTracker.mouseRightDown()) {
|
||||
mouseZoom = mouseZoom + ((1.0 - (mouseTracker.getDeltaMouseY()*4.0))-mouseZoom) * 0.1;
|
||||
} else {
|
||||
int freqPos = GetFrequencyAt(mTracker.getMouseX());
|
||||
int freqPos = getFrequencyAt(mouseTracker.getMouseX());
|
||||
|
||||
std::vector<DemodulatorInstance *> *demodsHover = wxGetApp().getDemodMgr().getDemodulatorsAt(freqPos, 15000);
|
||||
|
||||
@ -576,8 +587,8 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
|
||||
if (altDown) {
|
||||
nextDragState = WF_DRAG_RANGE;
|
||||
mTracker.setVertDragLock(true);
|
||||
mTracker.setHorizDragLock(false);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
if (shiftDown) {
|
||||
setStatusText("Click and drag to create a new demodulator by range.");
|
||||
} else {
|
||||
@ -585,7 +596,7 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
}
|
||||
} else if (demodsHover->size()) {
|
||||
int hovered = -1;
|
||||
int near_dist = GetBandwidth();
|
||||
int near_dist = getBandwidth();
|
||||
|
||||
DemodulatorInstance *activeDemodulator = NULL;
|
||||
|
||||
@ -627,15 +638,15 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
nextDragState = WF_DRAG_BANDWIDTH_RIGHT;
|
||||
}
|
||||
|
||||
mTracker.setVertDragLock(true);
|
||||
mTracker.setHorizDragLock(false);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
setStatusText("Click and drag to change demodulator bandwidth. D to delete, SPACE for stereo.");
|
||||
} else {
|
||||
SetCursor(wxCURSOR_SIZING);
|
||||
nextDragState = WF_DRAG_FREQUENCY;
|
||||
|
||||
mTracker.setVertDragLock(true);
|
||||
mTracker.setHorizDragLock(false);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
setStatusText("Click and drag to change demodulator frequency. D to delete, SPACE for stereo.");
|
||||
}
|
||||
} else {
|
||||
@ -652,8 +663,8 @@ void WaterfallCanvas::mouseMoved(wxMouseEvent& event) {
|
||||
}
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseDown(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseDown(event);
|
||||
void WaterfallCanvas::OnMouseDown(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseDown(event);
|
||||
|
||||
dragState = nextDragState;
|
||||
|
||||
@ -665,25 +676,25 @@ void WaterfallCanvas::mouseDown(wxMouseEvent& event) {
|
||||
activeDemodulatorFrequency = 0;
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseWheelMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseWheelMoved(event);
|
||||
void WaterfallCanvas::OnMouseWheelMoved(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseWheelMoved(event);
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseReleased(event);
|
||||
void WaterfallCanvas::OnMouseReleased(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseReleased(event);
|
||||
|
||||
bool isNew = shiftDown
|
||||
|| (wxGetApp().getDemodMgr().getLastActiveDemodulator() && !wxGetApp().getDemodMgr().getLastActiveDemodulator()->isActive());
|
||||
|
||||
mTracker.setVertDragLock(false);
|
||||
mTracker.setHorizDragLock(false);
|
||||
mouseTracker.setVertDragLock(false);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
|
||||
DemodulatorInstance *demod;
|
||||
|
||||
if (mTracker.getOriginDeltaMouseX() == 0 && mTracker.getOriginDeltaMouseY() == 0) {
|
||||
float pos = mTracker.getMouseX();
|
||||
int input_center_freq = GetCenterFrequency();
|
||||
int freq = input_center_freq - (int) (0.5 * (float) GetBandwidth()) + (int) ((float) pos * (float) GetBandwidth());
|
||||
if (mouseTracker.getOriginDeltaMouseX() == 0 && mouseTracker.getOriginDeltaMouseY() == 0) {
|
||||
float pos = mouseTracker.getMouseX();
|
||||
int input_center_freq = getCenterFrequency();
|
||||
int freq = input_center_freq - (int) (0.5 * (float) getBandwidth()) + (int) ((float) pos * (float) getBandwidth());
|
||||
|
||||
if (dragState == WF_DRAG_NONE) {
|
||||
if (!isNew && wxGetApp().getDemodMgr().getDemodulators().size()) {
|
||||
@ -723,19 +734,19 @@ void WaterfallCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
wxGetApp().getDemodMgr().setActiveDemodulator(wxGetApp().getDemodMgr().getLastActiveDemodulator(), false);
|
||||
SetCursor(wxCURSOR_SIZING);
|
||||
nextDragState = WF_DRAG_FREQUENCY;
|
||||
mTracker.setVertDragLock(true);
|
||||
mTracker.setHorizDragLock(false);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
} else {
|
||||
wxGetApp().getDemodMgr().setActiveDemodulator(wxGetApp().getDemodMgr().getActiveDemodulator(), false);
|
||||
nextDragState = WF_DRAG_FREQUENCY;
|
||||
}
|
||||
} else if (dragState == WF_DRAG_RANGE) {
|
||||
float width = mTracker.getOriginDeltaMouseX();
|
||||
float pos = mTracker.getOriginMouseX() + width / 2.0;
|
||||
float width = mouseTracker.getOriginDeltaMouseX();
|
||||
float pos = mouseTracker.getOriginMouseX() + width / 2.0;
|
||||
|
||||
int input_center_freq = GetCenterFrequency();
|
||||
unsigned int freq = input_center_freq - (int) (0.5 * (float) GetBandwidth()) + (int) ((float) pos * (float) GetBandwidth());
|
||||
unsigned int bw = (unsigned int) (fabs(width) * (float) GetBandwidth());
|
||||
int input_center_freq = getCenterFrequency();
|
||||
unsigned int freq = input_center_freq - (int) (0.5 * (float) getBandwidth()) + (int) ((float) pos * (float) getBandwidth());
|
||||
unsigned int bw = (unsigned int) (fabs(width) * (float) getBandwidth());
|
||||
|
||||
if (bw < MIN_BANDWIDTH) {
|
||||
bw = MIN_BANDWIDTH;
|
||||
@ -786,14 +797,30 @@ void WaterfallCanvas::mouseReleased(wxMouseEvent& event) {
|
||||
dragState = WF_DRAG_NONE;
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseLeftWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseLeftWindow(event);
|
||||
void WaterfallCanvas::OnMouseLeftWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseLeftWindow(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
wxGetApp().getDemodMgr().setActiveDemodulator(NULL);
|
||||
mouseZoom = 1.0;
|
||||
}
|
||||
|
||||
void WaterfallCanvas::mouseEnterWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::mouseEnterWindow(event);
|
||||
void WaterfallCanvas::OnMouseEnterWindow(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseEnterWindow(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
}
|
||||
|
||||
void WaterfallCanvas::OnMouseRightDown(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseRightDown(event);
|
||||
|
||||
SetCursor(wxCURSOR_SIZENS);
|
||||
mouseTracker.setVertDragLock(true);
|
||||
mouseTracker.setHorizDragLock(true);
|
||||
}
|
||||
|
||||
void WaterfallCanvas::OnMouseRightReleased(wxMouseEvent& event) {
|
||||
InteractiveCanvas::OnMouseRightReleased(event);
|
||||
SetCursor(wxCURSOR_CROSS);
|
||||
mouseTracker.setVertDragLock(false);
|
||||
mouseTracker.setHorizDragLock(false);
|
||||
mouseZoom = 1.0;
|
||||
}
|
||||
|
@ -20,7 +20,7 @@ public:
|
||||
};
|
||||
|
||||
WaterfallCanvas(wxWindow *parent, int *attribList = NULL);
|
||||
void Setup(int fft_size_in, int waterfall_lines_in);
|
||||
void setup(int fft_size_in, int waterfall_lines_in);
|
||||
~WaterfallCanvas();
|
||||
|
||||
void setData(DemodulatorThreadIQData *input);
|
||||
@ -37,12 +37,14 @@ private:
|
||||
|
||||
void OnIdle(wxIdleEvent &event);
|
||||
|
||||
void mouseMoved(wxMouseEvent& event);
|
||||
void mouseDown(wxMouseEvent& event);
|
||||
void mouseWheelMoved(wxMouseEvent& event);
|
||||
void mouseReleased(wxMouseEvent& event);
|
||||
void mouseEnterWindow(wxMouseEvent& event);
|
||||
void mouseLeftWindow(wxMouseEvent& event);
|
||||
void OnMouseMoved(wxMouseEvent& event);
|
||||
void OnMouseWheelMoved(wxMouseEvent& event);
|
||||
void OnMouseDown(wxMouseEvent& event);
|
||||
void OnMouseReleased(wxMouseEvent& event);
|
||||
void OnMouseRightDown(wxMouseEvent& event);
|
||||
void OnMouseRightReleased(wxMouseEvent& event);
|
||||
void OnMouseEnterWindow(wxMouseEvent& event);
|
||||
void OnMouseLeftWindow(wxMouseEvent& event);
|
||||
|
||||
SpectrumCanvas *spectrumCanvas;
|
||||
std::vector<float> spectrum_points;
|
||||
@ -69,16 +71,15 @@ private:
|
||||
int waterfall_lines;
|
||||
|
||||
msresamp_crcf resampler;
|
||||
double resample_ratio;
|
||||
nco_crcf nco_shift;
|
||||
int shift_freq;
|
||||
double resamplerRatio;
|
||||
nco_crcf freqShifter;
|
||||
int shiftFrequency;
|
||||
|
||||
int last_input_bandwidth;
|
||||
int zoom;
|
||||
|
||||
std::vector<liquid_float_complex> shift_buffer;
|
||||
std::vector<liquid_float_complex> resampler_buffer;
|
||||
int lastInputBandwidth;
|
||||
float mouseZoom, zoom;
|
||||
|
||||
std::vector<liquid_float_complex> shiftBuffer;
|
||||
std::vector<liquid_float_complex> resampleBuffer;
|
||||
// event table
|
||||
wxDECLARE_EVENT_TABLE();
|
||||
};
|
||||
|
Loading…
Reference in New Issue
Block a user