VideoSource_Base.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 <bias_config.h>
#include "VideoSource_Base.hh"
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>

#include <Image/VideoStream.hh>
#include <Image/Camera.hh>


#include <Base/Common/BIASpragma.hh>

#ifdef __APPLE__
# include <sys/types.h> // for fchmod
# include <sys/stat.h>
#endif

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


using namespace BIAS;
using namespace std;


// for O_APPEND
#include <fcntl.h>

VideoSource::VideoSource():Debug()
{
  Width_ = 0;
  Height_= 0;
  ColorChannels_ = 0;
  DeviceChannel_ = 0;
  BytesPerPixel_ = 1.0; // assume 8bpp as default
  CompleteInitialized_ = false;
  Active_ = false;
  Grabbing_ = false;
  DefaultDevice_ = NULL;
  DirectToDisk_ = false;
  DtDFd_ = 0;
  DtDBuffer_ = NULL;
  DtDBufferSize_ = 0;
  IsControllable_ = false;
  Identifier_ = "Uninitialized";
  WaitForNew_ = true;
  bExternalTrigger_ = false;
  minContrast_ = 0; //?
  maxContrast_ = 100;
  minGain_=0; //db
  maxGain_ = 255;
  minShutter_ = 0; //ms
  maxShutter_ = 200;
  minBrightness_ =0; //additive offset in pixel values 
  maxBrightness_ = 200;
  FramesPerSecond_ = 0;
}


VideoSource::~VideoSource()
{

}


void VideoSource::SetSize(int w, int h, int bytesperpixel)
{
  Width_ = w;
  Height_ = h;
  BytesPerPixel_ = float(bytesperpixel);
  BIASDOUT(D_DCAM, "Width, height:"<<Width_<<"x"<<Height_);
}

int VideoSource::SetColorModel(BIAS::ImageBase::EColorModel  mode)
{
  ColorMode_ = mode;
  if (ColorMode_ == ImageBase::CM_BGR || ColorMode_ == ImageBase::CM_RGB)
    ColorChannels_ = 3;
  if (ColorMode_ == ImageBase::CM_YUYV422
      || ColorMode_ == ImageBase::CM_YUYV
      || ColorMode_ == ImageBase::CM_UYVY422
      || ColorMode_ == ImageBase::CM_YUV420P) ColorChannels_ = 2;
  if (ColorMode_ == ImageBase::CM_Grey) ColorChannels_ = 1;
  if (ColorMode_ == ImageBase::CM_Bayer_RGGB
      || ColorMode_ == ImageBase::CM_Bayer_GBRG
      || ColorMode_ == ImageBase::CM_Bayer_GRBG
      || ColorMode_ == ImageBase::CM_Bayer_BGGR) ColorChannels_ = 1;
  if (ColorMode_ == ImageBase::CM_RGBA
      || ColorMode_ == ImageBase::CM_BGRA)
    ColorChannels_ = 4;
  return 0;
}

int VideoSource::InitImage(ImageBase &Image){
  if (!Image.IsEmpty())
    BIASERR("VideoSource::InitImage() should be called with uninitialized image");

  ImageBase::EStorageType st = ImageBase::ST_unsignedchar;

  if (BytesPerPixel_ == 2.0) {
    st = ImageBase::ST_unsignedshortint;
  }
  if (Image.GetStorageType() != ImageBase::ST_invalid){
    if (Image.GetStorageType() != st){
      BIASERR("invalid storage type");
      return -1;
    }
  }


  Image.Init(Width_, Height_, ColorChannels_, st);
  Image.SetColorModel(ColorMode_);
  return 0;
}


int VideoSource::PreGrab()
{
  if (! CompleteInitialized_) {
    BIASERR("VideoSource::PreGrab() : Object not completely initialized");
    return -1;
  }

  if (Active_) {
    BIASERR("VideoSource::PreGrab() : Object already active");
    return -1;
  }

  Active_ = true;

  return 0;
}

int VideoSource::PostGrab()
{
  Active_ = false;
  return 0;
}

