mirror of https://github.com/lwvmobile/dsd-fme.git
1620 lines
57 KiB
C
1620 lines
57 KiB
C
/*
|
|
* Copyright (C) 2010 DSD Author
|
|
* GPG Key ID: 0x3F1D7FD0 (74EF 430D F7F2 0A48 FCE6 F630 FAA2 635D 3F1D 7FD0)
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
|
|
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
|
* AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
|
|
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
|
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
|
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
|
* PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include "dsd.h"
|
|
#include <locale.h>
|
|
|
|
//borrowed from LEH/DSDcc for 'improved NXDN sync detection'
|
|
int strncmperr(const char *s1, const char *s2, size_t size, int MaxErr)
|
|
{
|
|
|
|
int Compare = -1;
|
|
size_t i = 0;
|
|
int err = 0;
|
|
int BreakBeforeEnd = 0;
|
|
|
|
if(s1 && s2)
|
|
{
|
|
for(i = 0; i < size; i++)
|
|
{
|
|
if(((s1[i] & 0xFF) != '\0') && ((s2[i] & 0xFF) != '\0'))
|
|
{
|
|
if((s1[i] & 0xFF) != (s2[i] & 0xFF)) err++;
|
|
}
|
|
else
|
|
{
|
|
BreakBeforeEnd = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if((err <= MaxErr) && (BreakBeforeEnd == 0))
|
|
{
|
|
Compare = 0;
|
|
}
|
|
} /* End if(s1 && s2) */
|
|
|
|
return Compare;
|
|
} /* End strncmperr() */
|
|
|
|
char * getTime(void) //get pretty hh:mm:ss timestamp
|
|
{
|
|
time_t t = time(NULL);
|
|
|
|
char * curr;
|
|
char * stamp = asctime(localtime( & t));
|
|
|
|
curr = strtok(stamp, " ");
|
|
curr = strtok(NULL, " ");
|
|
curr = strtok(NULL, " ");
|
|
curr = strtok(NULL, " ");
|
|
|
|
return curr;
|
|
}
|
|
|
|
char * getDate(void) {
|
|
char datename[32];
|
|
char * curr2;
|
|
struct tm * to;
|
|
time_t t;
|
|
t = time(NULL);
|
|
to = localtime( & t);
|
|
strftime(datename, sizeof(datename), "%Y-%m-%d", to);
|
|
curr2 = strtok(datename, " ");
|
|
return curr2;
|
|
}
|
|
|
|
void
|
|
printFrameSync (dsd_opts * opts, dsd_state * state, char *frametype, int offset, char *modulation)
|
|
{
|
|
|
|
if (opts->verbose > 0)
|
|
{
|
|
fprintf (stderr,"%s ", getTime());
|
|
fprintf (stderr,"Sync: %s ", frametype);
|
|
}
|
|
if (opts->verbose > 2)
|
|
{
|
|
//fprintf (stderr,"o: %4i ", offset);
|
|
}
|
|
if (opts->verbose > 1)
|
|
{
|
|
//fprintf (stderr,"mod: %s ", modulation);
|
|
}
|
|
if (opts->verbose > 2)
|
|
{
|
|
//fprintf (stderr,"g: %f ", state->aout_gain);
|
|
}
|
|
|
|
}
|
|
|
|
int
|
|
getFrameSync (dsd_opts * opts, dsd_state * state)
|
|
{
|
|
/* detects frame sync and returns frame type
|
|
* 0 = +P25p1
|
|
* 1 = -P25p1
|
|
* 2 = +X2-TDMA (non inverted signal data frame)
|
|
* 3 = -X2-TDMA (inverted signal voice frame)
|
|
* 4 = +X2-TDMA (non inverted signal voice frame)
|
|
* 5 = -X2-TDMA (inverted signal data frame)
|
|
* 6 = +D-STAR
|
|
* 7 = -D-STAR
|
|
* 8 = +NXDN (non inverted voice frame)
|
|
* 9 = -NXDN (inverted voice frame)
|
|
* 10 = +DMR (non inverted signal data frame)
|
|
* 11 = -DMR (inverted signal voice frame)
|
|
* 12 = +DMR (non inverted signal voice frame)
|
|
* 13 = -DMR (inverted signal data frame)
|
|
* 14 = +ProVoice
|
|
* 15 = -ProVoice
|
|
* 16 = +NXDN (non inverted data frame)
|
|
* 17 = -NXDN (inverted data frame)
|
|
* 18 = +D-STAR_HD
|
|
* 19 = -D-STAR_HD
|
|
* 20 = +dPMR Frame Sync 1
|
|
* 21 = +dPMR Frame Sync 2
|
|
* 22 = +dPMR Frame Sync 3
|
|
* 23 = +dPMR Frame Sync 4
|
|
* 24 = -dPMR Frame Sync 1
|
|
* 25 = -dPMR Frame Sync 2
|
|
* 26 = -dPMR Frame Sync 3
|
|
* 27 = -dPMR Frame Sync 4
|
|
* 28 = +NXDN (sync only)
|
|
* 29 = -NXDN (sync only)
|
|
* 30 = +YSF
|
|
* 31 = -YSF
|
|
* 32 = DMR MS Voice
|
|
* 33 = DMR MS Data
|
|
* 34 = DMR RC Data
|
|
* 35 = +P25 P2
|
|
* 36 = -P25 P2
|
|
* 37 = +EDACS
|
|
* 38 = -EDACS
|
|
*/
|
|
|
|
|
|
//start control channel hunting if using trunking, time needs updating on each successful sync
|
|
//will need to assign frequencies to a CC array for P25 since that isn't imported from CSV
|
|
if (state->dmr_rest_channel == -1 && opts->p25_is_tuned == 0 && opts->p25_trunk == 1 && ( (time(NULL) - state->last_cc_sync_time) > (opts->trunk_hangtime + 0) ) ) //was 3, go to hangtime value
|
|
{
|
|
|
|
//test to switch back to 10/4 P1 QPSK for P25 FDMA CC
|
|
if (opts->mod_qpsk == 1 && state->p25_cc_is_tdma == 0)
|
|
{
|
|
state->samplesPerSymbol = 10;
|
|
state->symbolCenter = 4;
|
|
}
|
|
|
|
//start going through the lcn/frequencies CC/signal hunting
|
|
fprintf (stderr, "Control Channel Signal Lost. Searching for Control Channel.\n");
|
|
//make sure our current roll value doesn't exceed value of frequencies imported
|
|
if (state->lcn_freq_roll >= state->lcn_freq_count) //fixed this to skip the extra wait out at the end of the list
|
|
{
|
|
state->lcn_freq_roll = 0; //reset to zero
|
|
}
|
|
//roll an extra value up if the current is the same as what's already loaded -- faster hunting on Cap+, etc
|
|
if (state->lcn_freq_roll != 0)
|
|
{
|
|
if (state->trunk_lcn_freq[state->lcn_freq_roll-1] == state->trunk_lcn_freq[state->lcn_freq_roll])
|
|
{
|
|
state->lcn_freq_roll++;
|
|
//check roll again if greater than expected, then go back to zero
|
|
if (state->lcn_freq_roll >= state->lcn_freq_count)
|
|
{
|
|
state->lcn_freq_roll = 0; //reset to zero
|
|
}
|
|
}
|
|
}
|
|
//check that we have a non zero value first, then tune next frequency
|
|
if (state->trunk_lcn_freq[state->lcn_freq_roll] != 0)
|
|
{
|
|
//rigctl
|
|
if (opts->use_rigctl == 1)
|
|
{
|
|
if (opts->setmod_bw != 0 ) SetModulation(opts->rigctl_sockfd, opts->setmod_bw);
|
|
SetFreq(opts->rigctl_sockfd, state->trunk_lcn_freq[state->lcn_freq_roll]);
|
|
}
|
|
//rtl
|
|
if (opts->audio_in_type == 3)
|
|
{
|
|
#ifdef USE_RTLSDR
|
|
rtl_dev_tune (opts, state->trunk_lcn_freq[state->lcn_freq_roll]);
|
|
#endif
|
|
}
|
|
|
|
fprintf (stderr, "Tuning to Frequency: %.06lf MHz\n",
|
|
(double)state->trunk_lcn_freq[state->lcn_freq_roll]/1000000);
|
|
|
|
}
|
|
state->lcn_freq_roll++;
|
|
state->last_cc_sync_time = time(NULL); //set again to give another x seconds
|
|
}
|
|
|
|
int i, j, t, o, dibit, sync, symbol, synctest_pos, lastt;
|
|
char synctest[25];
|
|
char synctest12[13]; //dPMR
|
|
char synctest10[11]; //NXDN FSW only
|
|
char synctest19[20]; //NXDN Preamble + FSW
|
|
char synctest18[19];
|
|
char synctest32[33];
|
|
char synctest20[21]; //YSF
|
|
char synctest21[22]; //P25 S-OEMI (SACCH)
|
|
char synctest48[49]; //EDACS
|
|
char modulation[8];
|
|
char *synctest_p;
|
|
int symboltest_pos; //symbol test position, match to synctest_pos
|
|
int symboltest_p[10240]; //make this an array instead
|
|
char synctest_buf[10240]; //what actually is assigned to this, can't find its use anywhere?
|
|
int lmin, lmax, lidx;
|
|
|
|
//assign t_max value based on decoding type expected (all non-auto decodes first)
|
|
int t_max; //maximum values allowed for t will depend on decoding type - NXDN will be 10, others will be more
|
|
if (opts->frame_nxdn48 == 1 || opts->frame_nxdn96 == 1)
|
|
{
|
|
t_max = 10;
|
|
}
|
|
//else if dPMR
|
|
else if (opts->frame_dpmr == 1)
|
|
{
|
|
t_max = 12; //based on Frame_Sync_2 pattern
|
|
}
|
|
//if Phase 2 (or YSF in future), then only 19
|
|
else if (state->lastsynctype == 35 || state->lastsynctype == 36) //P2
|
|
{
|
|
t_max = 19; //Phase 2 S-ISCH is only 19
|
|
}
|
|
else t_max = 24; //24 for everything else
|
|
|
|
int lbuf[t_max], lbuf2[t_max];
|
|
int lsum;
|
|
char spectrum[64];
|
|
//init the lbuf
|
|
memset (lbuf, 0, sizeof(lbuf));
|
|
memset (lbuf2, 0, sizeof(lbuf2));
|
|
|
|
// detect frame sync
|
|
t = 0;
|
|
synctest10[10] = 0;
|
|
synctest[24] = 0;
|
|
synctest12[12] = 0;
|
|
synctest18[18] = 0;
|
|
synctest48[48] = 0;
|
|
synctest32[32] = 0;
|
|
synctest20[20] = 0;
|
|
synctest_pos = 0;
|
|
synctest_p = synctest_buf + 10;
|
|
sync = 0;
|
|
lmin = 0;
|
|
lmax = 0;
|
|
lidx = 0;
|
|
lastt = 0;
|
|
state->numflips = 0;
|
|
|
|
//move ncursesPrinter outside of the sync loop, causes weird lag inside the loop
|
|
if (opts->use_ncurses_terminal == 1)
|
|
{
|
|
ncursesPrinter(opts, state);
|
|
}
|
|
|
|
if ((opts->symboltiming == 1) && (state->carrier == 1))
|
|
{
|
|
//fprintf (stderr,"\nSymbol Timing:\n");
|
|
//printw("\nSymbol Timing:\n");
|
|
}
|
|
while (sync == 0)
|
|
{
|
|
|
|
t++;
|
|
|
|
symbol = getSymbol (opts, state, 0);
|
|
|
|
lbuf[lidx] = symbol;
|
|
state->sbuf[state->sidx] = symbol;
|
|
if ( lidx == (t_max - 1) ) //23 //9 for NXDN
|
|
{
|
|
lidx = 0;
|
|
}
|
|
else
|
|
{
|
|
lidx++;
|
|
}
|
|
if (state->sidx == (opts->ssize - 1))
|
|
{
|
|
state->sidx = 0;
|
|
}
|
|
else
|
|
{
|
|
state->sidx++;
|
|
}
|
|
|
|
if (lastt == t_max) //issue for QPSK on shorter sync pattern? //23
|
|
{
|
|
lastt = 0;
|
|
if (state->numflips > opts->mod_threshold)
|
|
{
|
|
if (opts->mod_qpsk == 1)
|
|
{
|
|
state->rf_mod = 1;
|
|
}
|
|
}
|
|
else if (state->numflips > 18)
|
|
{
|
|
if (opts->mod_gfsk == 1)
|
|
{
|
|
state->rf_mod = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (opts->mod_c4fm == 1)
|
|
{
|
|
state->rf_mod = 0;
|
|
}
|
|
}
|
|
state->numflips = 0;
|
|
}
|
|
else
|
|
{
|
|
lastt++;
|
|
}
|
|
|
|
if (state->dibit_buf_p > state->dibit_buf + 900000)
|
|
{
|
|
state->dibit_buf_p = state->dibit_buf + 200;
|
|
}
|
|
|
|
//determine dibit state
|
|
if (symbol > 0)
|
|
{
|
|
*state->dibit_buf_p = 1;
|
|
state->dibit_buf_p++;
|
|
dibit = 49; // '1'
|
|
}
|
|
else
|
|
{
|
|
*state->dibit_buf_p = 3;
|
|
state->dibit_buf_p++;
|
|
dibit = 51; // '3'
|
|
}
|
|
|
|
if (opts->symbol_out == 1 && dibit != 0)
|
|
{
|
|
int csymbol = 0;
|
|
if (dibit == 49)
|
|
{
|
|
csymbol = 1; //1
|
|
}
|
|
if (dibit == 51)
|
|
{
|
|
csymbol = 3; //3
|
|
}
|
|
//fprintf (stderr, "%d", dibit);
|
|
fputc (csymbol, opts->symbol_out_f);
|
|
}
|
|
|
|
//digitize test for storing dibits in buffer correctly for dmr recovery
|
|
|
|
if (state->dmr_payload_p > state->dmr_payload_buf + 900000)
|
|
{
|
|
state->dmr_payload_p = state->dmr_payload_buf + 200;
|
|
}
|
|
|
|
if (1 == 1)
|
|
{
|
|
if (symbol > state->center)
|
|
{
|
|
if (symbol > state->umid)
|
|
{
|
|
*state->dmr_payload_p = 1; // +3
|
|
}
|
|
else
|
|
{
|
|
*state->dmr_payload_p = 0; // +1
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (symbol < state->lmid)
|
|
{
|
|
*state->dmr_payload_p = 3; // -3
|
|
}
|
|
else
|
|
{
|
|
*state->dmr_payload_p = 2; // -1
|
|
}
|
|
}
|
|
}
|
|
|
|
state->dmr_payload_p++;
|
|
// end digitize and dmr buffer testing
|
|
|
|
*synctest_p = dibit;
|
|
if (t >= t_max) //works excelent now with short sync patterns, and no issues with large ones!
|
|
{
|
|
for (i = 0; i < t_max; i++) //24
|
|
{
|
|
lbuf2[i] = lbuf[i];
|
|
}
|
|
qsort (lbuf2, t_max, sizeof (int), comp);
|
|
lmin = (lbuf2[1] + lbuf2[2] + lbuf2[3]) / 3;
|
|
lmax = (lbuf2[t_max - 3] + lbuf2[t_max - 2] + lbuf2[t_max - 1]) / 3;
|
|
|
|
if (state->rf_mod == 1)
|
|
{
|
|
state->minbuf[state->midx] = lmin;
|
|
state->maxbuf[state->midx] = lmax;
|
|
if (state->midx == (opts->msize - 1)) //-1
|
|
{
|
|
state->midx = 0;
|
|
}
|
|
else
|
|
{
|
|
state->midx++;
|
|
}
|
|
lsum = 0;
|
|
for (i = 0; i < opts->msize; i++)
|
|
{
|
|
lsum += state->minbuf[i];
|
|
}
|
|
state->min = lsum / opts->msize;
|
|
lsum = 0;
|
|
for (i = 0; i < opts->msize; i++)
|
|
{
|
|
lsum += state->maxbuf[i];
|
|
}
|
|
state->max = lsum / opts->msize;
|
|
state->center = ((state->max) + (state->min)) / 2;
|
|
state->maxref = (int)((state->max) * 0.80F);
|
|
state->minref = (int)((state->min) * 0.80F);
|
|
}
|
|
else
|
|
{
|
|
state->maxref = state->max;
|
|
state->minref = state->min;
|
|
}
|
|
|
|
//if using an rtl input method, do not look for sync patterns if the rms value is lower than our 'soft squelch' level
|
|
if (opts->audio_in_type == 3 && opts->rtl_rms < opts->rtl_squelch_level) //tests show floor level around 40, and signal breaking 100, default is 100 for level
|
|
{
|
|
if (opts->frame_nxdn48 == 1 || opts->frame_nxdn96 == 1 || opts->frame_dpmr == 1)
|
|
{
|
|
//should we update min/max here? yes or no?
|
|
// state->max = ((state->max) + lmax) / 2;
|
|
// state->min = ((state->min) + lmin) / 2;
|
|
|
|
goto SYNC_TEST_END;
|
|
}
|
|
}
|
|
|
|
strncpy (synctest, (synctest_p - 23), 24);
|
|
if (opts->frame_p25p1 == 1)
|
|
{
|
|
if (strcmp (synctest, P25P1_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
state->dmrburstR = 17;
|
|
state->payload_algidR = 0;
|
|
state->dmr_stereo = 1; //check to see if this causes dmr data issues later on during mixed sync types
|
|
sprintf (state->ftype, "P25 Phase 1");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+P25p1 ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 0;
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (0);
|
|
}
|
|
if (strcmp (synctest, INV_P25P1_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
state->dmrburstR = 17;
|
|
state->payload_algidR = 0;
|
|
state->dmr_stereo = 1; //check to see if this causes dmr data issues later on during mixed sync types
|
|
sprintf (state->ftype, "P25 Phase 1");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-P25p1 ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 1;
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (1);
|
|
}
|
|
}
|
|
if (opts->frame_x2tdma == 1)
|
|
{
|
|
if ((strcmp (synctest, X2TDMA_BS_DATA_SYNC) == 0) || (strcmp (synctest, X2TDMA_MS_DATA_SYNC) == 0))
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + (lmax)) / 2;
|
|
state->min = ((state->min) + (lmin)) / 2;
|
|
if (opts->inverted_x2tdma == 0)
|
|
{
|
|
// data frame
|
|
sprintf (state->ftype, "X2-TDMA");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+X2-TDMA ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 2;
|
|
return (2);
|
|
}
|
|
else
|
|
{
|
|
// inverted voice frame
|
|
sprintf (state->ftype, "X2-TDMA");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-X2-TDMA ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 3)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 3;
|
|
return (3);
|
|
}
|
|
}
|
|
if ((strcmp (synctest, X2TDMA_BS_VOICE_SYNC) == 0) || (strcmp (synctest, X2TDMA_MS_VOICE_SYNC) == 0))
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
if (opts->inverted_x2tdma == 0)
|
|
{
|
|
// voice frame
|
|
sprintf (state->ftype, "X2-TDMA");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+X2-TDMA ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 4)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 4;
|
|
return (4);
|
|
}
|
|
else
|
|
{
|
|
// inverted data frame
|
|
sprintf (state->ftype, "X2-TDMA");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-X2-TDMA ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 5;
|
|
return (5);
|
|
}
|
|
}
|
|
}
|
|
//YSF sync
|
|
strncpy(synctest20, (synctest_p - 19), 20); //double check make sure this is right
|
|
if(opts->frame_ysf == 1) //(opts->frame_ysf == 1
|
|
{
|
|
if (0 == 0) //opts->inverted_ysf == 0
|
|
{
|
|
if (strcmp(synctest20, FUSION_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
fprintf (stderr, "\nYSF FUSION SYNC \n");
|
|
opts->inverted_ysf = 0; //should we set this here?
|
|
state->lastsynctype = 30;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (30);
|
|
}
|
|
}
|
|
}
|
|
if(opts->frame_ysf == 1) //(opts->frame_ysf == 1
|
|
{
|
|
if (0 == 0) //opts->inverted_ysf == 1
|
|
{
|
|
if (strcmp(synctest20, INV_FUSION_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
fprintf (stderr, "\nINVERTED YSF FUSION SYNC \n");
|
|
opts->inverted_ysf = 1; //should we set this here?
|
|
state->lastsynctype = 31;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (31);
|
|
}
|
|
}
|
|
}
|
|
//end YSF sync
|
|
|
|
//P25 P2 sync S-ISCH VCH
|
|
strncpy(synctest20, (synctest_p - 19), 20);
|
|
if(opts->frame_p25p2 == 1)
|
|
{
|
|
if (0 == 0)
|
|
{
|
|
if (strcmp(synctest20, P25P2_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
opts->inverted_p2 = 0;
|
|
state->lastsynctype = 35; //35
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+P25p2 SISCH", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->p2_wacn != 0 && state->p2_cc != 0 && state->p2_sysid != 0)
|
|
{
|
|
//fprintf (stderr, "%s", KCYN);
|
|
fprintf (stderr, " WACN [%05llX] SYS [%03llX] NAC [%03llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc);
|
|
//fprintf (stderr, "%s", KNRM);
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr, "%s", KRED);
|
|
fprintf (stderr, " P2 Missing Parameters ");
|
|
fprintf (stderr, "%s", KNRM);
|
|
}
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (35); //35
|
|
}
|
|
}
|
|
}
|
|
if(opts->frame_p25p2 == 1)
|
|
{
|
|
if (0 == 0)
|
|
{
|
|
//S-ISCH VCH
|
|
if (strcmp(synctest20, INV_P25P2_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
opts->inverted_p2 = 1;
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-P25p2 SISCH", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->p2_wacn != 0 && state->p2_cc != 0 && state->p2_sysid != 0)
|
|
{
|
|
//fprintf (stderr, "%s", KCYN);
|
|
fprintf (stderr, " WACN [%05llX] SYS [%03llX] NAC [%03llX] ", state->p2_wacn, state->p2_sysid, state->p2_cc);
|
|
//fprintf (stderr, "%s", KNRM);
|
|
}
|
|
else
|
|
{
|
|
fprintf (stderr, "%s", KRED);
|
|
fprintf (stderr, " P2 Missing Parameters ");
|
|
fprintf (stderr, "%s", KNRM);
|
|
}
|
|
|
|
state->lastsynctype = 36; //36
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (36); //36
|
|
}
|
|
}
|
|
}
|
|
|
|
//dPMR sync
|
|
strncpy(synctest, (synctest_p - 23), 24);
|
|
strncpy(synctest12, (synctest_p - 11), 12);
|
|
if(opts->frame_dpmr == 1)
|
|
{
|
|
if (opts->inverted_dpmr == 0)
|
|
{
|
|
if(strcmp(synctest, DPMR_FRAME_SYNC_1) == 0)
|
|
{
|
|
//fprintf (stderr, "+dPMR FS1\n");
|
|
}
|
|
if(strcmp(synctest12, DPMR_FRAME_SYNC_2) == 0)
|
|
{
|
|
//fprintf (stderr, "DPMR_FRAME_SYNC_2\n");
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
sprintf(state->ftype, "dPMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+dPMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 21;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (21);
|
|
}
|
|
if(strcmp(synctest12, DPMR_FRAME_SYNC_3) == 0)
|
|
{
|
|
//fprintf (stderr, "+dPMR FS3 \n");
|
|
}
|
|
if(strcmp(synctest, DPMR_FRAME_SYNC_4) == 0)
|
|
{
|
|
//fprintf (stderr, "+dPMR FS4 \n");
|
|
}
|
|
}
|
|
if (opts->inverted_dpmr == 1)
|
|
{
|
|
if(strcmp(synctest, INV_DPMR_FRAME_SYNC_1) == 0)
|
|
{
|
|
//fprintf (stderr, "-dPMR FS1 \n");
|
|
}
|
|
if(strcmp(synctest12, INV_DPMR_FRAME_SYNC_2) == 0)
|
|
{
|
|
//fprintf (stderr, "INV_DPMR_FRAME_SYNC_2\n");
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
sprintf(state->ftype, "dPMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-dPMR ", synctest_pos + 1, modulation);
|
|
}
|
|
|
|
state->lastsynctype = 25;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (25);
|
|
}
|
|
if(strcmp(synctest12, INV_DPMR_FRAME_SYNC_3) == 0)
|
|
{
|
|
//fprintf (stderr, "-dPMR FS3 \n");
|
|
}
|
|
if(strcmp(synctest, INV_DPMR_FRAME_SYNC_4) == 0)
|
|
{
|
|
//fprintf (stderr, "-dPMR FS4 \n");
|
|
}
|
|
}
|
|
}
|
|
|
|
//New DMR Sync
|
|
if (opts->frame_dmr == 1)
|
|
{
|
|
|
|
if(strcmp (synctest, DMR_MS_DATA_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
//state->directmode = 0;
|
|
//fprintf (stderr, "DMR MS Data");
|
|
if (opts->inverted_dmr == 0) //opts->inverted_dmr
|
|
{
|
|
// data frame
|
|
sprintf(state->ftype, "DMR MS");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR MS Data", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 33) //33
|
|
{
|
|
//state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 33; //33
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (33); //33
|
|
}
|
|
else //inverted MS voice frame
|
|
{
|
|
sprintf(state->ftype, "DMR MS");
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (32);
|
|
}
|
|
}
|
|
//not sure if this should be here, RC data should only be present in vc6?
|
|
if(strcmp (synctest, DMR_RC_DATA_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
//state->directmode = 0;
|
|
//fprintf (stderr, "DMR RC DATA\n");
|
|
state->dmr_ms_rc == 1; //set flag for RC data, then process accordingly and reset back to 0 afterwards
|
|
if (0 == 0) //opts->inverted_dmr
|
|
{
|
|
// voice frame
|
|
sprintf(state->ftype, "DMR RC");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR RC Data", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 34)
|
|
{
|
|
//state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 34;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (34);
|
|
}
|
|
}
|
|
|
|
if(strcmp (synctest, DMR_MS_VOICE_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
//state->directmode = 0;
|
|
//fprintf (stderr, "DMR MS VOICE\n");
|
|
if (opts->inverted_dmr == 0) //opts->inverted_dmr
|
|
{
|
|
// voice frame
|
|
sprintf(state->ftype, "DMR MS");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR MS Voice", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 32)
|
|
{
|
|
//state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (32);
|
|
}
|
|
else //inverted MS data frame
|
|
{
|
|
sprintf(state->ftype, "DMR MS");
|
|
state->lastsynctype = 33;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (33);
|
|
}
|
|
|
|
}
|
|
|
|
//if ((strcmp (synctest, DMR_MS_DATA_SYNC) == 0) || (strcmp (synctest, DMR_BS_DATA_SYNC) == 0))
|
|
if (strcmp (synctest, DMR_BS_DATA_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + (lmax)) / 2;
|
|
state->min = ((state->min) + (lmin)) / 2;
|
|
state->directmode = 0;
|
|
if (opts->inverted_dmr == 0)
|
|
{
|
|
// data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 10;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (10);
|
|
}
|
|
else
|
|
{
|
|
// inverted voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 11)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 11;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (11); //11
|
|
}
|
|
}
|
|
if(strcmp (synctest, DMR_DIRECT_MODE_TS1_DATA_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + (lmax)) / 2;
|
|
state->min = ((state->min) + (lmin)) / 2;
|
|
//state->currentslot = 0;
|
|
state->directmode = 1; //Direct mode
|
|
if (opts->inverted_dmr == 0)
|
|
{
|
|
// data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 33;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (33);
|
|
}
|
|
else
|
|
{
|
|
// inverted voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 11)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (32);
|
|
}
|
|
} /* End if(strcmp (synctest, DMR_DIRECT_MODE_TS1_DATA_SYNC) == 0) */
|
|
if(strcmp (synctest, DMR_DIRECT_MODE_TS2_DATA_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + (lmax)) / 2;
|
|
state->min = ((state->min) + (lmin)) / 2;
|
|
//state->currentslot = 1;
|
|
state->directmode = 1; //Direct mode
|
|
if (opts->inverted_dmr == 0)
|
|
{
|
|
// data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 33;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (33);
|
|
}
|
|
else
|
|
{
|
|
// inverted voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 11)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (32);
|
|
}
|
|
} /* End if(strcmp (synctest, DMR_DIRECT_MODE_TS2_DATA_SYNC) == 0) */
|
|
//if((strcmp (synctest, DMR_MS_VOICE_SYNC) == 0) || (strcmp (synctest, DMR_BS_VOICE_SYNC) == 0))
|
|
if(strcmp (synctest, DMR_BS_VOICE_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
state->directmode = 0;
|
|
if (opts->inverted_dmr == 0)
|
|
{
|
|
// voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 12)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 12;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (12);
|
|
}
|
|
|
|
else
|
|
{
|
|
// inverted data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1) //&& opts->dmr_stereo == 0
|
|
{
|
|
printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 13;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (13);
|
|
}
|
|
}
|
|
if(strcmp (synctest, DMR_DIRECT_MODE_TS1_VOICE_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
//state->currentslot = 0;
|
|
state->directmode = 1; //Direct mode
|
|
if (opts->inverted_dmr == 0) //&& opts->dmr_stereo == 1
|
|
{
|
|
// voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 12)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (32); //treat Direct Mode same as MS mode for now
|
|
}
|
|
else
|
|
{
|
|
// inverted data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 33;
|
|
return (33);
|
|
}
|
|
} /* End if(strcmp (synctest, DMR_DIRECT_MODE_TS1_VOICE_SYNC) == 0) */
|
|
if(strcmp (synctest, DMR_DIRECT_MODE_TS2_VOICE_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
// state->currentslot = 1;
|
|
state->directmode = 1; //Direct mode
|
|
if (opts->inverted_dmr == 0) //&& opts->dmr_stereo == 1
|
|
{
|
|
// voice frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "+DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
if (state->lastsynctype != 12)
|
|
{
|
|
state->firstframe = 1;
|
|
}
|
|
state->lastsynctype = 32;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (32);
|
|
}
|
|
else
|
|
{
|
|
// inverted data frame
|
|
sprintf(state->ftype, "DMR ");
|
|
if (opts->errorbars == 1 && opts->dmr_stereo == 0)
|
|
{
|
|
//printFrameSync (opts, state, "-DMR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 33;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
state->last_cc_sync_time = time(NULL);
|
|
return (33);
|
|
}
|
|
} //End if(strcmp (synctest, DMR_DIRECT_MODE_TS2_VOICE_SYNC) == 0)
|
|
} //End if (opts->frame_dmr == 1)
|
|
|
|
//end DMR Sync
|
|
|
|
//ProVoice and EDACS sync
|
|
if (opts->frame_provoice == 1)
|
|
{
|
|
strncpy (synctest32, (synctest_p - 31), 32);
|
|
strncpy (synctest48, (synctest_p - 47), 48);
|
|
if ((strcmp (synctest32, PROVOICE_SYNC) == 0) || (strcmp (synctest32, PROVOICE_EA_SYNC) == 0))
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "ProVoice ");
|
|
if (opts->errorbars == 1)
|
|
printFrameSync (opts, state, "+PV ", synctest_pos + 1, modulation);
|
|
state->lastsynctype = 14;
|
|
return (14);
|
|
}
|
|
else if ((strcmp (synctest32, INV_PROVOICE_SYNC) == 0) || (strcmp (synctest32, INV_PROVOICE_EA_SYNC) == 0))
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "ProVoice ");
|
|
printFrameSync (opts, state, "-PV ", synctest_pos + 1, modulation);
|
|
state->lastsynctype = 15;
|
|
return (15);
|
|
}
|
|
else if ( strcmp (synctest48, EDACS_SYNC) == 0)
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
printFrameSync (opts, state, "-EDACS", synctest_pos + 1, modulation);
|
|
state->lastsynctype = 38;
|
|
return (38);
|
|
}
|
|
else if ( strcmp (synctest48, INV_EDACS_SYNC) == 0)
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
printFrameSync (opts, state, "+EDACS", synctest_pos + 1, modulation);
|
|
state->lastsynctype = 37;
|
|
return (37);
|
|
}
|
|
|
|
}
|
|
|
|
else if (opts->frame_dstar == 1)
|
|
{
|
|
if (strcmp (synctest, DSTAR_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "D-STAR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+D-STAR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 6;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (6);
|
|
}
|
|
if (strcmp (synctest, INV_DSTAR_SYNC) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "D-STAR ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-D-STAR ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 7;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (7);
|
|
}
|
|
if (strcmp (synctest, DSTAR_HD) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "D-STAR_HD ");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "+D-STAR_HD ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 18;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (18);
|
|
}
|
|
if (strcmp (synctest, INV_DSTAR_HD) == 0)
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, " D-STAR_HD");
|
|
if (opts->errorbars == 1)
|
|
{
|
|
printFrameSync (opts, state, "-D-STAR_HD ", synctest_pos + 1, modulation);
|
|
}
|
|
state->lastsynctype = 19;
|
|
if ( opts->monitor_input_audio == 1)
|
|
{
|
|
|
|
pa_simple_flush(opts->pulse_raw_dev_out, NULL);
|
|
}
|
|
return (19);
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef NXDNTESTSYNC //
|
|
|
|
//NXDN FSW sync and handling - using more exact frame sync values
|
|
else if ((opts->frame_nxdn96 == 1) || (opts->frame_nxdn48 == 1))
|
|
{
|
|
strncpy (synctest10, (synctest_p - 9), 10); //FSW only
|
|
strncpy (synctest19, (synctest_p - 18), 19); //Preamble + FSW
|
|
|
|
//Using Hard Coded Sync Strings with variations for the areas where the symbol
|
|
//error will occur due to the demodulation issues internally
|
|
|
|
//Preamble plus FSW, proceed right away
|
|
if (
|
|
|
|
(strcmp (synctest19, "3131133313131331131") == 0 )
|
|
|| (strcmp (synctest19, "3131133313331331131") == 0 )
|
|
|| (strcmp (synctest19, "3131133313131331111") == 0 )
|
|
|| (strcmp (synctest19, "3131133313331331111") == 0 )
|
|
|
|
)
|
|
{
|
|
// state->carrier = 1;
|
|
state->lastsynctype = 28;
|
|
state->last_cc_sync_time = time(NULL);
|
|
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, "\n +PANDF ");
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, " %s \n", synctest19);
|
|
return (28);
|
|
}
|
|
else if (
|
|
|
|
(strcmp (synctest19, "1313311133131331131") == 0 )
|
|
|| (strcmp (synctest19, "1313311133331331131") == 0 )
|
|
|| (strcmp (synctest19, "1313311133131331111") == 0 )
|
|
|| (strcmp (synctest19, "1313311133331331111") == 0 )
|
|
|
|
)
|
|
{
|
|
// state->carrier = 1;
|
|
state->lastsynctype = 29;
|
|
state->last_cc_sync_time = time(NULL);
|
|
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, "\n -PANDF ");
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, " %s \n", synctest19);
|
|
return (29);
|
|
}
|
|
|
|
else if (
|
|
(strcmp (synctest10, "3131331131") == 0 )
|
|
|| (strcmp (synctest10, "3331331131") == 0 )
|
|
|| (strcmp (synctest10, "3131331111") == 0 )
|
|
|| (strcmp (synctest10, "3331331111") == 0 )
|
|
|
|
)
|
|
{
|
|
// state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
if (state->lastsynctype == 28)
|
|
{
|
|
state->lastsynctype = 28;
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, "\n +FSW ");
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, " %s \n", synctest10);
|
|
return (28);
|
|
}
|
|
|
|
state->lastsynctype = 28;
|
|
|
|
|
|
}
|
|
|
|
else if (
|
|
|
|
(strcmp (synctest10, "1313113313") == 0 )
|
|
|| (strcmp (synctest10, "1113113313") == 0 )
|
|
|| (strcmp (synctest10, "1313113333") == 0 )
|
|
|| (strcmp (synctest10, "1113113333") == 0 )
|
|
|
|
)
|
|
{
|
|
// state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
if (state->lastsynctype == 29)
|
|
{
|
|
state->lastsynctype = 29;
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, "\n -FSW ");
|
|
// if (opts->payload == 1)
|
|
// fprintf (stderr, " %s \n", synctest10);
|
|
return (29);
|
|
}
|
|
state->lastsynctype = 29;
|
|
|
|
}
|
|
}
|
|
|
|
#else //use previous NXDN Sync pattern detection
|
|
|
|
//NXDN FSW sync and handling - moved to very bottom of sync stack for falsing sanity
|
|
else if ((opts->frame_nxdn96 == 1) || (opts->frame_nxdn48 == 1))
|
|
{
|
|
strncpy (synctest10, (synctest_p - 9), 10); //FSW only
|
|
strncpy (synctest19, (synctest_p - 18), 19); //Preamble + FSW
|
|
|
|
//Preamble plus FSW, proceed right away
|
|
if ( (strncmperr (synctest19, NXDN_PANDFSW, 19, 1) == 0) )
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
state->lastsynctype = 28;
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1) fprintf (stderr, "PANDF ");
|
|
// fprintf (stderr, " %s ", synctest19);
|
|
return (28);
|
|
}
|
|
|
|
else if ( (strncmperr (synctest19, INV_NXDN_PANDFSW, 19, 1) == 0) )
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
state->lastsynctype = 29;
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1) fprintf (stderr, "PANDF ");
|
|
// fprintf (stderr, " %s ", synctest19);
|
|
return (29);
|
|
}
|
|
|
|
else if ( (strncmperr (synctest10, NXDN_FSW, 10, 1) == 0) )
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
if (state->lastsynctype == 28)
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1) fprintf (stderr, "FSW ");
|
|
// fprintf (stderr, " %s ", synctest10);
|
|
return (28);
|
|
}
|
|
state->lastsynctype = 28; //need two consecutive patterns to continue
|
|
|
|
}
|
|
|
|
else if ( (strncmperr (synctest10, INV_NXDN_FSW, 10, 1) == 0) )
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
|
|
if (state->lastsynctype == 29)
|
|
{
|
|
state->last_cc_sync_time = time(NULL);
|
|
// if (opts->payload == 1) fprintf (stderr, "FSW ");
|
|
// fprintf (stderr, " %s ", synctest10);
|
|
return (29);
|
|
}
|
|
state->lastsynctype = 29; //need two consecutive patterns to continue
|
|
|
|
}
|
|
}
|
|
|
|
#endif //NXDN Sync Type Selection
|
|
|
|
//Provoice Conventional -- Some False Positives due to shortened frame sync pattern, so use squelch if possible
|
|
#ifdef PVCONVENTIONAL
|
|
if (opts->frame_provoice == 1)
|
|
{
|
|
memset (synctest32, 0, sizeof(synctest32));
|
|
strncpy (synctest32, (synctest_p - 31), 16); //short sync grab here on 32
|
|
char pvc_txs[9]; //string (symbol) value of TX Address
|
|
char pvc_rxs[9]; //string (symbol) value of RX Address
|
|
uint8_t pvc_txa = 0; //actual value of TX Address
|
|
uint8_t pvc_rxa = 0; //actual value of RX Address
|
|
strncpy (pvc_txs, (synctest_p - 15), 8); //copy string value of TX Address
|
|
strncpy (pvc_rxs, (synctest_p - 7), 8); //copy string value of RX Address
|
|
if ((strcmp (synctest32, INV_PROVOICE_CONV_SHORT) == 0))
|
|
{
|
|
if (state->lastsynctype == 15) //use this condition, like NXDN, to migitage false positives due to short sync pattern
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "ProVoice ");
|
|
// fprintf (stderr, "Sync Pattern = %s ", synctest32);
|
|
// fprintf (stderr, "TX = %s ", pvc_txs);
|
|
// fprintf (stderr, "RX = %s ", pvc_rxs);
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
pvc_txa = pvc_txa << 1;
|
|
pvc_rxa = pvc_rxa << 1;
|
|
//symbol 1 is binary 1 on inverted
|
|
//I hate working with strings, has to be a better way to evaluate this
|
|
memset (pvc_txs, 0, sizeof (pvc_txs));
|
|
memset (pvc_rxs, 0, sizeof (pvc_rxs));
|
|
strncpy (pvc_txs, (synctest_p - 15+i), 1);
|
|
strncpy (pvc_rxs, (synctest_p - 7+i), 1);
|
|
if ((strcmp (pvc_txs, "1") == 0))
|
|
pvc_txa = pvc_txa + 1;
|
|
if ((strcmp (pvc_rxs, "1") == 0))
|
|
pvc_rxa = pvc_rxa + 1;
|
|
}
|
|
printFrameSync (opts, state, "-PV_C ", synctest_pos + 1, modulation);
|
|
fprintf (stderr, "TX: %d ", pvc_txa);
|
|
fprintf (stderr, "RX: %d ", pvc_rxa);
|
|
if (pvc_txa == 172) fprintf (stderr, "ALL CALL ");
|
|
state->lastsynctype = 15;
|
|
return (15);
|
|
}
|
|
state->lastsynctype = 15;
|
|
}
|
|
else if ((strcmp (synctest32, PROVOICE_CONV_SHORT) == 0))
|
|
{
|
|
if (state->lastsynctype == 14) //use this condition, like NXDN, to migitage false positives due to short sync pattern
|
|
{
|
|
state->carrier = 1;
|
|
state->offset = synctest_pos;
|
|
state->max = ((state->max) + lmax) / 2;
|
|
state->min = ((state->min) + lmin) / 2;
|
|
sprintf (state->ftype, "ProVoice ");
|
|
// fprintf (stderr, "Sync Pattern = %s ", synctest32);
|
|
// fprintf (stderr, "TX = %s ", pvc_txs);
|
|
// fprintf (stderr, "RX = %s ", pvc_rxs);
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
pvc_txa = pvc_txa << 1;
|
|
pvc_rxa = pvc_rxa << 1;
|
|
//symbol 3 is binary 1 on positive
|
|
//I hate working with strings, has to be a better way to evaluate this
|
|
memset (pvc_txs, 0, sizeof (pvc_txs));
|
|
memset (pvc_rxs, 0, sizeof (pvc_rxs));
|
|
strncpy (pvc_txs, (synctest_p - 15+i), 1);
|
|
strncpy (pvc_rxs, (synctest_p - 7+i), 1);
|
|
if ((strcmp (pvc_txs, "3") == 0))
|
|
pvc_txa = pvc_txa + 1;
|
|
if ((strcmp (pvc_rxs, "3") == 0))
|
|
pvc_rxa = pvc_rxa + 1;
|
|
}
|
|
printFrameSync (opts, state, "+PV_C ", synctest_pos + 1, modulation);
|
|
fprintf (stderr, "TX: %d ", pvc_txa);
|
|
fprintf (stderr, "RX: %d ", pvc_rxa);
|
|
if (pvc_txa == 172) fprintf (stderr, "ALL CALL ");
|
|
state->lastsynctype = 14;
|
|
return (14);
|
|
}
|
|
state->lastsynctype = 14;
|
|
}
|
|
}
|
|
#endif //End Provoice Conventional
|
|
|
|
SYNC_TEST_END: ; //do nothing
|
|
|
|
} // t >= 10
|
|
|
|
if (exitflag == 1)
|
|
{
|
|
cleanupAndExit (opts, state);
|
|
}
|
|
|
|
if (synctest_pos < 10200)
|
|
{
|
|
synctest_pos++;
|
|
synctest_p++;
|
|
|
|
}
|
|
else
|
|
{
|
|
// buffer reset
|
|
synctest_pos = 0;
|
|
synctest_p = synctest_buf;
|
|
noCarrier (opts, state);
|
|
|
|
}
|
|
|
|
if (state->lastsynctype != 1)
|
|
{
|
|
|
|
if (synctest_pos >= 1800)
|
|
{
|
|
if ((opts->errorbars == 1) && (opts->verbose > 1) && (state->carrier == 1))
|
|
{
|
|
fprintf (stderr,"Sync: no sync\n");
|
|
fprintf (stderr,"Press CTRL + C to close.\n");
|
|
|
|
}
|
|
noCarrier (opts, state);
|
|
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|