VideoSource_uEye.cpp

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

Copyright (C) 2003-2015 (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 "VideoSource_uEye.hh"
#include <Base/Image/ImageIO.hh>
#include <stdio.h>
#include <Base/Image/ImageBase.hh>
#include <sstream>
#include <string>

using namespace BIAS;
using namespace std;

//#define USE_PROJECTOR_MODE

#ifdef USE_PROJECTOR_MODE
#  define UEYE_THREAD_DELAY 5000
#else
#  define UEYE_THREAD_DELAY 1000
#endif

std::vector<VideoSource_uEye::CuEye> VideoSource_uEye::cams_;

template <typename T> T number_from_string(std::string const & s)
{
  std::stringstream ss(s);
  T result;
  ss >> result;
  return result;
}

VideoSource_uEye::VideoSource_uEye() : grabThread_(this)
{
  // use default values for uEye camera
  SetSize(1280, 1024, 1);
  SetColorModel(ImageBase::CM_Bayer_RGGB);

  IsControllable_ = true;

  pixelClock_ = 0;
  pixelClockMin_ = pixelClockMax_ = pixelClockInc_ = pixelClockDefault_ = 0;

  imageBuffer_.resize(3, (char*)NULL);
  
  minContrast_ = 0;  // [?]
  maxContrast_ = 40;
  minGain_= 0;       // [dB]
  maxGain_ = 56;
  minShutter_ = 0;  // [us]
  maxShutter_ = 1000;

  camBufferId_ = 0;
  camBuffer_ = NULL;

  consBufferIdx_ = 0;
  prodBufferIdx_ = 0;

  bytesize_ = 0;

  triggerMode_ = IS_SET_TRIGGER_LO_HI;

  isMaster_ = false;
  sem_init(&prodsem_, true, 0);
  sem_init(&conssem_, true, 3);
}

VideoSource_uEye::~VideoSource_uEye()
{
}

int VideoSource_uEye::OpenDevice()
{
  return -1;
}

int VideoSource_uEye::OpenDevice(const char *resource)
{
#ifdef BIAS_DEBUG
  std::cout << "VideoSource_uEye::OpenDevice() : Open device " << resource << "..." << std::endl;
#endif
  //int pNumCameras = 0;
  int ret = -1;
  if (cams_.size()==0) {
    ScanBus();
  }
  bool found = false;
  long long deviceId = number_from_string<long long>(resource);

  for (unsigned int i=0;i<cams_.size();i++) {
    if (deviceId == cams_[i].deviceId) {
      cam_ = cams_[i];
      found = true;
      break;
    }
  }
  // Search for serial number
  if (!found) {
    for (unsigned int i=0;i<cams_.size();i++) {
      long long curId = number_from_string<long long>(cams_[i].serNo);
#ifdef BIAS_DEBUG
      std::cout << "- checking if camera " << cams_[i].serNo << " (#" << (curId % 10000)
                << ") has device ID " << deviceId << std::endl << std::flush;
#endif
      if (deviceId == curId || deviceId == (curId % 10000)) {
        cam_ = cams_[i];
#ifdef BIAS_DEBUG
        std::cout << "- found " << cam_.hCam << std::endl << std::flush;
#endif
        found = true;
        break;
      }
    }
  }
  if (found) {
    HIDS camid = (HIDS) ((INT)cam_.hCam | IS_USE_DEVICE_ID);
    ret = is_InitCamera (&camid, NULL);
    if (ret == IS_STARTER_FW_UPLOAD_NEEDED)
    {
      // Time for the firmware upload = 25 seconds by default
      INT nUploadTime = 25000;
      is_GetDuration (cam_.hCam, IS_STARTER_FW_UPLOAD, &nUploadTime);
      camid = (HIDS) ((INT)camid | IS_ALLOW_STARTER_FW_UPLOAD);
      ret = is_InitCamera (&camid, NULL);
    }
    cam_.hCam = camid;
    is_GetCameraInfo( cam_.hCam, &cam_.CamInfo);

    // Retrieve original image size
    is_GetSensorInfo( cam_.hCam, &cam_.SensorInfo);

    SetSize(cam_.SensorInfo.nMaxWidth, cam_.SensorInfo.nMaxHeight, 1 );

    /** @todo Not all RGB modes are tested yet! */
    if (GetColorModel() == ImageBase::CM_RGB) {
      ret = is_SetColorMode(cam_.hCam, IS_CM_RGB8_PACKED);
      if (ret != IS_SUCCESS) {
        return ret;
      }
    } else {
      ret = is_SetColorMode(cam_.hCam, IS_CM_SENSOR_RAW8);
      if (ret != IS_SUCCESS) {
        return ret;
      }
      switch (cam_.SensorInfo.nUpperLeftBayerPixel) {
      case BAYER_PIXEL_RED:
        SetColorModel(ImageBase::CM_Bayer_RGGB);
        break;
      case BAYER_PIXEL_GREEN:
        SetColorModel(ImageBase::CM_Bayer_GRBG);
        break;
      case BAYER_PIXEL_BLUE:
        SetColorModel(ImageBase::CM_Bayer_BGGR);
        break;
      default:
        SetColorModel(ImageBase::CM_Grey);
        break;
      }
    }

    UINT nRange[3];
    memset(nRange, 0, sizeof(UINT)*3);

    // Get pixel clock range
    ret = is_PixelClock(cam_.hCam, IS_PIXELCLOCK_CMD_GET_RANGE, (void*)nRange, sizeof(nRange));
    if (ret == IS_SUCCESS) {
      pixelClockMin_ = nRange[0];
      pixelClockMax_ = nRange[1];
      pixelClockInc_ = nRange[2];
    }
    ret = is_PixelClock(cam_.hCam, IS_PIXELCLOCK_CMD_GET_DEFAULT, (void*)&pixelClockDefault_, sizeof(UINT));
    if (ret == IS_SUCCESS) {
      if (pixelClock_ == 0) {
        pixelClock_ = pixelClockDefault_;
      }
      pixelClock_ = min ( pixelClockMax_, max ( pixelClockMin_, pixelClock_ ) );
      ret = is_PixelClock(cam_.hCam, IS_PIXELCLOCK_CMD_SET, (void*)&pixelClock_, sizeof(UINT));
    }
    ret = is_PixelClock(cam_.hCam, IS_PIXELCLOCK_CMD_GET, (void*)&pixelClock_, sizeof(UINT));
#ifdef BIAS_DEBUG
    std::cout << "- clocks : min. " << pixelClockMin_ << ", max. " << pixelClockMax_
              << ", def. " << pixelClockDefault_ << ", inc. " << pixelClockInc_
              << ", val. " << pixelClock_ << std::endl << std::flush;
#endif
  }

  double val;
  ret = is_Exposure(cam_.hCam, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MIN, &val, sizeof(double));
  minShutter_ = (float)val;
  ret = is_Exposure(cam_.hCam, IS_EXPOSURE_CMD_GET_EXPOSURE_RANGE_MAX, &val, sizeof(double));
  maxShutter_ = (float)val;

  /** @todo This depends only on exposure setting! */
  if (ret == IS_SUCCESS) {
    Active_ = true;
  } else {
    BIASERR("Failed to initialize camera!");
  }

  // Apply default settings
  double disable = 0.0;
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_FRAMERATE,    &disable, 0);
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_GAIN,         &disable, 0);
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_SHUTTER,      &disable, 0);
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_WHITEBALANCE, &disable, 0);

  INT nGamma = 160;
  INT nRet = is_Gamma(cam_.hCam, IS_GAMMA_CMD_SET, (void*) &nGamma, sizeof(nGamma));

  nRet = is_SetHWGainFactor (cam_.hCam, IS_SET_MASTER_GAIN_FACTOR, 100);
  if (nRet != IS_SUCCESS) { ret = 1; }
  nRet = is_SetHWGainFactor (cam_.hCam, IS_SET_RED_GAIN_FACTOR,    100); // 114
  if (nRet != IS_SUCCESS) { ret = 1; }
  nRet = is_SetHWGainFactor (cam_.hCam, IS_SET_GREEN_GAIN_FACTOR,  100);
  if (nRet != IS_SUCCESS) { ret = 1; }
  nRet = is_SetHWGainFactor (cam_.hCam, IS_SET_BLUE_GAIN_FACTOR,   100); // 229
  if (nRet != IS_SUCCESS) { ret = 1; }

