VideoShMFeeder.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
*/

// for gcc 4.7
#ifndef WIN32
#include <unistd.h>
#endif

#include "VideoShMFeeder.hh"
#include <Base/Common/BIASpragma.hh>



using namespace BIAS;
using namespace std;

VideoShMFeeder::VideoShMFeeder()
{
#ifdef WIN32
  ShmContext_ = NULL;
  Mapping_ = NULL;
#else
  ShmContext_ = 0;
#endif
  MemoryLengthTotal_ = 0;
  DataLength_ = 0;
  Shm_ = NULL;
  Header_ = NULL;
  Data_ = NULL;
  bIsInitialized_ = false;
#ifdef WIN32
  FileName_ = "/VideoSource_Shm.shm";
#else
  FileName_ = "VideoSource_Shm.shm";
#endif
}



VideoShMFeeder::VideoShMFeeder(const string &filename)
{
#ifdef WIN32
  ShmContext_ = NULL;
  Mapping_ = NULL;
#else
  ShmContext_ = 0;
#endif
  MemoryLengthTotal_ = 0;
  DataLength_ = 0;
  Shm_ = NULL;
  Header_ = NULL;
  Data_ = NULL;
  bIsInitialized_ = false;
  FileName_ = filename;
}


VideoShMFeeder::~VideoShMFeeder()
{
   bIsInitialized_ = false;
#ifdef WIN32
    UnmapViewOfFile(Shm_);
    CloseHandle(Mapping_ );
  DeleteFile(FileName_.c_str());
#else
  shm_unlink(FileName_.c_str());
#endif
}

bool VideoShMFeeder::Init_()
{
  MemoryLengthTotal_ = DataLength_ + sizeof(VideoSource_Shm::ShmImageHeader);

#ifdef WIN32
  SYSTEM_INFO sSysInfo;
  GetSystemInfo( &sSysInfo );
  Granularity_ = sSysInfo.dwAllocationGranularity;
  while( long(MemoryLengthTotal_) > Granularity_ )
    Granularity_ += sSysInfo.dwAllocationGranularity;
  MemoryLengthTotal_ = Granularity_;
 
  //check if file exists
  if( Mapping_ == NULL )
    Mapping_ = OpenFileMapping( FILE_MAP_ALL_ACCESS,FALSE,FileName_.c_str());

  if(Mapping_ == NULL)
    {
      HANDLE File_ = CreateFile(FileName_.c_str(),GENERIC_WRITE 
                | GENERIC_READ,
                FILE_SHARE_WRITE,NULL,CREATE_ALWAYS, 
                FILE_ATTRIBUTE_TEMPORARY,NULL );
      //create a new filemapping
      Mapping_= CreateFileMapping(File_,    // use paging file
                  NULL,                    // default security 
                  PAGE_READWRITE,          // read/write access
                  0,                       // max. object size 
                  // buffer size                  
                  Granularity_ + MemoryLengthTotal_,      
                  FileName_.c_str());  // name of mapping object
    }
  if (Mapping_ == NULL) {
    BIASERR("Failed to memory map file");
    return false;
  };

  Shm_= (unsigned char*)MapViewOfFile(Mapping_,FILE_MAP_ALL_ACCESS,0,0,0);
  
  if (Shm_ == NULL) {
    BIASERR("Failed to memory map file");
    return false;
  };

#else // win32
  ShmContext_ = shm_open(FileName_.c_str(),O_RDWR,S_IRWXU| S_IRWXG| S_IRWXO);
  if (ShmContext_ <0) {
    // cout <<"Creating new context"<<endl;
    ShmContext_ = shm_open(FileName_.c_str(),O_RDWR| O_CREAT,
            S_IRWXU| S_IRWXG| S_IRWXO);
  }
  // else cout <<"Using old context"<<endl;


  if (ShmContext_ <0) {
    BIASERR("Unable to create VideoSource_Shm.shm");
    return false;
  }
  int res;
  res = ftruncate(ShmContext_, MemoryLengthTotal_);
  if (res <0) {
    perror(FileName_.c_str());
    return -1;
  }

  Shm_ = mmap(0,MemoryLengthTotal_, PROT_WRITE,MAP_SHARED, ShmContext_, 0 );
  if (Shm_ == MAP_FAILED) {
    BIASERR("Unable to create memory-mapping!!!");
    return false;
  }
#endif 

  //pointer to header
  Header_ = (VideoSource_Shm::ShmImageHeader*)Shm_;
  Header_->Time_ = 0;
  Header_->AxisX_ = Header_->AxisY_ = Header_->AxisZ_ = Header_->Angle_ = 0;
  Header_->C1_ = Header_->C2_ = Header_->C3_ = 0;

  //pointer to data array behind header
  Data_ = (unsigned char*)Shm_ +sizeof(VideoSource_Shm::ShmImageHeader);
  
  bIsInitialized_ = true;
  return true;

}



bool VideoShMFeeder::ProcessImage(BIAS::Camera<unsigned char> *Image)
{

  ImgBuffer_.clear();
  ImgBuffer_.str("");
  ImgBuffer_ <<*Image;
  
  int size = ImgBuffer_.str().length();
  if (!bIsInitialized_) {
    DataLength_ = size;
    Init_();
  }
  BIASASSERT(size <=DataLength_);

  Header_->Size_ = DataLength_;
  
  memcpy(Data_,ImgBuffer_.str().c_str() ,Header_->Size_);
  //Set time != 0 to indicate new image data
  Header_->Time_ = Image->GetTime();
  //Set data for RMatrix and CVector
  BIAS::Vector3<double> tmpVec;
  (Image->GetR()).GetRotationAxisAngle(tmpVec, Header_->Angle_);
  Header_->AxisX_ = tmpVec[0];
  Header_->AxisY_ = tmpVec[1];
  Header_->AxisZ_ = tmpVec[2];
  tmpVec = Image->GetC();
  Header_->C1_ = tmpVec[0];
  Header_->C2_ = tmpVec[1];
  Header_->C3_ = tmpVec[2];
//   cout <<"VideoShmFeeder: Header is: "<<setw(20)<<setprecision(20)
//        <<Header_->Time_<<" , "<<Header_->Size_<<endl;

  return true;
}