djiparsetxt.cpp

Go to the documentation of this file.

/**********
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
**********/
/*
    A C++ program to parse DJI's ".txt" log files (recorded by the "DJI Go 4" app).
    Version 2021-05-20

    Copyright (c) 2021 Live Networks, Inc.  All rights reserved.
    For the latest version of this program (and more information), visit http://djilogs.live555.com
*/

#include "DJITxtParser.hh"

#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <errno.h>

#define OLD_HEADER_SIZE 12
#define NEW_HEADER_SIZE 100
#define MIN_RECORD_SIZE 3 // type+0-length+FF

u_int8_t fileVersionNumber;

int main(int argc, char** argv) {
  fprintf(stderr, "\"%s\", version 2021-05-20. Copyright (c) 2021 Live Networks, Inc. All rights reserved.\n", argv[0]);
  fprintf(stderr, "For the latest version of this program (and more information), visit http://djilogs.live555.com\n");

  int fileNamePos = 1;
  if (argc != 2) {
    fprintf(stderr, "Usage: %s <txtFileName>\n", argv[0]);
    return 1;
  }
  char const* fileName = argv[fileNamePos];

  FILE* fid = fopen(fileName, "rb");
  if (fid == NULL) {
    fprintf(stderr, "Failed to open \"%s\"\n", fileName);
    return 1;
  }

  // Figure out the file's size
  struct stat sb;
  u_int64_t fileSize;
  if (stat(fileName, &sb) == 0) {
    fileSize = sb.st_size;
  } else {
    fprintf(stderr, "Failed to get file size\n");
    return 1;
  }

  // Check the file size:
  if (fileSize < OLD_HEADER_SIZE) {
    fprintf(stderr, "Bad file size: %llu bytes\n", fileSize);
    return 1;
  }

  // Map the file into memory:
  u_int8_t* const mappedFile
    = (u_int8_t*)mmap(0, fileSize, PROT_READ, MAP_SHARED, fileno(fid), 0);
  if (mappedFile == MAP_FAILED) {
    extern int errno;
    fprintf(stderr, "mmap() call failed: %s\n", strerror(errno));
    return 1;
  }

  // Figure out the start and end position of the header/records/details areas:
  u_int64_t recordsAreaStart, recordsAreaEnd;
  u_int64_t detailsAreaStart, detailsAreaEnd;

  // The first 8 bytes (little-endian) of the file points to the end of records area:
  u_int8_t const* ptr = mappedFile;
  recordsAreaEnd = getWord64LE(ptr);

  // The next 2 bytes (little-endian) is the size of the details area:
  u_int16_t const detailsAreaSize = get2BytesLE(ptr);
  
  // The next byte is the version number of the file:
  fileVersionNumber = *ptr++;
  fprintf(stderr, "File version number: 0x%02x\n", fileVersionNumber);

  // The next byte is unknown; skip over it:
  ++ptr;

  // Old versions of the file have a smaller header, and are not scrambled:
  unsigned headerSize;
  int isScrambled;
  if (fileVersionNumber < 0x06) {
    headerSize = OLD_HEADER_SIZE;
    isScrambled = 0;
  } else {
    headerSize = NEW_HEADER_SIZE;
    isScrambled = 1;
  }

  // Newer versions of the file have a different order:
  u_int64_t computedFileSize;
  if (fileVersionNumber >= 0x0C) {
    // Order is "header";"details area";"records area"
    recordsAreaStart = headerSize + detailsAreaSize;
    detailsAreaStart = headerSize;
    detailsAreaEnd = detailsAreaStart + detailsAreaSize;

    computedFileSize = recordsAreaEnd;
  } else {
    // Order is "header";"records area";"details area"
    recordsAreaStart = headerSize;
    detailsAreaStart = recordsAreaEnd;
    detailsAreaEnd = detailsAreaStart + detailsAreaSize;

    computedFileSize = detailsAreaEnd;
  }

  // Check the sanity of these values:
  u_int64_t const minFileSize = headerSize + MIN_RECORD_SIZE;
  if (computedFileSize < minFileSize || computedFileSize > fileSize) {
    fprintf(stderr, "Bad 'recordsAreaEnd' %llu (0x%llx) and/or 'detailsAreaSize' %u (0x%x); file size is %llu\n",
            recordsAreaEnd, recordsAreaEnd,
            detailsAreaSize, detailsAreaSize,
            fileSize);
    return 1;
  }

  // Create a parser:
  DJITxtParser* parser = DJITxtParser::createNew();

  // Begin by parsing the 'DETAILS' area:
  ptr = &mappedFile[detailsAreaStart];
  parser->parseDetailsArea(ptr, &mappedFile[detailsAreaEnd]);

  // Then, parse all of the records in the file:
  ptr = &mappedFile[recordsAreaStart];
  u_int8_t* const recordsAreaEndPtr = &mappedFile[recordsAreaEnd];

  while (ptr < recordsAreaEndPtr) {
#ifdef DEBUG_RECORD_PARSING
    u_int64_t curFilePosition = ptr - mappedFile;
    fprintf(stderr, "@0x%08llx: ", curFilePosition);
#endif
    if (!parser->parseRecord(ptr, recordsAreaEndPtr, isScrambled)) break;
  }
  if (ptr < recordsAreaEndPtr) {
    u_int64_t curFilePosition = ptr - mappedFile;
    fprintf(stderr, "Premature end of record parsing at file position %llu (0x%08llx)\n", curFilePosition, curFilePosition);
  }
  parser->outputOneRow(); // the final row of data
  parser->summarizeRecordParsing();

  delete parser;

  fprintf(stderr, "Done writing CSV.\n");
  return 0;
}