#ifdef USE_PROJECTOR_MODE
  // Set trigger settings for projector
  long long curId = number_from_string<long long>(cam_.serNo);
  // HACK : master camera
  if (curId % 10000 == 9309) {
    isMaster_ = true;
    is_SetExternalTrigger(cam_.hCam, IS_SET_TRIGGER_SOFTWARE);
#ifdef BIAS_DEBUG
    std::cout << "- found TESTO master camera : Software trigger, flash pulse for"
              << " projector and slave camera sync" << std::endl << std::flush;
#endif
    IO_FLASH_PARAMS flashparam;
    flashparam.s32Delay = 0;
    flashparam.u32Duration = 0;
    is_IO(cam_.hCam, IS_IO_CMD_FLASH_SET_PARAMS, (void*) &flashparam, sizeof(IO_FLASH_PARAMS));
    unsigned int flashmode = IO_FLASH_MODE_TRIGGER_HI_ACTIVE;
    is_IO(cam_.hCam, IS_IO_CMD_FLASH_SET_MODE, (void*) &flashmode, sizeof(flashmode));
  }
  // slave camera
  else if (curId % 10000 == 6321) {
#ifdef BIAS_DEBUG
    std::cout << "- found TESTO slave camera : Triggered by flash signal of"
              << " master camera" << std::endl << std::flush;
#endif
    is_SetExternalTrigger(cam_.hCam, IS_SET_TRIGGER_LO_HI);
  }