// Virtual functions , they should not be called nor implemented
int VideoSource::OpenDevice()
{
    BIASERR("VideoSource_Base::OpenDevice() should not be called directly");
  return -1;
}

int VideoSource::OpenDevice(int device)
{
    BIASERR("VideoSource_Base::OpenDevice(int device) should not be called directly");
  return -1;
}

int VideoSource::OpenDevice(const char *f)
{
    BIASERR("VideoSource_Base::OpenDevice((const char *filename) should not be called directly");
  return -1;
}

int VideoSource::OpenDevice(string Prefix, string Postfix, int DigitCount, int PictureCount,int StartCount)
{
    BIASERR("VideoSource_Base::OpenDevice(string Prefix, string Postfix, int DigitCount, int PictureCount) should not be called directly");
  return -1;
}

int VideoSource::OpenDevice(const vector<string> &FileNames)
{
    BIASERR("VideoSource_Base::OpenDevice(vector<string> FileNames) should not be called directly");
  return -1;
}

int VideoSource::GetAllDevices(std::vector<std::string> &devices)
{
    BIASERR("VideoSource_Base::GetAllDevices(std::vector<std::string> &devices) should not be called directly");
  return -1;
}

int VideoSource::GetCapabilities(VideoSourceCapabilities &caps)
{
    BIASERR("VideoSource_Base::GetCapabilities() should not be called directly");
  return -1;
}

int VideoSource::GetCapabilities(const char *device, VideoSourceCapabilities &caps)
{
    BIASERR("VideoSource_Base::GetCapabilities() should not be called directly");
  return -1;
}


int VideoSource::CloseDevice()
{
    BIASERR("VideoSource_Base::CloseDevice() should not be called directly");
  return -1;
}

int VideoSource::GrabSingle(Camera <unsigned char> &image)
{
  BIASERR("VideoSource_Base::GrabSingle() should not be called, please overload");
  return -1;
}


int VideoSource::GrabSingle(Camera <float> &image)
{
  BIASERR("VideoSource_Base::GrabSingle() should not be called, please overload");
  return -1;
}

