static void *demod_thread_fn(void *arg)
{
while (!do_exit) {
safe_cond_wait(&ready, &ready_m);
pthread_rwlock_wrlock(&both.rw);
downsample(&both);
memcpy(left.buf, both.buf, 2*both.len_out);
memcpy(right.buf, both.buf, 2*both.len_out);
pthread_rwlock_unlock(&both.rw);
rotate_90(left.buf, left.len_in);
downsample(&left);
memcpy(left_demod.buf, left.buf, 2*left.len_out);
demodulate(&left_demod);
if (dc_filter) {
dc_block_filter(&left_demod);}
//if (oversample) {
// downsample(&left);}
arbitrary_upsample(left_demod.result, stereo.buf_left, left_demod.result_len, stereo.bl_len);
rotate_m90(right.buf, right.len_in);
downsample(&right);
memcpy(right_demod.buf, right.buf, 2*right.len_out);
demodulate(&right_demod);
if (dc_filter) {
dc_block_filter(&right_demod);}
//if (oversample) {
// downsample(&right);}
arbitrary_upsample(right_demod.result, stereo.buf_right, right_demod.result_len, stereo.br_len);
output();
}
rtlsdr_cancel_async(dev);
return 0;
}
static void *demod_thread_fn(void *arg)
{
struct fm_state *fm2 = arg;
while (!do_exit) {
safe_cond_wait(&data_ready, &data_mutex);
full_demod(fm2);
if (fm2->exit_flag) {
do_exit = 1;
//rtlsdr_cancel_async(dev);
}
}
return 0;
}
// tz this is where gain and frequency are set
//
//
static void *controller_thread_fn(void *arg)
{
// from original comments:
// thoughts for multiple dongles
// might be no good using a controller thread if retune/rate blocks
// int i;
struct controller_state *s = arg;
static int latency_timer = 0;
// tz - note that in optimal_settings the actual frequency in s-> is used to set the dongle.freq
// then the dongle.freq what gets sent to the device.
//
//
optimal_settings_new(s->freqs[0], demod.rate_in);
// tz - we have temporarily abandoned these options but here is where you would set them
//
// if (dongle.direct_sampling) {
// verbose_direct_sampling(dongle.dev, 1);}
// if (dongle.offset_tuning) {
// verbose_offset_tuning(dongle.dev);}
/* Set the frequency */
verbose_set_frequency(dongle.dev, dongle.freq);
sprintf(errmesg, "Oversampling input by: %ix.\n", demod.downsample);
post(errmesg,0);
sprintf(errmesg, "Oversampling output by: %ix.\n", demod.post_downsample);
post(errmesg,0);
sprintf(errmesg, "Buffer size: %0.2fms\n",
1000 * 0.5 * (float)ACTUAL_BUF_LENGTH / (float)dongle.rate);
post(errmesg,0);
/* Set the sample rate */
verbose_set_sample_rate(dongle.dev, dongle.rate);
sprintf(errmesg, "Output at %u Hz.\n", demod.rate_in/demod.post_downsample);
post(errmesg,0);
need_to_reset_circ_buffer = 1; // tz - this will cause read buffer to reset
while (!do_exit) {
//usleep(100000);
//post("in controller thread", 0);
safe_cond_wait(&s->hop, &s->hop_m);
// tz it might be possible to set 'mode' here - using the same init
// sequence as with restarting the radio
if(need_to_set_freq) {
need_to_set_freq = 0;
optimal_settings_new(new_freq, demod.rate_in);
rtlsdr_set_center_freq(dongle.dev, dongle.freq);
//sprintf(errmesg, "setting frequency to %d", new_freq);
//post(errmesg, 0);
// need_to_reset_circ_buffer = 1; // not sure if we need to do this here too...
// post("hello...");
}
if(need_to_set_gain) {
need_to_set_gain = 0;
dongle.gain = new_gain;
sprintf(errmesg, "setting gain to %d", new_gain);
post(errmesg, 0);
set_tuner_gain(&dongle);
}
if(need_to_reset_circ_buffer) {
need_to_reset_circ_buffer = 0;
latency_timer = circ_buf_latency_factor + 1;
circ_index_write = 0;
post("reseting circular buffer write index", 0);
}
// After latency timer counts down to 1, reset the read index too
// timer cound represents number of vectors (determined by latency factor)
if(latency_timer > 0) {
if(latency_timer == 1) {
post("reseting circular buffer read index", 0);
circ_index_read = 0;
}
latency_timer--;
}
}
return 0;
}
