playFile Example

The playFile program creates a logger, opens a logger tape, and plays it back.

Periodic messages output the current tape time. If 'q' is pressed playback stops and the program exits\ immediately, otherwise it will continue to the end of the tape at which point it will exit.

---

The main application:

/*******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*******************************************************************************/

#include <lgrUtil/absoluteTime.h>
#include <lgrCore/lgrPlaybackInterface.h>
#include <lgrUtil/lgrPrint.h>
#include <lgrCore/lgrSimInterface.h>
#include <lgrCore/loggerPlaybackFile.h>

#include <vlutil/vlProcessControl.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlMiniDumper.h>
#include <cmdLine/cmdLine.h>
#include <lgrUtil/lgrVersion.h>

#if DtDIS
#include <vl/exerciseConnInitializerDIS.h>
#include <lgrSim/disLogger.h>
#include <lgrSim/lgrDisFileFormats.h>
#endif

#if DtHLA
#include <vl/exerciseConnInitializerHLA.h>
#include <lgrSim/hlaLogger.h>
#include <lgrSim/lgrHlaFileFormats.h>
#include <lgrSim/lgrHlaConfigData.h>
#include <vl/emptyFomMapper.h>
#endif

using namespace MAKLogger;

// Hard coded paths for files. Relative to the bin directories.
#if DtDIS
const char defaultFileName[] = "..\\logger_tapes\\bombMission2021-DIS.lgr";
#elif DtHLA_1516_EVOLVED
const char defaultFileName[] = "..\\logger_tapes\\bombMission2021-HLAe-RPR20.lgr";
#elif DtHLA_1516
const char defaultFileName[] = "..\\logger_tapes\\bombMission2021-HLA516-RPR20.lgr";
#else
const char defaultFileName[] = "..\\logger_tapes\\bombMission2021-HLA13-RPR20.lgr";
#endif

bool fileTypeMatches(DtString& filename);
void setConfigParameters(DtExerciseConnInitializer& exConnInit, const DtFilename& filename);
bool keyCheck(const char* keysToCheck);

int playFile(int argc, char** argv)
{
   DtCmdLine::CmdLine cmdLine("playFile","Example of how to play a logger file.",LOGGER_VERSION_STRING);
   DtCmdLine::UnlabeledMultiArg<DtString> filenameArg("Filename","The name of the logger file to play.","string");
   DtCmdLine::ValueArg<double> playbackSpeed("s","speed", "The playback speed.",false, 1.0,"double");
   cmdLine.add(&filenameArg);
   cmdLine.add(playbackSpeed);
   cmdLine.parse(argc,argv);

   std::vector<DtString> values = filenameArg.getValue();
   if(values.size() == 0)
   {
      values.push_back(defaultFileName);
   }
   DtFilename filename(values.front());

   try
   {

   // Initialize logger with settings retrieved from file.
   DtExerciseConnInitializer exConnInit;

   // Create the logger based upon it's protocol. These helper sub classes
   // automatically register the protocol and provide additional utility
   // functions.
#if DtDIS
   // Create a DIS logger
   DtDisLogger* aLogger = DtDisLogger::create(true);
#else
   // Create a HLA logger
   DtHlaLogger* aLogger = DtHlaLogger::create(true);
#endif

   if (!fileTypeMatches(filename))
   {
      DtInfo << "Unable to process file (" <<
         filename.c_str() << "): file format designator does not match, unknown or corrupted." << std::endl;
      return 1;
   }

#if DtHLA
   // Extract the configuration data from the file
   setConfigParameters(exConnInit, filename);
#endif

   aLogger->connect(exConnInit);

   DtLgrSimInterface* simInterface = DtLgrSimInterface::create(*aLogger);
   aLogger->tick();
   simInterface->update();
   if(!simInterface->isConnected())
   {
      DtInfo << "Unable to connect." << std::endl;
      return 1;
   }
   delete simInterface;

   // Create Playback interface for controlling playback.
   DtLgrPlaybackInterface* pbInterface = DtLgrPlaybackInterface::create(*aLogger);
   if(!pbInterface)
   {
      DtInfo << "Error: Unable to create playback interface." << std::endl;
      return 1;
   }

   // Tell the logger to open a file.
   pbInterface->openFile(filename, true);
   // Process Commands
   aLogger->tick();
   // Update interface
   pbInterface->update();

   // Check to see if file was loaded.
   if(!pbInterface->isFileLoaded())
   {
      DtInfo << "Unable to open file: " << filename << "." << std::endl;
      return 1;
   }

   if (playbackSpeed.isSet())
   {
      DtInfo << "Setting playback speed to " << playbackSpeed.getValue() << std::endl;
      pbInterface->setPlaybackSpeed(playbackSpeed.getValue(), false);
   }

   DtInfo << "Playing file: " << filename << "." << std::endl;
   DtInfo << "Press 'q' or 'enter' to quit." << std::endl;

   // Tell the logger to play.
   pbInterface->play();
   // Process Commands
   aLogger->tick();
   // Update interface
   pbInterface->update();

   // Check to see if playback was started.
   if(!pbInterface->isPlaying())
   {
      DtInfo << "Unable to play file." << std::endl;
      return 1;
   }

   // The number of seconds between print outs.
   double printDelay = 1.0;
   double printLoopTotal = 0;

   // The time of a loop.
   double loopDelay = .1;

   // Execution loop.
   while(pbInterface->isPlaying())
   {
      // Tick logger
      aLogger->tick();
      // Update Interface
      pbInterface->update();

      if(printLoopTotal >= printDelay)
      {
         DtInfo << "Current Time = " << pbInterface->currentTime() << "." << std::endl;
         printLoopTotal = 0.0;
      }
      printLoopTotal += loopDelay;
      DtSleep(loopDelay);
      // Break out if q or enter was pressed.
      if(keyCheck("q\r")) break;
   }

   // Check to see if the logger is still playing.
   if(pbInterface->isPlaying())
   {
      DtInfo << "Stopping playback." << std::endl;
      pbInterface->stop();
      // Make the logger stop.
      aLogger->tick();
   }

   DtInfo << "Finished playing file." << std::endl;
   DtRestoreKbHit();

   delete pbInterface;
   delete aLogger;

   }
   catch (DtException& ex)
   {
      DtString output = DtSerializeException(ex);
      DtInfo << output << std::endl;
      return 0;
   }

   return 0;
}

