prip/include/IPCamera.h

Go to the documentation of this file.

#ifndef PRIP_IPCAMERA_H
#define PRIP_IPCAMERA_H

#include "prip.h"
#include "Util.h"
#include <pinet.h>
#include <string>
#include <vector>
#include <sstream>
#include <iostream>

namespace prip {

class MJPEGStream : public pt::thread
{
public:
   MJPEGStream(pt::instm& stream) : pt::thread(false),
      mStream(stream), mCancel(false),mFrameNr(0)
   {}

   virtual ~MJPEGStream(void)
   {
      cancel();
      waitfor();
   }

   void cancel(void)
   {
      mCancel = true;
   }

   std::string getJPEG(void) const
   {
      pt::scopelock x(mMutexJPEG);
      return currentJPEG;
   }

   int getFrameNr(void) const
   {
      pt::scopelock x(mMutexJPEG);
      return mFrameNr;
   }

   void setFrameNr(int newFrameNr = 0)
   {
      pt::scopelock x(mMutexJPEG);
      mFrameNr = newFrameNr;
   }

   void resetFrameNr(void)
   {
      setFrameNr();
   }


protected:
   virtual void execute(void)
   {
      std::stringstream oss;
      bool started(false);

      while (!mStream.get_eof() && !mCancel)
      {
         unsigned char cur = mStream.get();
         if (mStream.get_eof()) std::clog << "EOF!" << std::endl;
         unsigned char preview = mStream.preview();
         if (mStream.get_eof()) std::clog << "EOF!" << std::endl;


         if (cur==0xFF)
         {
            if (started && (preview == 0xD9))
            {
               
               started = false;
               oss.put(cur);
               

               cur = mStream.get();
               oss.put(cur);
               putJPEG(oss.str());

               // clear ostringstream
               oss.seekp(0);
            } else if (!started && ( preview == 0xD8))
            {
               started = true;
            }
            
         }

         if (started) 
         {
            oss.put(cur);
            
         }
      }
   }

   
   virtual void cleanup(void)
   {}
   
   pt::instm&  mStream;
   bool     mCancel;

   std::string currentJPEG;

private:
   mutable pt::mutex mMutexJPEG;
   int mFrameNr;
   
   void putJPEG(const std::string& newJPEG)
   {  
      pt::scopelock x(mMutexJPEG);
      currentJPEG = newJPEG;
      std::clog << "retrieved new image frame-Nr"<<mFrameNr+1 << std::endl;
      mFrameNr++;
   }
};

class IPCamera
{
public:
   
   IPCamera(std::string address, int port, std::string username="", 
      std::string password="") : mAddress(address), mPort(port), mUsername(username),
      mPassword(password), mClient(mAddress.c_str(),mPort)
   {}

   
   IPCamera(const IPCamera& other) : 
   mAddress(other.mAddress), mPort(other.mPort), mUsername(other.mUsername),
      mPassword(other.mPassword), mClient(mAddress.c_str(),mPort)
   {
   }

   IPCamera& operator=(const IPCamera& other) 
   {
      if (&other==this)
         return *this;

      mAddress = other.mAddress;
      mPort = other.mPort;
      mUsername = other.mUsername;
      mPassword = other.mPassword;

      mClient.set_port(mPort);
      mClient.set_host(mAddress.c_str());
   }

   virtual ~IPCamera(void);


   void post(std::string site, 
      const std::vector<std::string>& parameters, 
      const std::vector<std::string>& values,
      bool close=false);

   void post(std::string site, std::string parameter, std::string value, bool close = false)
   {
      std::vector<std::string> ps(1), v(1);
      ps.push_back(parameter);
      v.push_back(value);
      post(site,ps,v,close);
   }
   
   void get(const std::string site, bool close=false);
   
   void setUsername(const std::string username) {mUsername = username;}

   void setPassword(const std::string password) {mPassword = password;}


   pt::ipstream& getResult(void) {return mClient;}

   virtual std::string getImage(void) = 0;

private:
   IPCamera(void) {}
   
   std::string    mAddress;
   int            mPort;

   std::string    mUsername;
   std::string    mPassword;