#endif

  return ret;
}

int VideoSource_uEye::CloseDevice()
{
  int ret = is_ExitCamera(cam_.hCam);
  Active_ = false;
  return ret;
}

void VideoSource_uEye::SetExternalTrigger(bool trigger)
{
  VideoSource::SetExternalTrigger(trigger);
  if (trigger) {
    is_SetExternalTrigger(cam_.hCam, triggerMode_);
  } else {
    is_SetExternalTrigger(cam_.hCam, IS_SET_TRIGGER_OFF);
  }
}

void VideoSource_uEye::SetExternalTriggerMode(unsigned int mode) {
  switch (mode) {
  case 0:
    triggerMode_ = IS_SET_TRIGGER_LO_HI;
    break;
  case 1:
    triggerMode_ = IS_SET_TRIGGER_HI_LO;
    break;
  default:
    BIASERR("Trigger mode " << mode << " is not supported!");
    break;
  }
}

void VideoSource_uEye::SetExternalTriggerDelay(unsigned int delay)
{
  int ret = is_SetTriggerDelay (cam_.hCam, delay);
  if (ret != IS_SUCCESS) {
    BIASERR("Valid delay range is [" << is_SetTriggerDelay(cam_.hCam, IS_GET_MIN_TRIGGER_DELAY)
            << ", " << is_SetTriggerDelay(cam_.hCam, IS_GET_MAX_TRIGGER_DELAY)
            << "] with step " << is_SetTriggerDelay(cam_.hCam, IS_GET_TRIGGER_DELAY_GRANULARITY));
  }
}

int VideoSource_uEye::SetShutter(float exptime)
{
  return SetExposure(exptime);
}

float VideoSource_uEye::GetShutter()
{
  return GetExposure();
}

int VideoSource_uEye::SetExposure(float exptime)
{
  double val = (double)exptime;
  return is_Exposure(cam_.hCam, IS_EXPOSURE_CMD_SET_EXPOSURE, (void*)&val, sizeof(double));
}

float VideoSource_uEye::GetExposure()
{
  double val;
  is_Exposure(cam_.hCam, IS_EXPOSURE_CMD_GET_EXPOSURE, (void*)&val, sizeof(double));
  return (float)val;
}

bool VideoSource_uEye::HasControlShutter()
{
  return true;
}

bool VideoSource_uEye::HasControlGain()
{
  return false; // true;
}

void VideoSource_uEye::SetAutoGain(bool autoGain)
{
  double dEnable = 0.0;
  if (autoGain) {
    dEnable = 1.0;
  }
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_GAIN, &dEnable, 0);
  double soll = 128;
  is_SetAutoParameter (cam_.hCam, IS_SET_AUTO_REFERENCE, &soll, 0);
}

bool VideoSource_uEye::GetAutoGain() {
  return false;
}

int VideoSource_uEye::SetGain(float g)
{
  //double gain = (double)g;
  //ret = is_SetAutoParameter (cam_.hCam, IS_SET_AUTO_REFERENCE, &gain, 0);
  return 0;
}

float VideoSource_uEye::GetGain()
{
  float gain = 0.0f;
  //if (m_bIsInited)
  //  gain = (float)m_ueye.GetGain();
  //else
  //  gain = 0.0f;
  return gain;
}

bool VideoSource_uEye::HasControlWhiteBalance() {
  return true;
}

