diff --git a/dump1090.c b/dump1090.c index 343f8a3..d2c79bb 100644 --- a/dump1090.c +++ b/dump1090.c @@ -56,7 +56,7 @@ // MinorVer changes when additional features are added, but not for bug fixes (range 00-99) // DayDate & Year changes for all changes, including for bug fixes. It represent the release date of the update // -#define MODES_DUMP1090_VERSION "1.05.1205.13" +#define MODES_DUMP1090_VERSION "1.05.1305.13" #define MODES_USER_LATITUDE_DFLT (0.0) #define MODES_USER_LONGITUDE_DFLT (0.0) @@ -286,7 +286,7 @@ struct modesMessage { int msgtype; // Downlink format # int crcok; // True if CRC was valid uint32_t crc; // Message CRC - int errorbit; // Bit corrected. -1 if no bit corrected + int correctedbits; // No. of bits corrected uint32_t addr; // ICAO Address from bytes 1 2 and 3 int phase_corrected; // True if phase correction was applied uint64_t timestampMsg; // Timestamp of the message @@ -327,8 +327,10 @@ void modesSendRawOutput(struct modesMessage *mm); void modesSendBeastOutput(struct modesMessage *mm); void modesSendSBSOutput(struct modesMessage *mm); void useModesMessage(struct modesMessage *mm); +int fixBitErrors(unsigned char *msg, int bits); int fixSingleBitErrors(unsigned char *msg, int bits); int fixTwoBitsErrors(unsigned char *msg, int bits); +void modesInitErrorInfo(); int modesMessageLenByType(int type); /* ============================= Utility functions ========================== */ @@ -461,6 +463,9 @@ void modesInit(void) { Modes.maglut[(i*256)+q] = (uint16_t) ((mag < 65535) ? mag : 65535); } } + + /* Prepare error correction tables */ + modesInitErrorInfo(); } /* =============================== RTLSDR handling ========================== */ @@ -653,12 +658,7 @@ void dumpRawMessageJS(char *descr, unsigned char *msg, int start = offset - padding; int end = offset + (MODES_PREAMBLE_SAMPLES)+(MODES_LONG_MSG_SAMPLES) - 1; FILE *fp; - int j, fix1 = -1, fix2 = -1; - - if (fixable != -1) { - fix1 = fixable & 0xff; - if (fixable > 255) fix2 = fixable >> 8; - } + int j; if ((fp = fopen("frames.js","a")) == NULL) { fprintf(stderr, "Error opening frames.js: %s\n", strerror(errno)); @@ -670,8 +670,8 @@ void dumpRawMessageJS(char *descr, unsigned char *msg, fprintf(fp,"%d", j < 0 ? 0 : m[j]); if (j != end) fprintf(fp,","); } - fprintf(fp,"], \"fix1\": %d, \"fix2\": %d, \"bits\": %d, \"hex\": \"", - fix1, fix2, modesMessageLenByType(msg[0]>>3)); + fprintf(fp,"], \"fixed\": %d, \"bits\": %d, \"hex\": \"", + fixable, modesMessageLenByType(msg[0]>>3)); for (j = 0; j < MODES_LONG_MSG_BYTES; j++) fprintf(fp,"\\x%02x",msg[j]); fprintf(fp,"\"});\n"); @@ -695,12 +695,10 @@ void dumpRawMessage(char *descr, unsigned char *msg, { int j; int msgtype = msg[0] >> 3; - int fixable = -1; + int fixable = 0; if (msgtype == 17) { - fixable = fixSingleBitErrors(msg, MODES_LONG_MSG_BITS); - if (fixable == -1) - fixable = fixTwoBitsErrors(msg, MODES_LONG_MSG_BITS); + fixable = fixBitErrors(msg, MODES_LONG_MSG_BITS); } if (Modes.debug & MODES_DEBUG_JS) { @@ -1063,7 +1061,7 @@ void decodeModeAMessage(struct modesMessage *mm, int ModeA) // Not much else we can tell from a Mode A/C reply. // Just fudge up a few bits to keep other code happy mm->crcok = 1; - mm->errorbit = -1; + mm->correctedbits = 0; } /* ===================== Mode S detection and decoding ===================== */ @@ -1207,6 +1205,307 @@ int fixTwoBitsErrors(unsigned char *msg, int bits) { return (-1); } +/* Code for introducing a less CPU-intensive method of correcting + * single bit errors. + * + * Makes use of the fact that the crc checksum is linear with respect to + * the bitwise xor operation, i.e. + * crc(m^e) = (crc(m)^crc(e) + * where m and e are the message resp. error bit vectors. + * + * Call crc(e) the syndrome. + * + * The code below works by precomputing a table of (crc(e), e) for all + * possible error vectors e (here only single bit and double bit errors), + * search for the syndrome in the table, and correct the then known error. + * The error vector e is represented by one or two bit positions that are + * changed. If a second bit position is not used, it is -1. + * + * Run-time is binary search in a sorted table, plus some constant overhead, + * instead of running through all possible bit positions (resp. pairs of + * bit positions). + * + * + * + */ +struct errorinfo { + uint32_t syndrome; /* CRC syndrome */ + int pos0; /* bit position of first error */ + int pos1; /* bit position of second error, or -1 */ +}; + +#define NERRORINFO \ + (MODES_LONG_MSG_BITS+MODES_LONG_MSG_BITS*(MODES_LONG_MSG_BITS-1)/2) +struct errorinfo bitErrorTable[NERRORINFO]; + +/* Compare function as needed for stdlib's qsort and bsearch functions */ +int cmpErrorInfo(const void *p0, const void *p1) { + struct errorinfo *e0 = (struct errorinfo*)p0; + struct errorinfo *e1 = (struct errorinfo*)p1; + if (e0->syndrome == e1->syndrome) { + return 0; + } else if (e0->syndrome < e1->syndrome) { + return -1; + } else { + return 1; + } +} + +/* Compute the table of all syndromes for 1-bit and 2-bit error vectors */ +void modesInitErrorInfo() { + unsigned char msg[MODES_LONG_MSG_BYTES]; + int i, j, n; + uint32_t crc; + n = 0; + memset(bitErrorTable, 0, sizeof(bitErrorTable)); + /* First, insert infos about all possible single bit errors */ + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + int bytepos = (i >> 3); + int mask = 1 << (7 - (i & 7)); + memset(msg, 0, MODES_LONG_MSG_BYTES); + msg[bytepos] ^= mask; + crc = modesChecksum(msg, MODES_LONG_MSG_BITS); + bitErrorTable[n].syndrome = crc; + bitErrorTable[n].pos0 = i; + bitErrorTable[n].pos1 = -1; + n += 1; + } + /* Add also all double bit errors */ + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + int bytepos0 = (i >> 3); + int mask0 = 1 << (7 - (i & 7)); + memset(msg, 0, MODES_LONG_MSG_BYTES); + msg[bytepos0] ^= mask0; + for (j = i+1; j < MODES_LONG_MSG_BITS; j++) { + int bytepos1 = (j >> 3); + int mask1 = 1 << (7 - (j & 7)); + msg[bytepos1] ^= mask1; + crc = modesChecksum(msg, MODES_LONG_MSG_BITS); + if (n >= NERRORINFO) { + /* + fprintf(stderr, + "Internal error, too many " + "entries, fix NERRORINFO\n"); + */ + break; + } + bitErrorTable[n].syndrome = crc; + bitErrorTable[n].pos0 = i; + bitErrorTable[n].pos1 = j; + n += 1; + } + } + qsort(bitErrorTable, NERRORINFO, + sizeof(struct errorinfo), cmpErrorInfo); + /* Test code: report if any syndrome appears at least twice. In this + * case the correction cannot be done without ambiguity. + * Tried it, does not happen for 1- and 2-bit errors. + */ + /* + for (i = 1; i < NERRORINFO; i++) { + if (bitErrorTable[i-1].syndrome + == bitErrorTable[i].syndrome) { + fprintf(stderr, "modesInitErrorInfo: " + "Collision for syndrome %06x\n", + (int)bitErrorTable[i].syndrome); + } + } + */ + /* + for (i = 0; i < NERRORINFO; i++) { + printf("syndrome %06x bit0 %3d bit1 %3d\n", + bitErrorTable[i].syndrome, + bitErrorTable[i].pos0, bitErrorTable[i].pos1); + } + */ +} + +/* Flip a bit, but make sure that the DF field (first 5 bits) + * is never changed + */ +int flipBit(unsigned char *msg, int nbits, int bit) { + int bytepos, mask; + if ((bit < 0) || (bit >= nbits)) { + return 0; + } + if (bit < 5) { + return 0; + } + bytepos = (bit >> 3); + mask = 1 << (7 - (bit & 7)); + msg[bytepos] ^= mask; + return 1; +} + +/* Search syndrome in table and, if an entry is found, flip the necessary + * bits. Make sure the indices fit into the array, and for 2-bit errors, + * are different. + * Return number of fixed bits. + */ +int fixBitErrors(unsigned char *msg, int bits) { + struct errorinfo *pei; + struct errorinfo ei; + int bitpos0, bitpos1, offset, res; + ei.syndrome = modesChecksum(msg, bits); + ei.pos0 = -1; + ei.pos1 = -1; + pei = bsearch(&ei, bitErrorTable, NERRORINFO, + sizeof(struct errorinfo), cmpErrorInfo); + if (pei == NULL) { + /* Nothing found */ + return 0; + } + offset = MODES_LONG_MSG_BITS-bits; + bitpos0 = pei->pos0; + bitpos1 = pei->pos1; + res = 0; + if (bitpos1 >= 0) { /* two-bit error pattern */ + bitpos0 -= offset; + bitpos1 -= offset; + if ((bitpos0 < 0) || (bitpos0 >= bits) || + (bitpos1 < 0) || (bitpos1 >= bits)) { + return res; + } + res +=flipBit(msg, bits, bitpos0); + if (bitpos0 != bitpos1) { + res += flipBit(msg, bits, bitpos1); + return res; + } + return res; + } else { + bitpos0 -= offset; + if ((bitpos0 < 0) || (bitpos0 >= bits)) { + return res; + } + res += flipBit(msg, bits, bitpos0); + return res; + } +} + +/* Code for testing the timing: run all possible 1- and 2-bit error + * the test message by all 1-bit errors. Run the old code against + * all of them, and new the code. + * + * Example measurements: + * Timing old vs. new crc correction code: + * Old code: 1-bit errors on 112 msgs: 3934 usecs + * New code: 1-bit errors on 112 msgs: 104 usecs + * Old code: 2-bit errors on 6216 msgs: 407743 usecs + * New code: 2-bit errors on 6216 msgs: 5176 usecs + * indicating a 37-fold resp. 78-fold improvement in speed for 1-bit resp. + * 2-bit error. + */ +unsigned char tmsg0[MODES_LONG_MSG_BYTES] = { + /* Test data: first ADS-B message from testfiles/modes1.bin */ + 0x8f, 0x4d, 0x20, 0x23, 0x58, 0x7f, 0x34, 0x5e, + 0x35, 0x83, 0x7e, 0x22, 0x18, 0xb2 +}; +#define NTWOBITS (MODES_LONG_MSG_BITS*(MODES_LONG_MSG_BITS-1)/2) +unsigned char tmsg1[MODES_LONG_MSG_BITS][MODES_LONG_MSG_BYTES]; +unsigned char tmsg2[NTWOBITS][MODES_LONG_MSG_BYTES]; +/* Init an array of cloned messages with all possible 1-bit errors present, + * applied to each message at the respective position + */ +void inittmsg1() { + int i, bytepos, mask; + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + bytepos = i >> 3; + mask = 1 << (7 - (i & 7)); + memcpy(&tmsg1[i][0], tmsg0, MODES_LONG_MSG_BYTES); + tmsg1[i][bytepos] ^= mask; + } +} + +/* Run sanity check on all but first 5 messages / bits, as those bits + * are not corrected. + */ +void checktmsg1(FILE *out) { + int i, k; + uint32_t crc; + for (i = 5; i < MODES_LONG_MSG_BITS; i++) { + crc = modesChecksum(&tmsg1[i][0], MODES_LONG_MSG_BITS); + if (crc != 0) { + fprintf(out, "CRC not fixed for " + "positon %d\n", i); + fprintf(out, " MSG "); + for (k = 0; k < MODES_LONG_MSG_BYTES; k++) { + fprintf(out, "%02x", tmsg1[i][k]); + } + fprintf(out, "\n"); + } + } +} + +void inittmsg2() { + int i, j, n, bytepos0, bytepos1, mask0, mask1; + n = 0; + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + bytepos0 = i >> 3; + mask0 = 1 << (7 - (i & 7)); + for (j = i+1; j < MODES_LONG_MSG_BITS; j++) { + bytepos1 = j >> 3; + mask1 = 1 << (7 - (j & 7)); + memcpy(&tmsg2[n][0], tmsg0, MODES_LONG_MSG_BYTES); + tmsg2[n][bytepos0] ^= mask0; + tmsg2[n][bytepos1] ^= mask1; + n += 1; + } + } +} + +long difftvusec(struct timeval *t0, struct timeval *t1) { + long res = 0; + res = t1->tv_usec-t0->tv_usec; + res += (t1->tv_sec-t0->tv_sec)*1000000L; + return res; +} + +/* the actual test code */ +void testAndTimeBitCorrection() { + struct timeval starttv, endtv; + int i; + /* Run timing on 1-bit errors */ + printf("Timing old vs. new crc correction code:\n"); + inittmsg1(); + gettimeofday(&starttv, NULL); + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + fixSingleBitErrors(&tmsg1[i][0], MODES_LONG_MSG_BITS); + } + gettimeofday(&endtv, NULL); + printf(" Old code: 1-bit errors on %d msgs: %ld usecs\n", + MODES_LONG_MSG_BITS, difftvusec(&starttv, &endtv)); + checktmsg1(stdout); + /* Re-init */ + inittmsg1(); + gettimeofday(&starttv, NULL); + for (i = 0; i < MODES_LONG_MSG_BITS; i++) { + fixBitErrors(&tmsg1[i][0], MODES_LONG_MSG_BITS); + } + gettimeofday(&endtv, NULL); + printf(" New code: 1-bit errors on %d msgs: %ld usecs\n", + MODES_LONG_MSG_BITS, difftvusec(&starttv, &endtv)); + checktmsg1(stdout); + /* Run timing on 2-bit errors */ + inittmsg2(); + gettimeofday(&starttv, NULL); + for (i = 0; i < NTWOBITS; i++) { + fixSingleBitErrors(&tmsg2[i][0], MODES_LONG_MSG_BITS); + } + gettimeofday(&endtv, NULL); + printf(" Old code: 2-bit errors on %d msgs: %ld usecs\n", + NTWOBITS, difftvusec(&starttv, &endtv)); + /* Re-init */ + inittmsg2(); + gettimeofday(&starttv, NULL); + for (i = 0; i < NTWOBITS; i++) { + fixBitErrors(&tmsg2[i][0], MODES_LONG_MSG_BITS); + } + gettimeofday(&endtv, NULL); + printf(" New code: 2-bit errors on %d msgs: %ld usecs\n", + NTWOBITS, difftvusec(&starttv, &endtv)); +} + + /* Hash the ICAO address to index our cache of MODES_ICAO_CACHE_LEN * elements, that is assumed to be a power of two. */ uint32_t ICAOCacheHashAddress(uint32_t a) { @@ -1407,7 +1706,7 @@ void decodeModesMessage(struct modesMessage *mm, unsigned char *msg) { // Get the message type ASAP as other operations depend on this mm->msgtype = msg[0] >> 3; // Downlink Format mm->msgbits = modesMessageLenByType(mm->msgtype); - mm->errorbit = -1; // No errors fixed + mm->correctedbits = 0; // No errors fixed mm->phase_corrected = 0; mm->crc = modesChecksum(msg, mm->msgbits); @@ -1423,10 +1722,10 @@ void decodeModesMessage(struct modesMessage *mm, unsigned char *msg) { // using the results. Perhaps check the ICAO against known aircraft, and check // IID against known good IID's. That's a TODO. // - mm->errorbit = fixSingleBitErrors(msg, mm->msgbits); - if ((mm->errorbit == -1) && (Modes.aggressive)) { - mm->errorbit = fixTwoBitsErrors(msg, mm->msgbits); - } + mm->correctedbits = fixBitErrors(msg, mm->msgbits); + //if ((mm->errorbit == -1) && (Modes.aggressive)) { + // mm->errorbit = fixTwoBitsErrors(msg, mm->msgbits); + //} } // // Note that most of the other computation happens *after* we fix the @@ -1446,7 +1745,7 @@ void decodeModesMessage(struct modesMessage *mm, unsigned char *msg) { mm->crcok = (mm->crc == 0); mm->addr = (msg[1] << 16) | (msg[2] << 8) | (msg[3]); - if (-1 != mm->errorbit) { + if (0 != mm->correctedbits) { // DF 17 : if (error corrected) force crc = 0 but do not try to add this address // to the whitelist of recently seen ICAO addresses. mm->crc = 0; @@ -1692,8 +1991,8 @@ void displayModesMessage(struct modesMessage *mm) { if (mm->msgtype < 32) printf("CRC: %06x (%s)\n", (int)mm->crc, mm->crcok ? "ok" : "wrong"); - if (mm->errorbit != -1) - printf("Single bit error fixed, bit %d\n", mm->errorbit); + if (mm->correctedbits != 0) + printf("No. of bit errors fixed: %d\n", mm->correctedbits); if (mm->msgtype == 0) { // DF 0 printf("DF 0: Short Air-Air Surveillance.\n"); @@ -2165,16 +2464,17 @@ void detectModeS(uint16_t *m, uint32_t mlen) { if (Modes.stats) { if (mm.crcok || use_correction) { if (errors == 0) Modes.stat_demodulated++; - if (mm.errorbit == -1) { + if (mm.correctedbits == 0) { if (mm.crcok) {Modes.stat_goodcrc++;} else {Modes.stat_badcrc++;} } else { Modes.stat_badcrc++; Modes.stat_fixed++; - if (mm.errorbit < MODES_LONG_MSG_BITS) - {Modes.stat_single_bit_fix++;} - else - {Modes.stat_two_bits_fix++;} + if (mm.correctedbits == 1) { + Modes.stat_single_bit_fix++; + } else if (mm.correctedbits == 2) { + Modes.stat_two_bits_fix++; + } } } } @@ -2185,10 +2485,10 @@ void detectModeS(uint16_t *m, uint32_t mlen) { dumpRawMessage("Demodulated with 0 errors", msg, m, j); else if (Modes.debug & MODES_DEBUG_BADCRC && mm.msgtype == 17 && - (!mm.crcok || mm.errorbit != -1)) + (!mm.crcok || mm.correctedbits != 0)) dumpRawMessage("Decoded with bad CRC", msg, m, j); else if (Modes.debug & MODES_DEBUG_GOODCRC && mm.crcok && - mm.errorbit == -1) + mm.correctedbits == 0) dumpRawMessage("Decoded with good CRC", msg, m, j); } @@ -3769,6 +4069,9 @@ int main(int argc, char **argv) { // Initialization modesInit(); + if (Modes.debug & MODES_DEBUG_BADCRC) { + testAndTimeBitCorrection(); + } if (Modes.net_only) { fprintf(stderr,"Net-only mode, no RTL device or file open.\n"); } else if (Modes.filename == NULL) {