lgrRecordDriver.h

Go to the documentation of this file.

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


#ifndef lgrRecordDriver_H_
#define lgrRecordDriver_H_

#include <lgrCore/lgrDriver.h>
#include <lgrUtil/absoluteTime.h>
#include <lgrCore/messageBuffer.h>
#include <vlutil/vlRunnable.h>

class DtThread;

namespace MAKLogger
{
   class DtCheckpointPolicy;
   class DtLgrClock;
   class DtLgrContinuousClock;
   class DtLgrFileInput;
   class DtLgrFileOutput;
   class DtLgrPlaybackDriver;
   class DtLgrRecordCommandFactory;
   class DtLgrRecordInterface;
   class DtMessagePipeline;
   class DtThreadedObject;
   class DtLgrRecordMediaStream;

   class DT_DLL_LGRCORE DtLgrRecordDriver : public DtLgrCommandHandler
   {
   public:
      typedef DtLgrRecordCommandFactory Factory;
      typedef DtLgrRecordInterface Interface;

      DT_VIRTUAL_CTR(DtLgrRecordDriver,(DtLgrSystemDriver&))

      virtual ~DtLgrRecordDriver();

      virtual void tick();

      virtual bool releasePipeline();
      virtual bool getPipeline();
      virtual bool hasPipeline() const;

      virtual bool isFileOpen() const;
      virtual bool isFileEmpty() const;

      virtual bool isRecording() const;
      virtual bool isPaused() const;

      virtual bool pauseOnRecordAs() const;

      virtual int checkpointPolicyId() const;

      virtual int checkpointCount() const;

      virtual int checkpointSize() const;

      virtual DtAbsoluteTime checkpointTime() const;

      bool interactionsCheckpointed() const;

      virtual const DtString& filename() const;

      virtual DtCheckpointPolicy* duplicateCheckpointPolicy() const;

      virtual bool recordToMultipleFiles() const;

      virtual double multipleFileDuration() const;

      virtual const DtString& multipleFileNamingConvention() const;

      virtual const DtLgrFileOutput* currentOutput() const;

      virtual void addTemporaryTrackedEntity(const DtString& name);

      virtual const DtString& streamPipeline() const;

      virtual const DtString& streamConfiguration() const;

      const DtString& selectedMediaStreamConfigurations() const;

      bool isRecordingMediaStream() const;

      bool mediaRecordByDefault() const;

      int mediaRecordPort() const;

      virtual void stopAllThreads();

      virtual void stopThread( DtLgrCommandThread* commandThread );

   protected:

      virtual DtLgrPlaybackDriver* getPlaybackDriver(bool checkForFileOpen) const;

      virtual void setCheckpointPolicy(DtCheckpointPolicy* policy);

      virtual void tickNormalRecording();

      virtual void tickRecordToMultipleFiles(double multipleFileDuration, bool final = false);

      virtual void configurePipeline();

      virtual void activateIdleListening();

      virtual bool doNewFile(DtString filename, DtString description, bool overwrite);
      virtual bool doRecord(bool multipleFiles);
      virtual bool doStop();
      virtual bool doPause();
      virtual bool doUnpause();

      virtual DtString multipleFileName() const;

      virtual DtString multiFileDescription(bool final);

      virtual void initializeMediaPipeline(const DtString& filename);

      virtual void createMediaPipeline(const DtString& pipelineConfigurations,
         const DtString tapeFilePath, int port);


      DtResponse newFile(const DtCommand& command);
      DtResponse closeFile(const DtCommand& command);
      DtResponse cancelRecording(const DtCommand& command);
      DtResponse record(const DtCommand& command);
      DtResponse pause(const DtCommand& command);
      DtResponse unpause(const DtCommand& command);
      DtResponse stop(const DtCommand& command);
      DtResponse stopCondition(const DtCommand& command);
      DtResponse stopDuration(const DtCommand& command);
      DtResponse stopSize(const DtCommand& command);
      DtResponse setCheckpointParameters(const DtCommand& command);
      DtResponse setPauseOnRecordAs(const DtCommand& command);
      DtResponse saveRecordedData(const DtCommand& command);
      DtResponse saveRecordedDataFinished(const DtCommand& command);
      DtResponse setRecordToMultipleFilesSettings(const DtCommand& command);
      DtResponse startRecordToMultipleFiles(const DtCommand& command);
      DtResponse setMediaRecordFromStreamConfiguration( const DtCommand& command );
      DtResponse setMediaRecordFromStreamPipeline(const DtCommand& command);
      DtResponse setIsRecordingMediaStream(const DtCommand& command);
      DtResponse setMediaRecordByDefault(const DtCommand& command);
      DtResponse setMediaRecordStreamParameters(const DtCommand& command);

   protected:

      class DumpCurrentRecordingThread : public DtRunnable
      {
      public:
         DumpCurrentRecordingThread( MAKLogger::DtLgrSystemDriver* driver, DtString newFileName,
            DtString description, DtLgrFileInput* input, DtLgrFileOutput* output,
            int packetOperationCount, double fixedDuration,DtRelativeTime offset);

         virtual ~DumpCurrentRecordingThread();

         virtual void run();

      protected:
         DtCommandInterface* myInterface;
         DtString myFilename;
         DtString myDescription;
         DtLgrFileInput* myInputFile;
         DtLgrFileOutput* myOutput;
         int  myPacketOperationCount;
         DtRelativeTime myFixedDuration;
         DtRelativeTime myOffset;
      };

      DtString myFileName;
      DtString myDescription;
      DtLgrFileOutput* myFileOutput;
      DtLgrSystemDriver* myDriver;
      DtMessagePipeline* myPipeline;

      DtCheckpointPolicy* myCheckpointPolicy;
      int myCheckpointPolicyId;
      int myCheckpointPolicyCount;
      int myCheckpointPolicySize;
      DtAbsoluteTime myCheckpointPolicyTime;
      bool myCheckpointInteractions;

      DtLgrContinuousClock* myRecordingClock;
      DtLgrClock* myOriginalClock;
      DtAbsoluteTime myCurrentTime;

      bool myRecordingFlag;
      bool myPausedFlag;
      bool myPauseOnRecordAsFlag;
      bool myFileEmptyFlag;
      int myStopCondition;
      bool myStopConditionClose;
      DtRelativeTime myStopDuration;
      DtU64 myStopSize;
      int myPacketOperationCount;
      bool mySavingRecordingData;
      DtThreadedObject* myDumpThread;

      bool myRecordToMultipleFiles;
      double myMultipleFileDuration;
      double myLastMultipleFileEndTime;
      DtString myMultipleFileNamingConvention;
      DtAbsoluteTime myTimeToSaveMultipleFiles;
      int myMultipleFileIndex;
      DtFilePosition myNextSavePosition;
      DtMessageBuffer* myCompleteState;

      DtMessageBuffer myPauseTimeSnapshot;

      DtString myStreamConfiguration;
      DtString myStreamPipeline;
      std::set<DtLgrRecordMediaStream*> myRecordStreams;
      bool myIsRecordingMediaStream;
      int myMediaRecordPort;
      bool myMediaRecordByDefault;
      DtFilename myMediaFilename;

   };

}

#endif