VideoSource_Disk.cpp

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


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

BIAS 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef  WIN32
#include <unistd.h>
#endif //WIN32
#include <Base/Common/W32Compat.hh>

#include <string>
#include <sstream>
#include <iostream>

#include "VideoSource_Disk.hh"
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageAttributes.hh>
#include <Image/Camera.hh>
#ifdef BIAS_HAVE_FFMPEG
#  include <VideoSource/VideoSource_FFmpeg.hh>
#endif
#include <Base/Common/BIASpragma.hh>

using namespace BIAS;
using namespace std;

VideoSource_Disk::VideoSource_Disk(): VideoSource()
{
  ActiveFrame_ = 0;
  SetDebugLevel(0);
  FramesPerSecond_=15;
  KeepFPS_ = true;
  Loop_ = true;
  bReverse_ = false;
  bReversePlaying_ = false;
  bUseMetaData_ = false;
  FrameCounterAsTimeStamp_=false;
  GenerateNewUIDs_ = true;
  bVideo_ = false;
}


VideoSource_Disk::~VideoSource_Disk()
{
}


int VideoSource_Disk::OpenDevice(string Prefix, string Postfix, int DigitCount, int PictureCount, int startCount)
{
  vector<string> FileNames;
  ostringstream Name;

  for (int i = startCount; i< PictureCount; i++){
    Name.str(""); // reset stringstream
    Name << Prefix << setfill('0') << setw(DigitCount) << i << Postfix;
    FileNames.push_back(Name.str());
    BIASDOUT(D_VSO_DISK,i<<"\t"<< Name.str().c_str());
  }
  BIASDOUT(D_VSO_DISK,"leaving VideoSource_Disk::OpenDevice(string .. )");
  return OpenDevice(FileNames);
}


int VideoSource_Disk::OpenDevice(const vector<string> &FileNames)
{
//   BIASDOUT(D_VSO_DISK,"entering VideoSource_Disk::OpenDevice(vector<string>)");
//  Camera<unsigned char> Image;
  // load first image and initialize some internal variables
  ImageBase Image;
  BIASDOUT(D_VSO_DISK,"FileNames[0] : "<<FileNames[0]);
  // Image.SetDebugLevel(D_COPYIN | D_CONVERT);
  if (FileNames.empty()){
    BEXCEPTION("VideoSource_Disk::OpenDevice(): empty argument vector");
    return -2;
  }
  if (ImageIO::Load(FileNames[0], Image)!=0){
#ifdef BIAS_HAVE_FFMPEG
    if (Video_.OpenDevice(FileNames[0].c_str())==0)
    {     
      bVideo_ = true;
      Width_ = Video_.GetWidth();
      Height_ = Video_.GetHeight();
      ColorMode_ = ImageBase::CM_RGB;
      ColorChannels_ = ImageBase::GetSizeUnits(ColorMode_);
      BytesPerPixel_ = 1.0;

      CompleteInitialized_ = true;
      ActiveFrame_ = 0;
      return 0;
    }
#endif
    cout<<"pwd: ";
    int r = system("pwd");
    if (r==-1){ BIASERR("error getting pwd"); }
    BIASERR("unable to read "<<FileNames[0]);
    BIASBREAK;
    return -1;
  }

  ImageAttributes attr;
  attr.InitExifTags();
  attr.Read(FileNames[0]);
  Identifier_ = attr.GetIdentifier();

  Width_  = Image.GetWidth();
  Height_ = Image.GetHeight();
  ColorChannels_ = Image.GetChannelCount();
  ColorMode_ = Image.GetColorModel();
  BytesPerPixel_ = Image.GetDepth();
  if (FileNames_.size() != 0)
    FileNames_.erase(FileNames_.begin(), FileNames_.end());

  for (vector<string>::const_iterator i = FileNames.begin();
    i != FileNames.end();i++)
  {
    FileNames_.push_back(*i);

#if 0
    const char *fName2 =(*i).c_str();
    //ImageIO::Load(fName2,Image);
    ImageIO::Load(fName2,Image);
    if (i != FileNames.begin()){
      if (Width_ != Image.GetWidth() || Height_ != Image.GetHeight() ||
        ColorChannels_ != Image.GetChannelCount() ){
          BIASERR("VideoSource_Disk::OpenDevice() Image is "<<*i<<
            " different from first image in sequence");
          return -1;
        }
    }
#endif
  }

  CompleteInitialized_ = true;
  ActiveFrame_ = 0;
  /* old version -- without timemeasure.hh
  gettimeofday(&lastTime_,NULL);
  */
  return 0;
}

