djiparsetxt.cpp File Reference

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

Include dependency graph for djiparsetxt.cpp:

Go to the source code of this file.

Macros
#define	OLD_HEADER_SIZE   12
#define	NEW_HEADER_SIZE   100
#define	MIN_RECORD_SIZE   3

Functions
int	main (int argc, char **argv)

Variables
u_int8_t	fileVersionNumber

Macro Definition Documentation

MIN_RECORD_SIZE

#define MIN_RECORD_SIZE   3

Definition at line 33 of file djiparsetxt.cpp.

NEW_HEADER_SIZE

#define NEW_HEADER_SIZE   100

Definition at line 32 of file djiparsetxt.cpp.

OLD_HEADER_SIZE

#define OLD_HEADER_SIZE   12

Definition at line 31 of file djiparsetxt.cpp.

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 37 of file djiparsetxt.cpp.

                                {
  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;
}

References DJITxtParser::createNew(), fileVersionNumber, get2BytesLE(), getWord64LE(), MIN_RECORD_SIZE, NEW_HEADER_SIZE, OLD_HEADER_SIZE, DJITxtParser::outputOneRow(), DJITxtParser::parseDetailsArea(), DJITxtParser::parseRecord(), and DJITxtParser::summarizeRecordParsing().

Variable Documentation

fileVersionNumber

u_int8_t fileVersionNumber

Definition at line 35 of file djiparsetxt.cpp.

Referenced by main(), and RecordAndDetailsParser::parseDetailsArea().