#ifdef BUILD_IMAGE_USHORT
int VideoSource::GrabSingle(Camera <unsigned short int> &image)
{
  BIASERR("VideoSource::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

#ifdef BUILD_IMAGE_UINT
int VideoSource::GrabSingle(Camera <unsigned int> &image)
{
  BIASERR("VideoSource::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

#ifdef BUILD_IMAGE_CHAR
int VideoSource::GrabSingle(Camera <char> &image)
{
  BIASERR("VideoSource_Base::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

#ifdef BUILD_IMAGE_SHORT
int VideoSource::GrabSingle(Camera <short int> &image)
{
  BIASERR("VideoSource::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

#ifdef BUILD_IMAGE_INT
int VideoSource::GrabSingle(Camera <int> &image)
{
  BIASERR("VideoSource_Base::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

#ifdef BUILD_IMAGE_DOUBLE
int VideoSource::GrabSingle(Camera <double> &image)
{
  BIASERR("VideoSource::GrabSingle() should not be called, please overload");
  return -1;
}
#endif

int VideoSource::AutoMode(int a, bool b)
{
  BIASERR("VideoSource_Base::AutoMode() should not be called, please overload");
  return -1;
}


unsigned int VideoSource::GetFeature(int a)
{
  BIASERR("VideoSource_Base::GetFeature() should not be called, please overload");
  return 0;
}

 int VideoSource::SetFeature(int a, unsigned int b)
{
  BIASERR("VideoSource_Base::setFeature() should not be called, please overload");
  return -1;
}


int VideoSource::SetShutter(float exptime)
{
  BIASERR("VideoSource_Base::SetShutter() should not be called, please overload");
  return -1;
}

int VideoSource::SetGain(float g)
{
  BIASERR("VideoSource_Base::SetGain() should not be called, please overload");
  return -1;
}

float VideoSource::GetGain()
{
  BIASERR("VideoSource_Base::GetGain() should not be called, please overload");
  return -1;
}

float VideoSource::GetShutter()
{
  BIASERR("VideoSource_Base::GetShutter() should not be called, please overload");
  return -1;
}
int VideoSource::OnePushAuto( int feature) {
  BIASERR("VideoSource_Base::OnePushAuto() should not be called,please overload");
  return -1;
}
int VideoSource::SetWhiteBalance(float rvalue,float bvalue){
  BIASERR("VideoSource_Base::SetWhiteBalance() should not be called,please overload");
  return -1;
}

int VideoSource::GetWhiteBalance(float &rvalue,float &bvalue){
  BIASERR("VideoSource_Base::SetWhiteBalance() should not be called,please overload");
  return -1;
}


int VideoSource::SoftwareWhiteBalance()
{
  float rGain=0.0, bGain=0.0;
  int widthHalf, heightHalf;
  BIAS::Camera<unsigned char> img;
  Image<unsigned char> rgbimg;

  if (!CompleteInitialized_)
  {
    OpenDevice();
  }

  InitImage(img);
  SetGain(0.0);
  while(GrabSingle(img)!=0) {
    // wait for other grab to complete
  }
  ImageConvert::ToRGB(img, rgbimg);
  widthHalf= img.GetWidth()/2;
  heightHalf = img.GetHeight()/2;

  unsigned char mean[3];
  BIASASSERT(img.GetWidth()>=20 && img.GetHeight()>=20);
  rgbimg.GetROI()->SetCorners(widthHalf-10, heightHalf-10,
                              widthHalf+10, heightHalf+10);
  rgbimg.GetMeanPixelValue(mean);
  int iterations = 0;

  while(iterations < 32)
  {
    BIASCDOUT(D_VS_WHITEB,"In videosource, SoftwarewhiteBalance pixel: "
              <<(int)mean[0]<<","<<(int)mean[1]<<","<<(int)mean[2]<<endl);
    if(mean[0] < mean[1])
      rGain +=1.0/32.0;
    else if(mean[0] > mean[1])
      rGain -=1.0/32.0;

    if(mean[2] < mean[1])
      bGain +=1.0/32.0;
    else if(mean[2] > mean[1])
      bGain -=1.0/32.0;
    BIASCDOUT(D_VS_WHITEB, "rGain,bGain :"<<rGain<<","<<bGain<<endl);
    SetWhiteBalance(rGain,bGain);
    GrabSingle(img);
    ImageConvert::ToRGB(img, rgbimg);
    rgbimg.SetROI(widthHalf-10, heightHalf-10, widthHalf+10, heightHalf+10);
    rgbimg.GetMeanPixelValue(mean);
    iterations++;
  }
  return 0;
}


int VideoSource::SetDirectToDisk(const std::string &filename)
{
  // open file
#ifndef WIN32
# ifdef __APPLE__
  DtDFd_ = open(filename.c_str(),O_WRONLY | O_CREAT , 0644);
# else // __APPLE__
  DtDFd_ = open(filename.c_str(),O_WRONLY | O_CREAT | O_DIRECT, 0644);
# endif // __APPLE__
  //DtDFd_ = basic_filebuf::open(filename.c_str(),O_WRONLY | O_CREAT );

  if (DtDFd_ <0) {
    BIASERR("Can not open/create file ");
    perror(filename.c_str());
    return -1;
  }

  fchmod(DtDFd_,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);

  ImageSize_ = Width_ * Height_ * ColorChannels_;
  ImageSize_ = (unsigned int)rint(float(ImageSize_) * BytesPerPixel_);
  unsigned int required_space = ImageSize_ +sizeof(VideoStream::VSImageHeader);
  // allocate buffer
  if (DtDBufferSize_ < required_space) {
    if (DtDBuffer_ != NULL) free(DtDBuffer_);
    DtDBufferSize_ = 512;
    while (DtDBufferSize_ < required_space) DtDBufferSize_ +=512;
    cout <<"New DtDBuffer_ with size "<<DtDBufferSize_ <<endl;
    char** bufferPointer = &DtDBuffer_;
#ifdef __APPLE__
      int r=0;
      *bufferPointer = (char *)valloc(DtDBufferSize_);
#else // __APPLE__
    int r = posix_memalign((void**)bufferPointer, 512, DtDBufferSize_);
#endif // __APPLE__
    if (DtDBuffer_ == NULL || r!=0) {
      BIASERR("Can not posix_memalign()"<<DtDBufferSize_<<" bytes");
      return -1;
    }
  }
  BIASDOUT(D_DTD, "Width, height, channelcount, BpP: "<<Width_<<"x"<<Height_
       <<", "<<ColorChannels_<<", "<<BytesPerPixel_);
  BIASDOUT(D_DTD, "ImageSize:     "<<ImageSize_);
  BIASDOUT(D_DTD, "HeaderSize:    "<<sizeof(VideoStream::VSImageHeader));
  BIASDOUT(D_DTD, "DtDBufferSize: "<<DtDBufferSize_);

  // set pointer for header and data
  DtDImageHeader_ = (VideoStream::VSImageHeader *)DtDBuffer_;
  DtDStartOfImage_ = DtDBuffer_ + sizeof(VideoStream::VSImageHeader);

  // prepare and write header
  VideoStream::VSHeader *header;
  cout <<"Size of header: "<<sizeof(VideoStream::VSHeader)<<endl;
  VideoStream::VSHeader** headerPointer = &header;
#ifdef __APPLE__
    int r=0;
    *headerPointer = (VideoStream::VSHeader*)valloc(sizeof(VideoStream::VSHeader));
#else // __APPLE__
    int r = posix_memalign((void**)headerPointer, 512, sizeof(VideoStream::VSHeader));
#endif // __APPLE__
  if (r!=0){
    BIASERR("error in poisx_memalign: "<<r);
    perror("posix_memalign");
    return -1;
  }
  header->Width = Width_;
  header->Height = Height_;
  header->ChannelCount = ColorChannels_;
  header->ColorModel = ColorMode_;
  header->BytesPerPixel = (int)BytesPerPixel_; // this is wrong for DV
  if (BytesPerPixel_ == 2.0)
    header->StorageType=ImageBase::ST_unsignedshortint;
  else header->StorageType = ImageBase::ST_unsignedchar;
  header->AlignedSize = DtDBufferSize_;

  int res = write(DtDFd_, header, sizeof(VideoStream::VSHeader));
  if (res <0) {
    BIASERR("Can not write to file with O_DIRECT: ");
    perror(filename.c_str());
    return -1;
  }


#else
  BIASERR("SetDirectToDisk() not implemented for WIN32");
#endif
  DirectToDisk_ = true;
  return 0;
}

int VideoSource::WriteDirect_(const unsigned char *data, const BIAS::UUID &uuid,
                  const long int &sec, const long int &usec)
{
#ifndef WIN32
  string uidstr;
  uuid.GetString(uidstr);
  DtDImageHeader_->tsec = sec;
  DtDImageHeader_->tusec = usec;
  memcpy(DtDImageHeader_->uuid, uidstr.c_str(), uidstr.length());
  memcpy(DtDStartOfImage_, data, ImageSize_);

  unsigned int chunksize = 20 * 1024;
  unsigned int numchunks = DtDBufferSize_ / chunksize;
  unsigned int lastchunksize = DtDBufferSize_ % chunksize;
  if (lastchunksize>0) numchunks++;

  cout <<"Chunk size: "<<chunksize<<endl;
  cout <<"Num chunks: "<<numchunks<<endl;
  cout <<"Last chunk: "<<lastchunksize<<endl;

  unsigned int currentchunksize;
  for (unsigned int c=0; c<numchunks; c++) {
    currentchunksize = c==(numchunks-1) ? lastchunksize :chunksize ;
    int res = write(DtDFd_, DtDBuffer_, currentchunksize);
    if (res <0) {
      BIASERR("Can not write to file with O_DIRECT: ");
      return -1;
    }
  }
#else
  BIASERR("WriteDirect() not implemented for WIN32");
#endif
  return 0;
}