int main(int argc, char** argv)
{
   DtINIT_MINIDUMPER( "PlayFile" );
   return playFile(argc,argv);
}

bool keyCheck(const char* keysToCheck)
{
   if(DtKbHit())
   {
      char c = DtGetCh();
      return strchr(keysToCheck,c) != 0;
   }
   return false;
}

// Check that the file type matches one of the tape formats
bool fileTypeMatches(DtString& filename)
{
   unsigned int magic = 0;
   std::ifstream fs;
   fs.open(filename.c_str(),std::ios::binary );

   if(!fs.is_open() || !fs.good())
   {
      DtInfo << "Unable to open file: " << filename << "." << std::endl;
      exit(1);
   }

   fs.read((char*)&magic,4);

   magic = (magic >> 24) | ((magic >> 8) & 0xFF00) |
      ((magic << 8) & 0xFF0000) | (magic << 24);

   // File formats must be registered for this check to work
#if DtDIS
   return DtString("Unknown") != DtLgrDisFileFormats::versionString(magic);
#else
   return DtString("Unknown") != DtLgrHlaFileFormats::versionString(magic);
#endif
}

#if DtHLA
// Add the specific parameters for the tape.
void setConfigParameters(DtExerciseConnInitializer& exConnInit, const DtFilename& filename)
{
   // Open the file and grab the config meta data
   DtLoggerPlaybackFile* file = 0;
   try
   {
      file = new DtLoggerPlaybackFile(DtString(filename.c_str()), false, true);
   }
   catch(DtException& ex)
   {
      DtString output = DtSerializeException(ex);
      DtInfo << output << std::endl;
   }

   const DtPacket* configPacket =
      file->formatter()->metaData()->getMetaData(DtLoggerFileMetaData::StartOfFile,
      DtPacket::Type_ConfigData);

   DtLgrHlaConfigData configData;
   if(configPacket)
   {
      configData.deserialize(configPacket->data());
   }

   // Use the config meta data to set the exercise connection initializer
   // that select things like the FOM version, FOM file name, etc.
   if (!configData.fomVersion().isEmpty())
      exConnInit.setRprFomVersion(configData.fomVersion().toDouble());

   if (!configData.fomMapperName().isEmpty())
   {
      exConnInit.setFomMapperLibName(configData.fomMapperName());
      if (!configData.fomMapperInitData().isEmpty())
      {
         exConnInit.setFomMapperInitData((void*)configData.fomMapperInitData().c_str());
      }
   }

   if (!configData.emptyFomMapper().isEmpty() && configData.emptyFomMapper() != "0")
   {
      exConnInit.setFomMapper(new DtEmptyFomMapper());
   }

   exConnInit.setExecName(configData.federationName());

   DtFilename fedFile(configData.fedFile());
   fedFile.stripPath();
   exConnInit.setFedFileName(fedFile);

#if DtHLA_1516_EVOLVED
   std::vector<DtString> fomModNames;
   configData.getFomModules(fomModNames);
   int numberModules = fomModNames.size();
   if (numberModules > 0)
   {
      for (int fmIndex=0; fmIndex < numberModules; ++fmIndex)
      {
         DtFilename fmFilename(fomModNames[fmIndex]);
         fmFilename.stripPath();
         fomModNames[fmIndex] = fmFilename;
      }
      exConnInit.setFomModules(fomModNames);
   }

   if (!configData.mim().isEmpty())
   {
      DtFilename mim(configData.mim());
      mim.stripPath();
      exConnInit.setMimModule(mim);
   }
#endif

   delete file;
}
#endif