int VideoSource_uEye::SetWhiteBalance(float rvalue,float bvalue) {
  float bmin,bmax;
  GetWhiteBalanceRange(bmin,bmax);
  rvalue += 0.5f; // now in 0..1
  rvalue = (1.0f-rvalue) * bmin + rvalue * bmax;
  is_SetHWGainFactor (cam_.hCam, IS_SET_RED_GAIN_FACTOR, (int)rvalue);
  //is_SetHWGainFactor (cam_.hCam, IS_SET_GREEN_GAIN_FACTOR, 100);
  bvalue += 0.5f; // now in 0..1
  bvalue = (1.0f-bvalue) * bmin + bvalue * bmax;
  is_SetHWGainFactor (cam_.hCam, IS_SET_BLUE_GAIN_FACTOR, (int)bvalue);
  return 0;
}

int VideoSource_uEye::GetWhiteBalance(float &rvalue,float &bvalue) {
  rvalue = (float)is_SetHWGainFactor (cam_.hCam, IS_GET_RED_GAIN_FACTOR, 0);
  bvalue = (float)is_SetHWGainFactor (cam_.hCam, IS_GET_BLUE_GAIN_FACTOR, 0);
  return 0;
}

void VideoSource_uEye::OnePushWhiteBalance() {
  double enable = 1.0;
  is_SetAutoParameter(cam_.hCam, IS_SET_ENABLE_AUTO_WHITEBALANCE, &enable, 0);
  is_SetAutoParameter(cam_.hCam, IS_SET_AUTO_WB_ONCE, &enable, 0);
}

void VideoSource_uEye::GetWhiteBalanceRange(float &bmin, float &bmax)
{
  bmin = (float)is_SetHWGainFactor (cam_.hCam, IS_INQUIRE_RED_GAIN_FACTOR, 0);
  bmax = (float)is_SetHWGainFactor (cam_.hCam, IS_INQUIRE_RED_GAIN_FACTOR, 100);
}

bool VideoSource_uEye::HasControlBrightness()
{
  return true;
}

int VideoSource_uEye::SetBrightness(float bright)
{
  int nGamma = (int)bright;
  int ret = is_Gamma(cam_.hCam, IS_GAMMA_CMD_SET, (void*) &nGamma, sizeof(int));
  return ret;
}

float VideoSource_uEye::GetBrightness()
{
  int nGamma;
  is_Gamma(cam_.hCam, IS_GAMMA_CMD_GET, (void*) &nGamma, sizeof(nGamma));
  return (float)nGamma;
}

void VideoSource_uEye::GetBrightnessRange(float &min, float &max)
{
  min = 100.0f; max = 260.0f;
}

bool VideoSource_uEye::GetAutoBrightness()
{
  if (IS_SET_HW_GAMMA_ON == is_SetHardwareGamma(cam_.hCam, IS_GET_HW_SUPPORTED_GAMMA)) {
    return ( IS_SET_HW_GAMMA_ON == is_SetHardwareGamma (cam_.hCam, IS_GET_HW_GAMMA) );
  }
  return false;
}

void VideoSource_uEye::SetAutoBrightness(bool autoBrightness)
{
  if (IS_SET_HW_GAMMA_ON == is_SetHardwareGamma(cam_.hCam, IS_GET_HW_SUPPORTED_GAMMA)) {
    if (autoBrightness) {
      is_SetHardwareGamma (cam_.hCam, IS_SET_HW_GAMMA_ON);
    } else {
      is_SetHardwareGamma (cam_.hCam, IS_SET_HW_GAMMA_OFF);
    }
  }
}

int VideoSource_uEye::GrabSingle(BIAS::Camera<unsigned char> &image)
{
#ifdef USE_PROJECTOR_MODE
  if (isMaster_) {
    if (is_FreezeVideo(cam_.hCam, IS_DONT_WAIT) != 0) {
      BIASWARN("Master camera soft trigger failed!");
    }
    biassleep(2); // wait for 2 sec to prevent hardware damage
  }
#endif
  sem_wait(&prodsem_);
  image.CopyIn_NoInit( imageBuffer_[consBufferIdx_] );
  consBufferIdx_ = (consBufferIdx_ + 1) % imageBuffer_.size();
  sem_post(&conssem_);
  return 0;
}