int VideoSource_Disk::PreGrab()
{
  VideoSource::PreGrab();

#ifdef BIAS_HAVE_FFMPEG
  if (bVideo_)
  {
    Video_.PreGrab();
  }
#endif
  timer_.Start();
  return 0;
}



int VideoSource_Disk::CloseDevice()
{
  if (Grabbing_) {
    BIASERR("VideoSource_Disk::CloseDevice(): Grabbing is running, but closing anyway");
  }
  Grabbing_ = false;
  PostGrab();
  CompleteInitialized_ = false;

#ifdef BIAS_HAVE_FFMPEG
  if (bVideo_)
  {
    Video_.CloseDevice();
  }
  else
#endif
  {
    if (FileNames_.size() != 0)
      FileNames_.erase(FileNames_.begin(), FileNames_.end());
  }
  return 0;
}


int  VideoSource_Disk::SetColorMode(ImageBase::EColorModel mode)
{
  BIASERR("VideoSource_Disk::SetColorMode: source always gives the original"<<
          " color mode of the saved files");
  return -1;
}

int VideoSource_Disk::GrabSingle(Camera<unsigned char> &image)
{
  BIASDOUT(D_VSO_DISK,"VideoSource_Disk::GrabSingle()");

#ifdef BIAS_HAVE_FFMPEG
  if (!bVideo_ && ActiveFrame_ == FileNames_.size())
#else
  if (ActiveFrame_ == FileNames_.size())
#endif
  {
    if (Loop_) {
      ActiveFrame_=0;
      BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
    } else {
      BEXCEPTION_NONFATAL("VideoSource_DISK: End of input. SetLoop(true) or "
                          <<"Rewind()");
      BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
      return -1;
    }
  }
  int res;
  if (!Active_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object not active, use PreGrab()");
    return -1;
  }

  if (Grabbing_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object is already grabbing()");
    return -1;
  }


#ifdef BIAS_HAVE_FFMPEG
  if (!bVideo_)
#endif
  {
    Grabbing_ = true;
    res = ImageIO::Load(FileNames_[ActiveFrame_],image);

    if (res<0) {
      BEXCEPTION("VideoSource_Disk::GrabSingle(): Unable to read image: "
                 <<FileNames_[ActiveFrame_]);
      BIASERR("VideoSource_Disk::GrabSingle(): Unable to read image: "<<FileNames_[ActiveFrame_]);
      return res;
    }
  }
#ifdef BIAS_HAVE_FFMPEG
  else
  {
    if (bReversePlaying_)
    {
      BIASERR("VideoSource_Disk::GrabSingle(): Reverse playing is not supported for videos yet");
      return -1;
    }
    if (ActiveFrame_ == 0)
      Video_.SeekFrame(0);
    bool eof = !Video_.GrabSingle(image);

    if (eof)
    {
      if (Loop_)
      {
  Video_.SeekFrame(0);
  if (!Video_.GrabSingle(image))
      return -1;
      }
      else
    return -1;
    }
  }
#endif

  // set time to _now_
  if (FrameCounterAsTimeStamp_) image.SetTime(ActiveFrame_,0);
  else {
    timeval tv;
    gettimeofday(&tv, NULL);
    image.SetTime(tv.tv_sec,tv.tv_usec);
  }

  //set meta data from loaded image, if activated
  if (bUseMetaData_) image.ParseMetaData();

  if(ActiveFrame_<FileNames_.size()-1){
    BIASDOUT(D_VSO_DISK,"GrabSingle() "<<ActiveFrame_<<"  "<<
             FileNames_[ActiveFrame_]);
    if(bReversePlaying_){
      if(ActiveFrame_>0)
        ActiveFrame_--;
      else
        {
          bReversePlaying_=false;
          ActiveFrame_++;
        }
    }
    else{
      ActiveFrame_++;
    }
  }
  else if (Loop_) {
    ActiveFrame_=0;
    BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
  }
  else if(bReverse_){

    bReversePlaying_=true;
    ActiveFrame_--;
  }
  else ActiveFrame_++;

  Grabbing_ = false;
  BIASDOUT(D_VSO_DISK,"leaving GrabSingle()");
  // check time and sleep while enough time elapsed
  double secPerFrame=1.0/FramesPerSecond_;

  //struct timeval now;         -- displaced by TimeMeasure
  //double secs=0.0;            --         -"-
  //while (secs<=secPerFrame) { --         -"-
  if(KeepFPS_) {
    timer_.Stop();
    if (FramesPerSecond_ != 0)
    {
      while (timer_.GetRealTime()<=(1E06*secPerFrame))
      {

        timer_.Start();
#ifdef   WIN32
        Sleep(1);        //go sleeping for 1 msec
#else  //not WIN32
        usleep(1000);     //go sleeping for 1 msec
#endif //WIN32
        timer_.Stop();

      }
    }
    timer_.Reset();
    timer_.Start();
  }
  if (GenerateNewUIDs_) {
    image.SetUID(BIAS::UUID::GenerateUUID());
  }
  //lastTime_=now;   -- displaced by TimeMeasure

  return 0;
}

