VideoSource_Net.cpp

#include <Base/Common/W32Compat.hh>

#ifdef WIN32
#  pragma warning(disable: 4996) // vs8
#endif //WIN32

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

#include <string>
#include <sstream>
#include <iostream>

#include <Image/Camera.hh>
#include "VideoSource_Net.hh"
#include <limits.h>

using namespace BIAS;
using namespace std;

VideoSource_Net::VideoSource_Net(bool threaded) : 
                 VideoSource(), client_(threaded) {

  ColorChannels_ = 3; // fake
  ColorMode_ = ImageBase::CM_RGB; // fake
#ifdef BIAS_HAVE_LIBJPEG
  Decompressor_.Init();
#endif //BIAS_HAVE_LIBJPEG
  pImgBuffer_ = new std::stringstream;
  count_=0;
  UseTCP_=true;
  if (!threaded) client_.SetKeepAll(true);
} 


int VideoSource_Net::OpenDevice(int /*port*/) 
{
  BIASERR("no UDP comm yet");
  return 0;
}

int VideoSource_Net::OpenDevice(const char* serverName)
{
  return OpenDevice(serverName, D_CS_DEFAULT_PORT);
}
                                 
int VideoSource_Net::OpenDevice(const std::string &serverName, 
                                int port) 
{
  client_.SetVerbose(true);
  if (client_.ConnectServer(serverName,port,UINT_MAX)!=0) {    
    return -1;
  }
  client_.RegisterMsg("BIAS_IMAGE",CS_BINARY);
  client_.RegisterMsg("JPEG_IMAGE",CS_BINARY);

  BIAS::ImageBase img;
  GrabSingle(img);
  
  Width_=img.GetWidth();
  Height_=img.GetHeight();
  ColorChannels_=img.GetChannelCount();
  BytesPerPixel_ = float( img.GetDepth()*img.GetChannelCount() );
  return 0;
}


int VideoSource_Net::PreGrab() 
{
 
  return 0;

} // PreGrab

int VideoSource_Net::GrabSingle(BIAS::Camera <unsigned char> &image)
{
  ImageBase imgBase;
  int res=GrabSingle(imgBase);
  if (imgBase.GetStorageType()==ImageBase::ST_unsignedchar)
    image=BIAS::Camera <unsigned char>(imgBase);
  else {
    BIASERR("received image is not unsigned char");
    return -2;
  }
  image.ParseMetaData();
  return res;
}

int VideoSource_Net::GrabSingle(BIAS::ImageBase &image) 
{
  bool haveJpeg=false;
  if (!UseTCP_) {    
    BIASERR("UDP not yet");
    return -1;
  }
  static std::vector<char> data;
  int res=-1;
  while (res!=0) {
    res=client_.GetData("BIAS_IMAGE",data);
    if (res!=0) {
      res=client_.GetData("JPEG_IMAGE",data);
      if (res==0)
        haveJpeg=true;
    }
#ifdef WIN32
    Sleep(1);
#else
    usleep(10);
#endif
  }    
  if (!haveJpeg) {
    pImgBuffer_->rdbuf()->sputn(&data[0],data.size());
    
    // this does the trick
    *pImgBuffer_>>image;    
    
    count_++;
    if (count_==20) { 
      count_=0;
      ////// free some memory
      // save unprocessed data
      string dummy(pImgBuffer_->rdbuf()->in_avail(),0); 
      pImgBuffer_->rdbuf()->sgetn(&dummy[0],pImgBuffer_->rdbuf()->in_avail());
      // delete and reallocate
      delete pImgBuffer_;
      pImgBuffer_ = new stringstream;
      pImgBuffer_->rdbuf()->sputn(&dummy[0],dummy.length());
    }
  } else {
#ifdef BIAS_HAVE_LIBJPEG
    //received image is jpeg-compressed
    Decompressor_.SetCompressedData((void *)&(data[0]), 
                                    (long) data.size());
    if (Decompressor_.Decompress(jpegImg_) < 0) {
      BIASERR("Decompression failed!");
      return -1;
    }
    if (image.SamePixelAndChannelCount(jpegImg_))
      image.CopyIn_NoInit(jpegImg_.GetImageData());
    else 
      image=jpegImg_;
#endif //BIAS_HAVE_LIBJPEG
  }

  return 0;
} // GrabSingle


int VideoSource_Net::PostGrab() 
{
  return 0;
} 


int VideoSource_Net::CloseDevice() {
#  ifdef BIAS_HAVE_LIBJPEG
    Decompressor_.Release();
#  endif //BIAS_HAVE_LIBJPEG

  return 0;
} // CloseDevice