int VideoSource_uEye::InitImage(BIAS::ImageBase &Image)
{
  if (!Image.IsEmpty()) {
    Image.Release();
  }
  Image.Init( GetWidth(), GetHeight(), 1, ImageBase::ST_unsignedchar);
  Image.SetColorModel(GetColorModel());
  return 0;
}

int VideoSource_uEye::SetEdgeEnhancement(int mode)
{
  switch (mode) {
    case 0:  mode = IS_EDGE_EN_DISABLE; break;
    case 1:  mode = IS_EDGE_EN_WEAK;    break;
    case 2:  mode = IS_EDGE_EN_STRONG;  break;
    default: mode = IS_EDGE_EN_DISABLE;
  }
  return 0; // m_ueye.SetEdgeEnhancement(mode);
}

int VideoSource_uEye::PreGrab()
{
  bytesize_ = GetWidth() * GetHeight();
  camBuffer_ = new char[bytesize_];
  is_SetAllocatedImageMem(cam_.hCam, GetWidth(), GetHeight(), 8, camBuffer_, &camBufferId_);
  is_SetImageMem(cam_.hCam, camBuffer_, camBufferId_);
  for (unsigned int i = 0; i < imageBuffer_.size(); i++) {
    imageBuffer_[i] = new char[ bytesize_ ];
  }
#ifdef WIN32
  hEvent_ = CreateEvent(NULL, FALSE, FALSE, NULL);
  is_InitEvent(cam_.hCam, hEvent_, IS_SET_EVENT_FRAME);
  is_EnableEvent(cam_.hCam, IS_SET_EVENT_FRAME);
#else
  is_EnableEvent(cam_.hCam, IS_SET_EVENT_FRAME);
#endif
  grabThread_.start();
  if (is_CaptureVideo(cam_.hCam, IS_WAIT) != 0) {
    BIASERR("Failed to start capture!");
  }
  return 0;
}

int VideoSource_uEye::PostGrab()
{
  grabThread_.stop();
#ifdef WIN32
  is_DisableEvent(cam_.hCam, IS_SET_EVENT_FRAME);
  is_ExitEvent(cam_.hCam, IS_SET_EVENT_FRAME);
  CloseHandle(hEvent_);
#else
  is_DisableEvent(cam_.hCam, IS_SET_EVENT_FRAME);
#endif
  if (is_CaptureVideo(cam_.hCam, IS_GET_LIVE) != 0) {
    if (is_StopLiveVideo(cam_.hCam, IS_FORCE_VIDEO_STOP) != 0) {
      BIASERR("Failed to stop capture!");
    }
  }
  delete[] camBuffer_;
  camBuffer_ = NULL;
  for (unsigned int i = 0; i <imageBuffer_.size(); i++) {
    delete[] imageBuffer_[i];
    imageBuffer_[i] = NULL;
  }
  return 0;
}

int VideoSource_uEye::GetPixelClock_() const
{
  return pixelClock_;
}

void VideoSource_uEye::SetPixelClock_(int value)
{
  pixelClock_ = value;
}

bool VideoSource_uEye::
sortBySerial_(const VideoSource_uEye::CuEye a, const VideoSource_uEye::CuEye b)
{
  return number_from_string<long long>(a.serNo) > number_from_string<long long>(b.serNo);
}