   std::string    mCurrentImg;

protected:
   pt::ipstream   mClient;

};

typedef std::vector<unsigned char> ViscaCommand;

class ViscaControl
{
public:
   

   static const int Head = 0x81;
   
   static const int Term = 0xFF;

   static const bool ON = true;
   static const bool OFF = false;

   enum Type {TCommand = 0x01, TInquiry = 0x09};

   enum Category {CInterface = 0x00, CCamera = 0x04, CPanTilt = 0x06};

   void CAM_Power(bool on);

   void CAM_ZoomStop(void);

   void CAM_ZoomIn(int speed = -1);

   void CAM_ZoomOut(int speed = -1);

   void CAM_ZoomTo(int pos);


   void CAM_FocusStop(void);

   void CAM_FocusFar(int speed = -1);

   void CAM_FocusNear(int speed = -1);

   bool CAM_FocusDirect(int pos);
   
   enum FocusMode{
      FMManual,

      FMAuto,

      FMSwitch,
      
      FMOnePushTrigger,

      FMInfinity,

      FMNearLimit
   };

   bool CAM_FocusMode(FocusMode mode, int limit=0);

   enum AFSensitivity {
      AFSNormal=0x02, 
      
      AFSLow=0x03    
   };

   void CAM_AFSensitivity(AFSensitivity mode);

   enum AFMode {
      AFNormal, 
      AFInterval, 
      AFZoomTrigger,
      AFActiveInterval};

   void CAM_AFMode(AFMode mode, int time, int interval);

   
   enum InitializationMode {
      IMLens = 0x01, 
      IMCompScan = 0x02};
   
   void CAM_Initialize(InitializationMode mode);


   enum WBMode {
      WBAuto=0,         

      WBIndoor,         
      
      WBOutdoor,        
      
      WBOnePushWB,      
      
      WBATW,            
      
      WBManual,         
      
      WBOnePushTrigger  
   };

   void CAM_WB(WBMode mode);

   enum GainMode {GainReset = 0, GainUp = 0x02, GainDown=0x03, GainDirect = 0xFF};
   
   void CAM_RGain(GainMode mode, int gain);

   void CAM_BGain(GainMode mode, int gain);


   enum AEMode {
      AEAuto=0x00,

      AEManual=0x03,

      /*Shutter Priority Automatic Exposure Mode - Variable Shutter Speed, Auto Iris and Gain (1/1 to 1/10000 sec, 22 steps, std. shutter: 16 setps, slow shutter, 6 steps)
       *
       * The shutter speed can be set freeely by the user to a 
       * total of 22 steps - 16 high speed and 6 low speeds.
       * when the slow shutter is set, the speed can be 1/30, 1/15,
       * 1/8, or 1/4 sec. The picture output is read at a normal rate from
       * the memory. The memory is updated at a low rate from the CCD.
       * AF capability is low. In high speed mode, the shutter speed
       * can be set up to 1/10000 sec. The iris and gain are set automatically,
       * according to the brightness
       */
      AEShutter=0x0A,

      AEIris=0x0B,

      AEBright=0x0D
   };
   
   void CAM_AE(AEMode mode);
   
   
   void CAM_AutoSlowShutter(bool on);

   enum ChangeParam
   {
      CPReset = 0x00,
      CPUp = 0x02,
      CPDown = 0x03,
      CPDirect = 0xFF
   };

   void CAM_Shutter(ChangeParam cp, int data=0);

   void CAM_Iris(ChangeParam cp, int data=0);

   void CAM_Gain(ChangeParam cp, int pos=0);

   void CAM_Bright(ChangeParam cp, int data=0);

   void CAM_ExpComp(bool on);

   void CAM_SetExpComp(ChangeParam cp, int data=0);

   void CAM_BackLight(bool on);

   void CAM_SpotAE(bool on);

   bool CAM_SetSpotAE(int X, int Y);

   void CAM_Aperture(ChangeParam cp, int data=0);

   void CAM_LR_Reverse(bool on);

   void CAM_Freeze(bool on);

   enum PictureEffect {
      PEOff = 0x02,

      PENegArt = 0x03,