int VideoSource_Disk::GrabSingle(Camera<float> &image)
{
  BIASDOUT(D_VSO_DISK,"VideoSource_Disk::GrabSingle()");

  if (ActiveFrame_ == FileNames_.size()){
    BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
    return -1;
  }
  int res;
  if (!Active_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object not active, use PreGrab()");
    return -1;
  }

  if (Grabbing_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object is already grabbing()");
    return -1;
  }

  Grabbing_ = true;
  res = ImageIO::Load(FileNames_[ActiveFrame_],image);

  if (res<0) {
    BIASERR("VideoSource_Disk::GrabSingle(): Unable to read image: "<<FileNames_[ActiveFrame_]);
    return res;
  }

  // set time to _now_
  if (FrameCounterAsTimeStamp_) image.SetTime(ActiveFrame_,0);
  else {
    timeval tv;
    gettimeofday(&tv, NULL);
    image.SetTime(tv.tv_sec,tv.tv_usec);
  }

  //set meta data from loaded image, if activated
  if (bUseMetaData_) image.ParseMetaData();

  if(ActiveFrame_<FileNames_.size()-1){
    BIASDOUT(D_VSO_DISK,"GrabSingle() "<<ActiveFrame_<<"  "<<
             FileNames_[ActiveFrame_]);
    if(bReversePlaying_){
      if(ActiveFrame_>0)
        ActiveFrame_--;
      else
        {
          bReversePlaying_=false;
          ActiveFrame_++;
        }
    }
    else{
      ActiveFrame_++;
    }
  }
  else if (Loop_) {
    ActiveFrame_=0;
    BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
  }
  else if(bReverse_){

    bReversePlaying_=true;
    ActiveFrame_--;
  }
  else ActiveFrame_++;

  Grabbing_ = false;
  BIASDOUT(D_VSO_DISK,"leaving GrabSingle()");
  // check time and sleep while enough time elapsed
  double secPerFrame=1.0/FramesPerSecond_;

  //struct timeval now;         -- displaced by TimeMeasure
  //double secs=0.0;            --         -"-
  //while (secs<=secPerFrame) { --         -"-
  if(KeepFPS_) {
    timer_.Stop();

    if (FramesPerSecond_ != 0)
    {
      while (timer_.GetRealTime()<=(1E06*secPerFrame))
      {

        timer_.Start();
#ifdef   WIN32
        Sleep(1);        //go sleeping for 1 msec
#else  //not WIN32
        usleep(1000);     //go sleeping for 1 msec
#endif //WIN32
        timer_.Stop();

      }
      timer_.Reset();
      timer_.Start();
    }
  }
  if (GenerateNewUIDs_) {
    image.SetUID(BIAS::UUID::GenerateUUID());
  }
  //lastTime_=now;   -- displaced by TimeMeasure

  return 0;
}

#ifdef BUILD_IMAGE_USHORT
int VideoSource_Disk::GrabSingle(Camera<unsigned short> &image)
{
  BIASDOUT(D_VSO_DISK,"VideoSource_Disk::GrabSingle()");

  if (ActiveFrame_ == FileNames_.size()){
    BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
    return -1;
  }
  int res;
  if (!Active_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object not active, use PreGrab()");
    return -1;
  }

  if (Grabbing_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object is already grabbing()");
    return -1;
  }

  Grabbing_ = true;
  res = ImageIO::Load(FileNames_[ActiveFrame_],image);

  if (res<0) {
    BIASERR("VideoSource_Disk::GrabSingle(): Unable to read image: "<<FileNames_[ActiveFrame_]);
    return res;
  }

  // set time to _now_
  if (FrameCounterAsTimeStamp_) image.SetTime(ActiveFrame_,0);
  else {
    timeval tv;
    gettimeofday(&tv, NULL);
    image.SetTime(tv.tv_sec,tv.tv_usec);
  }

  //set meta data from loaded image, if activated
  if (bUseMetaData_) image.ParseMetaData();

  if(ActiveFrame_<FileNames_.size()-1){
    BIASDOUT(D_VSO_DISK,"GrabSingle() "<<ActiveFrame_<<"  "<<
             FileNames_[ActiveFrame_]);
    if(bReversePlaying_){
      if(ActiveFrame_>0)
        ActiveFrame_--;
      else
        {
          bReversePlaying_=false;
          ActiveFrame_++;
        }
    }
    else
      ActiveFrame_++;
  }
  else if (Loop_) {
    ActiveFrame_=0;
    BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
  }
  else if(bReverse_){
    bReversePlaying_=true;
    ActiveFrame_--;
  }
  else ActiveFrame_++;

  Grabbing_ = false;
  BIASDOUT(D_VSO_DISK,"leaving GrabSingle()");
  // check time and sleep while enough time elapsed
  double secPerFrame=1.0/FramesPerSecond_;

  //struct timeval now;         -- displaced by TimeMeasure
  //double secs=0.0;            --         -"-
  //while (secs<=secPerFrame) { --         -"-
  if(KeepFPS_) {
    timer_.Stop();

    if (FramesPerSecond_ != 0)
    {
      while (timer_.GetRealTime()<=(1E06*secPerFrame))
      {
        timer_.Start();
#ifdef   WIN32
        Sleep(1);        //go sleeping for 1 msec
#else  //not WIN32
        usleep(1000);     //go sleeping for 1 msec
#endif //WIN32
        timer_.Stop();
      }
    }
    timer_.Reset();
    timer_.Start();
  }
  if (GenerateNewUIDs_) {
    image.SetUID(BIAS::UUID::GenerateUUID());
  }
  //lastTime_=now;   -- displaced by TimeMeasure

  return 0;
}
#endif

