VideoSource_Shm.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
*/
#include <string>
#include <sstream>
#include <iostream>
#include <sstream>

#include <Image/Camera.hh>
#include <VideoSource/VideoSource_Shm.hh>

#ifdef WIN32
#  define WIN32_LEAN_AND_MEAN       // Exclude rarely-used stuff from Windows headers
#  include <windows.h>
#else
# include <sys/types.h>
# include <sys/mman.h>
#include <fcntl.h>
#endif

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


#include <Base/Common/BIASpragma.hh>


using namespace BIAS;
using namespace std;

VideoSource_Shm::VideoSource_Shm(): VideoSource()
{
  IsCreator_ = false;
  bSync_ = true;
  pImgBuffer_ = new std::stringstream;
  LastTime_ = 0.0;
  ColorChannels_ = 3; // fake
  ColorMode_ = ImageBase::CM_RGB; // fake
#ifdef WIN32
  Context_ = NULL;
  Mapping_ = NULL;
#else
  Context_ = 0;
#endif
} 

VideoSource_Shm::~VideoSource_Shm() 
{ 
  if (pImgBuffer_!=NULL) {
    delete pImgBuffer_;
    pImgBuffer_ = NULL;
  }
}

void VideoSource_Shm::SetSize(int w, int h, int bytesperpixel){
  Width_ = w;
  Height_ = h;
  BytesPerPixel_ = bytesperpixel;
  ColorChannels_ = bytesperpixel;
}


 
int VideoSource_Shm::OpenDevice() 
{
  return OpenDevice("/VideoSource_Shm.shm");
}

int VideoSource_Shm::OpenDevice(const char *name)
{
  if (Width_ ==0 || Height_ ==0) {
    Width_ = 1024;
    Height_ = 1024;
  }
  DataLength_ = Width_ * Height_ * ColorChannels_;
  TotalLength_ = DataLength_ + sizeof(ShmImageHeader);
  FileName_ = name;
#ifdef WIN32
  SYSTEM_INFO sSysInfo;
  GetSystemInfo( &sSysInfo );
  Granularity_ = sSysInfo.dwAllocationGranularity;
  while( long(TotalLength_) > Granularity_ )
    Granularity_ += sSysInfo.dwAllocationGranularity;
  TotalLength_ = Granularity_;

  //Try to connect to existing File-Mapping
  while ( Mapping_ == NULL ) {
    Mapping_ = OpenFileMapping( FILE_MAP_ALL_ACCESS,FALSE,FileName_.c_str());
    cout <<"Wait for file mapping: "<<FileName_<<endl;
    Sleep(1000);
  }
  Shm_= (unsigned char*)MapViewOfFile(Mapping_,FILE_MAP_ALL_ACCESS,0,0,0);
  if (Shm_ == NULL) {
    BIASERR("Failed to memory map file");
    return -1;
  };
  
  return 0;
  
#else
  // try to open existing file, if that failes, create new one
  Context_ = shm_open(FileName_.c_str(),O_RDWR,
              S_IRWXU| S_IRWXG| S_IRWXO);
  if (Context_ <0) {
    IsCreator_ = true;
    cout <<"Creating new context"<<endl;
    Context_ = shm_open(FileName_.c_str(),O_RDWR| O_CREAT,
            S_IRWXU| S_IRWXG| S_IRWXO);
    int res;
    res = ftruncate(Context_,TotalLength_);
    if (res <0) {
      perror(FileName_.c_str());
      return -1;
    }

  }
  else cout <<"Using old context"<<endl;
  if (Context_ <0) {
    perror(name);
    return -1;
  }
#endif
  return 0;
}


int VideoSource_Shm::PreGrab() 
{
#ifdef WIN32
  
#else
  Shm_ = mmap(0,TotalLength_, PROT_READ | PROT_WRITE ,MAP_SHARED,Context_,0 );
#endif
  Header_ = (ShmImageHeader*)Shm_;
  Data_ = (char*)Shm_ +sizeof(ShmImageHeader);
  return 0;
} // PreGrab


int VideoSource_Shm::GrabSingle(Camera <unsigned char> &image) 
{
  bool gotit = false;
  BIAS::RMatrix tmpR;
  BIAS::Vector3<double> tmpC;
  do {

    if ((Header_->Time_ >LastTime_)||(!bSync_)) {
//   cout <<"VideoShmFeeder: Header is: "<<setw(20)<<setprecision(20)
//        <<Header_->Time_<<" , "<<Header_->Size_<<endl;
      if (Header_->Size_ >DataLength_) Resize_(Header_->Size_);
      
      pImgBuffer_->str("");
      if ((int)pImgBuffer_->rdbuf()->sputn(Data_,Header_->Size_) < (int) Header_->Size_) {
        BIASERR("Could not write data to streambuffer!");
        BIASABORT;
      }
      image.Release();
      //copy images data
      *pImgBuffer_>>image;    
      image.InvalidateUID();
      //copy images time
      image.SetTime(Header_->Time_);
      //copy images RMatrix and CVector
      tmpR.Set(BIAS::Vector3<double>(Header_->AxisX_,
                                     Header_->AxisY_,
                                     Header_->AxisZ_),
               Header_->Angle_);
      tmpC.Set(Header_->C1_, Header_->C2_, Header_->C3_);
      image.SetR(tmpR);
      image.SetC(tmpC);

      LastTime_ =  Header_->Time_;
      gotit = true;
      //cout << "shm: cm: "<<boolalpha<< (image.GetColorModel()==ImageBase::CM_Bayer_RGGB)<<endl;
    } else 
#ifdef WIN32
      Sleep(1);
#else
      usleep(1000);
#endif
  } while ((!gotit)&&(bSync_));
  image.SetUID(UUID::GenerateUUID());

  return 0;  
} 


int VideoSource_Shm::PostGrab() 
{
#ifdef WIN32
#else
  munmap(Shm_, TotalLength_);
#endif
  return 0;
} // PostGrab


int VideoSource_Shm::CloseDevice() 
{
#ifdef WIN32
    UnmapViewOfFile(Shm_);
    CloseHandle(Mapping_ );
#else
    //  shm_unlink(FileName_.c_str());
#endif
  return 0;
} // CloseDevice




int VideoSource_Shm::Resize_(int newsize)
{
  cout <<"Resizing from: "<<TotalLength_;
  PostGrab();
  DataLength_ = newsize;
  TotalLength_ = DataLength_ + sizeof(ShmImageHeader);  
  PreGrab();
  cout<<" to: "<<TotalLength_<<endl;
  return newsize;
}