int VideoSource_uEye::ScanBus()
{
#ifdef BIAS_DEBUG
  std::cout << "VideoSource_uEye::ScanBus() : Retrieving cameras..." << std::endl;
#endif
  cams_.clear();
  int nCameraCount = 0;
  if (is_GetNumberOfCameras(&nCameraCount) == IS_SUCCESS) {
    PUEYE_CAMERA_LIST pucl = (PUEYE_CAMERA_LIST)new char[sizeof(DWORD) + nCameraCount * sizeof(UEYE_CAMERA_INFO)];
    pucl->dwCount = nCameraCount;
    if (is_GetCameraList(pucl) == IS_SUCCESS) {
      for (int i = 0; i < nCameraCount; i++) {
        CuEye cam;
        // Type = 0 -> USB, Type = 1 -> ETH
        int Type = (pucl->uci[i].dwDeviceID >= 1000);
        // If ETH camera
        if (Type == 1) {
          if (pucl->uci[i].dwInUse == 0) {
            // Check if starter firmware is compatible to the driver (only SE)
            if ((pucl->uci[i].dwStatus & DEVSTS_INCLUDED_STARTER_FIRMWARE_INCOMPATIBLE) != 0) {
              cam.available = true;
            } else {
              cam.available = true;
            }
          } else {
            cam.available = false;
          }
        }
        // If USB camera
        else if (Type == 0) {
          bool FirmwareDownloadSupported = (pucl->uci[i].dwStatus & FIRMWARE_DOWNLOAD_NOT_SUPPORTED) == 0;
          bool InterfaceSpeedSupported = (pucl->uci[i].dwStatus & INTERFACE_SPEED_NOT_SUPPORTED) == 0;
          // If device is not used
          if(pucl->uci[i].dwInUse == 0) {
            if(FirmwareDownloadSupported && InterfaceSpeedSupported) {
              cam.available = true;
            } else {
              cam.available = false;
            }
          } else {
            cam.available = false;
          }
        }
        cam.camId = pucl->uci[i].dwCameraID;
        cam.deviceId = pucl->uci[i].dwDeviceID;
        cam.model = pucl->uci[i].Model;
        cam.serNo = pucl->uci[i].SerNo;
        cam.name = cam.serNo; // QString::number(cam.deviceId);
        cam.hCam = cam.deviceId;
#ifdef BIAS_DEBUG
        std::cout << "- found camera " << cam.model << " "<< cam.serNo << " with ID "
                  << cam.deviceId << " " << cam.camId << std::endl;
#endif
        cams_.push_back(cam);
      }
    } else {
      BIASERR("Failed to retrieve camera list!");
    }
    // sort cameras according to their serial number
    std::sort(cams_.begin(), cams_.end(), sortBySerial_);
    delete pucl;
  } else {
    BIASERR("Failed to retrieve number of cameras!");
  }
  return nCameraCount;
}

std::vector<std::string> VideoSource_uEye::GetDevices()
{
  if (cams_.empty()) {
    int numCams = ScanBus();
    if (numCams == 0) {
      BIASERR("No uEye cameras found!");
    }
  }
  std::vector<std::string> ret;
  for (unsigned int i=0;i<cams_.size();i++) {
    ret.push_back(cams_[i].name);
  }
  return ret;
}

VideoSource_uEye::UeyeGrabThread::UeyeGrabThread(VideoSource_uEye *parent)
{
  stopRequest_ = false;
  isRunning_ = false;
  parent_ = parent;
  thread_= new pthread_t;
}

VideoSource_uEye::UeyeGrabThread::~UeyeGrabThread()
{
  if (isRunning()) {
    stop();
  }
  delete thread_;
}

void VideoSource_uEye::UeyeGrabThread::start()
{
  isRunning_ = true;
  stopRequest_= false;
  pthread_create(thread_, NULL, VideoSource_uEye::UeyeGrabThread::run, (void*)this);
}

void VideoSource_uEye::UeyeGrabThread::stop()
{
  stopRequest_ = true;
  sem_post(&parent_->conssem_);
  pthread_join(*thread_, NULL);
  isRunning_ = false;
}

bool VideoSource_uEye::UeyeGrabThread::isRunning()
{
  return isRunning_;
}

void* VideoSource_uEye::UeyeGrabThread::run(void *parent)
{
  VideoSource_uEye::UeyeGrabThread *p = (VideoSource_uEye::UeyeGrabThread *)parent;
  VideoSource_uEye *cam = p->parent_;
  while (!p->stopRequest_) {
    bool grabOk = false;
#ifdef WIN32
    DWORD dwRet = WaitForSingleObject(parent_->hEvent_, UEYE_THREAD_DELAY);
    if (dwRet == WAIT_TIMEOUT) {
      BIASWARN("Timeout");
    } else if (dwRet == WAIT_OBJECT_0) {
      grabOk = true;
    }
#else
    INT nRet = is_WaitEvent(cam->cam_.hCam, IS_SET_EVENT_FRAME, UEYE_THREAD_DELAY);
    if (nRet == IS_TIMED_OUT) {
      BIASWARN("Timeout");
      //is_ForceTrigger(cam->cam_.hCam);
    } else if (nRet == IS_SUCCESS) {
      grabOk = true;
    }
#endif
    grabOk = true; // HACK : grab even when timeout occurred
    if (grabOk) {
      sem_wait(&cam->conssem_);
      memcpy(cam->imageBuffer_[cam->prodBufferIdx_], cam->camBuffer_, cam->bytesize_);
      cam->prodBufferIdx_ = (cam->prodBufferIdx_ + 1) % cam->imageBuffer_.size();
      sem_post(&cam->prodsem_);
    }
  }
  return NULL;
}