/* -*- c++ -*- */
/*
* Copyright 2014,2016 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "atsc_sync_impl.h"
#include "atsc_types.h"
#include <gnuradio/io_signature.h>
namespace gr {
namespace dtv {
static const double LOOP_FILTER_TAP = 0.0005; // 0.0005 works
static const double ADJUSTMENT_GAIN = 1.0e-5 / (10 * ATSC_DATA_SEGMENT_LENGTH);
static const int SYMBOL_INDEX_OFFSET = 3;
static const int MIN_SEG_LOCK_CORRELATION_VALUE = 5;
static const signed char SSI_MIN = -16;
static const signed char SSI_MAX = 15;
atsc_sync::sptr atsc_sync::make(float rate)
{
return gnuradio::make_block_sptr<atsc_sync_impl>(rate);
}
atsc_sync_impl::atsc_sync_impl(float rate)
: gr::block("dtv_atsc_sync",
io_signature::make(1, 1, sizeof(float)),
io_signature::make(1, 1, ATSC_DATA_SEGMENT_LENGTH * sizeof(float))),
d_rx_clock_to_symbol_freq(rate / ATSC_SYMBOL_RATE),
d_si(0)
{
d_loop.set_taps(LOOP_FILTER_TAP);
reset();
}
void atsc_sync_impl::reset()
{
d_w = d_rx_clock_to_symbol_freq;
d_mu = 0.5;
d_timing_adjust = 0;
d_counter = 0;
d_symbol_index = 0;
d_seg_locked = false;
d_sr = 0;
memset(d_sample_mem,
0,
ATSC_DATA_SEGMENT_LENGTH * sizeof(*d_sample_mem)); // (float)0 = 0x00000000
memset(d_data_mem,
0,
ATSC_DATA_SEGMENT_LENGTH * sizeof(*d_data_mem)); // (float)0 = 0x00000000
memset(d_integrator,
SSI_MIN,
ATSC_DATA_SEGMENT_LENGTH * sizeof(*d_integrator)); // signed char
}
atsc_sync_impl::~atsc_sync_impl() {}
void atsc_sync_impl::forecast(int noutput_items, gr_vector_int& ninput_items_required)
{
unsigned ninputs = ninput_items_required.size();
for (unsigned i = 0; i < ninputs; i++)
ninput_items_required[i] =
static_cast<int>(noutput_items * d_rx_clock_to_symbol_freq *
ATSC_DATA_SEGMENT_LENGTH) +
1500 - 1;
}
int atsc_sync_impl::general_work(int noutput_items,
gr_vector_int& ninput_items,
gr_vector_const_void_star& input_items,
gr_vector_void_star& output_items)
{
const float* in = static_cast<const float*>(input_items[0]);
float* out = static_cast<float*>(output_items[0]);
float interp_sample;
// amount actually consumed
d_si = 0;
for (d_output_produced = 0; d_output_produced < noutput_items &&
(d_si + (int)d_interp.ntaps()) < ninput_items[0];) {
// First we interpolate a sample from input to work with
interp_sample = d_interp.interpolate(&in[d_si], d_mu);
// Apply our timing adjustment slowly over several samples
d_mu += ADJUSTMENT_GAIN * 1e3 * d_timing_adjust;
double s = d_mu + d_w;
double float_incr = floor(s);
d_mu = s - float_incr;
d_incr = (int)float_incr;
assert(d_incr >= 1 && d_incr <= 3);
d_si += d_incr;
// Remember the sample at this count position
d_sample_mem[d_counter] = interp_sample;
// Is the sample positive or negative?
int bit = (interp_sample < 0 ? 0 : 1);
// Put the sign bit into our shift register
d_sr = ((bit & 1) << 3) | (d_sr >> 1);
// When +,-,-,+ (0x9, 1001) samples show up we have likely found a segment
// sync, it is more likely the segment sync will show up at about the same
// spot every ATSC_DATA_SEGMENT_LENGTH samples so we add some weight
// to this spot every pass to prevent random +,-,-,+ symbols from
// confusing our synchronizer
d_integrator[d_counter] += ((d_sr == 0x9) ? +2 : -1);
if (d_integrator[d_counter] < SSI_MIN)
d_integrator[d_counter] = SSI_MIN;
if (d_integrator[d_counter] > SSI_MAX)
d_integrator[d_counter] = SSI_MAX;
d_symbol_index++;
if (d_symbol_index >= ATSC_DATA_SEGMENT_LENGTH)
d_symbol_index = 0;
d_counter++;
if (d_counter >= ATSC_DATA_SEGMENT_LENGTH) { // counter just wrapped...
int best_correlation_value = d_integrator[0];
int best_correlation_index = 0;
for (int i = 1; i < ATSC_DATA_SEGMENT_LENGTH; i++)
if (d_integrator[i] > best_correlation_value) {
best_correlation_value = d_integrator[i];
best_correlation_index = i;
}
d_seg_locked = best_correlation_value >= MIN_SEG_LOCK_CORRELATION_VALUE;
// the coefficients are -1,-1,+1,+1
// d_timing_adjust = d_sample_mem[best_correlation_index - 3] +
// d_sample_mem[best_correlation_index - 2] -
// d_sample_mem[best_correlation_index - 1] -
// d_sample_mem[best_correlation_index];
int corr_count = best_correlation_index;
d_timing_adjust = -d_sample_mem[corr_count--];
if (corr_count < 0)
corr_count = ATSC_DATA_SEGMENT_LENGTH - 1;
d_timing_adjust -= d_sample_mem[corr_count--];
if (corr_count < 0)
corr_count = ATSC_DATA_SEGMENT_LENGTH - 1;
d_timing_adjust += d_sample_mem[corr_count--];
if (corr_count < 0)
corr_count = ATSC_DATA_SEGMENT_LENGTH - 1;
d_timing_adjust += d_sample_mem[corr_count--];
d_symbol_index = SYMBOL_INDEX_OFFSET - 1 - best_correlation_index;
if (d_symbol_index < 0)
d_symbol_index += ATSC_DATA_SEGMENT_LENGTH;
d_counter = 0;
}
// If we are locked we can start filling and producing data packets
// Due to the way we lock the first data packet will almost always be
// half full, this is OK because the fs_checker will not let packets though
// until a non-corrupted field packet is found
if (d_seg_locked) {
d_data_mem[d_symbol_index] = interp_sample;
if (d_symbol_index >= (ATSC_DATA_SEGMENT_LENGTH - 1)) {
memcpy(&out[d_output_produced * ATSC_DATA_SEGMENT_LENGTH],
d_data_mem,
ATSC_DATA_SEGMENT_LENGTH * sizeof(float));
d_output_produced++;
}
}
}
consume_each(d_si);
return d_output_produced;
}
} /* namespace dtv */
} /* namespace gr */