int VideoSource_Disk::GrabSingle(ImageBase &image)
{
  BIASDOUT(D_VSO_DISK,"VideoSource_Disk::GrabSingle()");

#ifdef BIAS_HAVE_FFMPEG
  if (!bVideo_ && ActiveFrame_ == FileNames_.size()){
#else
  if (ActiveFrame_ == FileNames_.size()){
#endif
    BIASERR("VideoSource_DISK: End of input. SetLoop(true) or Rewind()");
    return -1;
  }
  int res;
  if (!Active_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object not active, use PreGrab()");
    return -1;
  }

  if (Grabbing_) {
    BIASERR("VideoSource_Disk::GrabSingle(): VideoSource Object is already grabbing()");
    return -1;
  }

  Grabbing_ = true;
  res = ImageIO::Load(FileNames_[ActiveFrame_],image);

  if (res<0) {
    BIASERR("VideoSource_Disk::GrabSingle(): Unable to read image: "<<FileNames_[ActiveFrame_]);
    return res;
  }

  if(ActiveFrame_<FileNames_.size()-1){
    BIASDOUT(D_VSO_DISK,"GrabSingle() "<<ActiveFrame_<<"  "<<
             FileNames_[ActiveFrame_]);
    if(bReversePlaying_){
      if(ActiveFrame_>0)
        ActiveFrame_--;
      else
        {
          bReversePlaying_=false;
          ActiveFrame_++;
        }
    }
    else
      ActiveFrame_++;
  }
  else if (Loop_) {
    ActiveFrame_=0;
    BIASDOUT(D_VSO_DISK,"GrabSingle() restarting with first file");
  }
  else if(bReverse_){
    bReversePlaying_=true;
    ActiveFrame_--;
  }
  else ActiveFrame_++;

  Grabbing_ = false;
  BIASDOUT(D_VSO_DISK,"leaving GrabSingle()");
  // check time and sleep while enough time elapsed
  double secPerFrame=1.0/FramesPerSecond_;

  //struct timeval now;         -- displaced by TimeMeasure
  //double secs=0.0;            --         -"-
  //while (secs<=secPerFrame) { --         -"-
  if(KeepFPS_) {
    timer_.Stop();

    if (FramesPerSecond_ != 0)
    {
      while (timer_.GetRealTime()<=(1E06*secPerFrame))
      {
        timer_.Start();
#ifdef   WIN32
        Sleep(1);        //go sleeping for 1 msec
#else  //not WIN32
        usleep(1000);     //go sleeping for 1 msec
#endif //WIN32
        timer_.Stop();
      }
    }
    timer_.Reset();
    timer_.Start();
  }
    if (GenerateNewUIDs_) {

    image.SetUID(BIAS::UUID::GenerateUUID());
  }
  //lastTime_=now;   -- displaced by TimeMeasure

  return 0;
}

unsigned int VideoSource_Disk::GetNumFramesRemaining() const
{
  if (!bVideo_)
    return (FileNames_.size()- ActiveFrame_);
#ifdef BIAS_HAVE_FFMPEG
  else{
    // Only usefull for stopping
    int64_t total = Video_.GetNumberOfFrames();
    int64_t current = Video_.GetCurrentFrameNumber();
    return  total - current;
  }
#endif
  return 0;
}