      PEMonochrome = 0x04
   };

   void CAM_PictureEffect(PictureEffect pe);

   void CAM_ICR(bool on);

   void CAM_AutoICR(bool on);

   void CAM_Stabilizer(bool on);

   bool CAM_Memory_Reset(int presetPosition);
   bool CAM_Memory_Set(int presetPosition);
   bool CAM_Memory_Recall(int presetPosition);

   void CAM_CUSTOM_Set(void);
   void CAM_CUSTOM_Reset(void);


   void PanTiltAutoSpeed(bool on);

   enum Direction {Up, Down, Left, Right, UpLeft, UpRight, DownLeft, DownRight, Stop, Home};

   void PanTiltDrive(Direction dir, int panSpeed=0xFF, int tiltSpeed=0xFF);

   void PanTiltAbsolutePosition(int panSpeed, int tiltSpeed, int panPos, int tiltPos);

   void PanTiltRelativePosition(int panSpeed, int tiltSpeed, int panPos, int tiltPos);

   bool PanTiltGotoPreset(int pos, int panSpeed, int tiltSpeed);


   static std::string ViscaToString(const ViscaCommand& vc)
   {
      std::ostringstream cmd;
      
      for (ViscaCommand::const_iterator it = vc.begin(); it!=vc.end(); it++)
      {
         cmd << std::hex;
         cmd.width(2);
         cmd.fill('0');
         cmd << static_cast<short>(*it);
      }
      return cmd.str();
   }

   virtual std::ostream& operator<<(std::ostream& out)
   {
      out << ViscaToString(mCmd);
      return out;
   }

protected:
   ViscaCommand mCmd;
   
   virtual void initCommand(Type t, Category c)
   {
      mCmd.clear();
      mCmd.push_back(Head);
      mCmd.push_back(t);
      mCmd.push_back(c);
   }

   virtual void termCommand()
   {
      mCmd.push_back(0xFF);
   }

   virtual void sendCommand()
   {
      std::cout << ViscaToString(mCmd) << std::endl;
   }

};


class ViscaIP : public IPCamera, public ViscaControl
{

public:
   ViscaIP(std::string address, int port, std::string cgiscript="/command/ptzf.cgi",std::string imgpath="/.jpg",std::string streampath="/mjpeg",
      std::string username="", std::string password="") : 
   IPCamera(address,port,username,password), mSite(cgiscript),mImgPath(imgpath),mStreamPath(streampath),mStreamHandler(mClient)
   {}
   

   std::string getImage(void)
   {
      get(mImgPath,false);
      std::cout << mClient.get_status() << std::endl;
      while (!mClient.get_eof())
      {
         std::cout << mClient.get_status() << std::endl;
         const int bufferSize = 100*1024;
         char buffer[bufferSize];
         int size = mClient.read(buffer,bufferSize);
         std::ostringstream oss;
         oss.write(buffer,size);
         std::cout << size << ": "<< std::endl;
         std::cout << oss.str() << std::endl << "----------" << std::endl << std::endl;
      } 
      std::cout << mClient.get_status() << std::endl;
      std::cout << "done";
      mClient.close();
      return "";
   }

   std::string getNextImage(void)
   {
      if (mClient.get_active()!=true)
         startMJPEGStream();

      std::string jpeg;
      do
      {
         jpeg = mStreamHandler.getJPEG();
         if (jpeg=="") pt::psleep(100);
         if (mStreamHandler.get_running()!=true) break;
      } while (jpeg=="");

      return jpeg;
   }

   virtual void startMJPEGStream(void)
   {
      get(mStreamPath,false);
      mStreamHandler.start();
   }

   virtual void stopMJPEGStream(void)
   {
      mStreamHandler.cancel();
      mStreamHandler.waitfor();
      mClient.close();
   }



protected:
   virtual void sendCommand(void)
   {
      std::cout << ViscaToString(mCmd) << std::endl;
      post(mSite,"VISCA",ViscaToString(mCmd),true);
   }

   MJPEGStream mStreamHandler;

private:
   std::string mSite;
   std::string mImgPath;
   std::string mStreamPath;

};

}

#endif

---