VideoStream.cpp

#include "VideoStream.hh"

using namespace std;
using namespace BIAS;

#include <fcntl.h>
#include <sstream>
#include <iostream>
#include "Camera.hh"
#include <Base/Image/ImageIO.hh>


VideoStream::~VideoStream() {}


VideoStream::VideoStream()
{
  NumImages_ = 0;
  ImageSize_ = 0;
}

VideoStream::VideoStream(const std::string & file)
{
  NumImages_ = 0;
  ImageSize_  =0;
  Open(file);
}

// jw 
VideoStream::VideoStream(const BIAS::VideoStream & src){
    (*this) = src;
}

BIAS::VideoStream & 
VideoStream::operator=(const BIAS::VideoStream & src)
{
    Header_ = src.Header_;

    // no assignment operator for std streams!! (jw)
    //Ifs_ = src.Ifs_;
    BIASERR("Assignment operator is not correct due to missing fstream assignment! (jw)");

    ImageSize_ = src.ImageSize_;
    NumImages_ = src.NumImages_;
    FileSize_  = src.FileSize_;

    return *this;
}


    

int VideoStream::Open(const std::string & file)
{
  Ifs_.open(file.c_str(),ios::binary);
  if (!Ifs_) {
    BIASERR("Can not open file for reading");
    perror(file.c_str());
    return -1;
  }
  Ifs_.seekg(0,ios_base::end);
  FileSize_ = (unsigned long) Ifs_.tellg();
  Ifs_.seekg(0,ios_base::beg);
  Ifs_.read(reinterpret_cast<char *>(&Header_),sizeof(Header_));
  if (!Ifs_) {
    BIASERR("error reading from file");
    perror(file.c_str());
    return -1;
  }

  ImageSize_ = Header_.Width * Header_.Height * Header_.ChannelCount 
    * Header_.BytesPerPixel;

  NumImages_ = (FileSize_ - sizeof(Header_)) / Header_.AlignedSize; 

 return 0;
}


int VideoStream::Close()
{
  Ifs_.close();
  return 0;
}

// go through video stream and export count frames starting at start 
int VideoStream::SplitIntoFiles(const std::string &prefix, unsigned int start,
                unsigned int count )
{
  if (!Ifs_) {
    BIASERR("VideoStream not open.");
    return -1;
  }
  // we should seek to start

  unsigned int numimages;
  ostringstream filename;
  VSImageHeader  imghead;
  unsigned int paddingsize = Header_.AlignedSize - ImageSize_-sizeof(imghead);
  cout <<"Paddingsize: "<<paddingsize<<endl;
  Camera<unsigned char> img;
  UUID uid;
  img.Init(Header_.Width, Header_.Height, Header_.ChannelCount);
  char *imgdata = reinterpret_cast<char *> (img.GetImageData());
  if (count ==0) numimages = NumImages_ ;
  else numimages = count + start;
  for (unsigned int i=start;i<numimages; i++) {
    Ifs_.read(reinterpret_cast<char *>(&imghead), sizeof(imghead));
    if (!Ifs_) return -1;
    Ifs_.read(imgdata, ImageSize_);
    if (!Ifs_) return -1;
    uid.SetFromString(imghead.uuid);
    img.SetUID(uid);
    filename.str("");
    filename<<prefix<<i;
    cout <<"file: "<<filename.str()<<" UUID: "<<img.GetUID()<<" Time: "
     <<imghead.tsec<<" "<<imghead.tusec<<endl;
    img.UpdateMetaData();
    //ImageIO::Save(filename.str(),img,false,false);
    ImageIO::Save(filename.str(),
                  img,
                  ImageIO::FF_auto,
                  false,
                  BIAS_DEFAULT_IMAGE_QUALITY,
                  false);
    Ifs_.seekg(paddingsize,ios_base::cur);

  }

  return 0;
}


void VideoStream::PrintHeader()
{

  cout <<"FileSize: "<<FileSize_<<endl;
  cout <<"Image width, height, channelcout, BpP: "<<Header_.Width<<"x"
    <<Header_.Height<<", "<<(int)Header_.ChannelCount<<", "
    <<(int)Header_.BytesPerPixel<<endl;

  cout <<"StorageType, ColorModel: "
    <<int(Header_.StorageType)<<", "
    <<int(Header_.ColorModel)<<endl;

  cout <<"ImageSize, BlockSize: "<<ImageSize_<<", "<<Header_.AlignedSize<<endl;
  cout <<"NumImages: "<<NumImages_<<endl;
  cout <<"Remainer: "<<FileSize_ - sizeof(Header_) - NumImages_ * 
    Header_.AlignedSize<<endl;
}