vtkVideoSource.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkVideoSource.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkVideoSource_h
#define vtkVideoSource_h
 
#include "vtkIOVideoModule.h" // For export macro
#include "vtkImageAlgorithm.h"
 
class vtkTimerLog;
class vtkCriticalSection;
class vtkMultiThreader;
class vtkScalarsToColors;
 
class VTKIOVIDEO_EXPORT vtkVideoSource : public vtkImageAlgorithm
{
public:
  static vtkVideoSource* New();
  vtkTypeMacro(vtkVideoSource, vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual void Record();
 
  virtual void Play();
 
  virtual void Stop();
 
  virtual void Rewind();
 
  virtual void FastForward();
 
  virtual void Seek(int n);
 
  virtual void Grab();
 
 
  vtkGetMacro(Recording, int);
 
 
  vtkGetMacro(Playing, int);
 
 
  virtual void SetFrameSize(int x, int y, int z);
  virtual void SetFrameSize(int dim[3]) { this->SetFrameSize(dim[0], dim[1], dim[2]); }
  vtkGetVector3Macro(FrameSize, int);
 
 
  virtual void SetFrameRate(float rate);
  vtkGetMacro(FrameRate, float);
 
 
  virtual void SetOutputFormat(int format);
  void SetOutputFormatToLuminance() { this->SetOutputFormat(VTK_LUMINANCE); }
  void SetOutputFormatToRGB() { this->SetOutputFormat(VTK_RGB); }
  void SetOutputFormatToRGBA() { this->SetOutputFormat(VTK_RGBA); }
  vtkGetMacro(OutputFormat, int);
 
 
  virtual void SetFrameBufferSize(int FrameBufferSize);
  vtkGetMacro(FrameBufferSize, int);
 
 
  vtkSetMacro(NumberOfOutputFrames, int);
  vtkGetMacro(NumberOfOutputFrames, int);
 
 
  vtkBooleanMacro(AutoAdvance, vtkTypeBool);
  vtkSetMacro(AutoAdvance, vtkTypeBool);
  vtkGetMacro(AutoAdvance, vtkTypeBool);
 
 
  virtual void SetClipRegion(int r[6]) { this->SetClipRegion(r[0], r[1], r[2], r[3], r[4], r[5]); }
  virtual void SetClipRegion(int x0, int x1, int y0, int y1, int z0, int z1);
  vtkGetVector6Macro(ClipRegion, int);
 
 
  vtkSetVector6Macro(OutputWholeExtent, int);
  vtkGetVector6Macro(OutputWholeExtent, int);
 
 
  vtkSetVector3Macro(DataSpacing, double);
  vtkGetVector3Macro(DataSpacing, double);
 
 
  vtkSetVector3Macro(DataOrigin, double);
  vtkGetVector3Macro(DataOrigin, double);
 
 
  vtkSetMacro(Opacity, float);
  vtkGetMacro(Opacity, float);
 
 
  vtkGetMacro(FrameCount, int);
  vtkSetMacro(FrameCount, int);
 
 
  vtkGetMacro(FrameIndex, int);
 
  virtual double GetFrameTimeStamp(int frame);
 
  double GetFrameTimeStamp() { return this->FrameTimeStamp; }
 
 
  virtual void Initialize();
  virtual int GetInitialized() { return this->Initialized; }
 
  virtual void ReleaseSystemResources();
 
  virtual void InternalGrab();
 
 
  void SetStartTimeStamp(double t) { this->StartTimeStamp = t; }
  double GetStartTimeStamp() { return this->StartTimeStamp; }
 
protected:
  vtkVideoSource();
  ~vtkVideoSource() override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int Initialized;
 
  int FrameSize[3];
  int ClipRegion[6];
  int OutputWholeExtent[6];
  double DataSpacing[3];
  double DataOrigin[3];
  int OutputFormat;
  // set according to the OutputFormat
  int NumberOfScalarComponents;
  // The FrameOutputExtent is the WholeExtent for a single output frame.
  // It is initialized in ExecuteInformation.
  int FrameOutputExtent[6];
 
  // save this information from the output so that we can see if the
  // output scalars have changed
  int LastNumberOfScalarComponents;
  int LastOutputExtent[6];
 
  int Recording;
  int Playing;
  float FrameRate;
  int FrameCount;
 
  double StartTimeStamp;
  double FrameTimeStamp;
 
  vtkTypeBool AutoAdvance;
  int NumberOfOutputFrames;
 
  float Opacity;
 
  // true if Execute() must apply a vertical flip to each frame
  int FlipFrames;
 
  // set if output needs to be cleared to be cleared before being written
  int OutputNeedsInitialization;
 
  // An example of asynchrony
  vtkMultiThreader* PlayerThreader;
  int PlayerThreadId;
 
  // A mutex for the frame buffer: must be applied when any of the
  // below data is modified.
  vtkCriticalSection* FrameBufferMutex;
 
  // set according to the needs of the hardware:
  // number of bits per framebuffer pixel
  int FrameBufferBitsPerPixel;
  // byte alignment of each row in the framebuffer
  int FrameBufferRowAlignment;
  // FrameBufferExtent is the extent of frame after it has been clipped
  // with ClipRegion.  It is initialized in CheckBuffer().
  int FrameBufferExtent[6];
 
  int FrameBufferSize;
 
  // where the current frame is, note this decreases in time
  // increasing values are older frames
  int FrameBufferIndex;
 
  // number of frames from the beginning sort of,
  // it does wrap, sometimes
  int FrameIndex;
 
  void** FrameBuffer;
  double* FrameBufferTimeStamps;
 
 
  virtual void UpdateFrameBuffer();
  virtual void AdvanceFrameBuffer(int n);
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  // if some component conversion is required, it is done here:
  virtual void UnpackRasterLine(char* outPtr, char* rowPtr, int start, int count);
 
private:
  vtkVideoSource(const vtkVideoSource&) = delete;
  void operator=(const vtkVideoSource&) = delete;
};
 
#endif