ServerFrameGrabberDual.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
 * SPDX-FileCopyrightText: 2006-2010 RobotCub Consortium
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef YARP_DEV_SERVERGRABBER_H
#define YARP_DEV_SERVERGRABBER_H
 
#include <cstdio>
 
 
#include <yarp/dev/IFrameGrabberImage.h>
#include <yarp/dev/AudioGrabberInterfaces.h>
#include <yarp/dev/AudioVisualInterfaces.h>
#include <yarp/dev/ServiceInterfaces.h>
#include <yarp/dev/PolyDriver.h>
#include <yarp/dev/IPreciselyTimed.h>
#include <yarp/os/BufferedPort.h>
#include <yarp/os/Time.h>
#include <yarp/os/Network.h>
#include <yarp/os/PeriodicThread.h>
#include <yarp/os/Vocab.h>
#include <yarp/os/Bottle.h>
#include <yarp/dev/IWrapper.h>
#include <yarp/dev/IMultipleWrapper.h>
 
#include <yarp/proto/framegrabber/FrameGrabberControls_Responder.h>
#include <yarp/proto/framegrabber/FrameGrabberControlsDC1394_Responder.h>
#include <yarp/proto/framegrabber/RgbVisualParams_Responder.h>
 
class ServerGrabber;
 
 
class ServerGrabberResponder :
        public yarp::dev::DeviceResponder
{
private:
    bool left{false};
    ServerGrabber* server{nullptr};
public:
    ServerGrabberResponder(bool _left = false);
    ~ServerGrabberResponder() override = default;
    bool configure(ServerGrabber* _server);
    bool respond(const yarp::os::Bottle &command, yarp::os::Bottle &reply) override;
};
 
 
enum Capabilities
{
//    AV,
    COLOR,
    RAW,
};
 
 
struct Configuration
{
    bool spoke{false}; // location of this variable tickles bug on Solaris/gcc3.2
    bool canDrop{true};
    bool addStamp{false};
    bool active{false};
    bool singleThreaded{false};
    bool twoCameras{false};
    bool split{false};
    bool splitterMode{false};
    bool hasAudio{false};
    Capabilities cap{COLOR};
};
 
 
#define DEFAULT_THREAD_PERIOD   0.03 //s
 
 
class ServerGrabber :
        public yarp::dev::DeviceDriver,
        public yarp::dev::IWrapper,
        public yarp::dev::IMultipleWrapper,
        public yarp::os::PeriodicThread
{
private:
    double period{DEFAULT_THREAD_PERIOD};
    int count{0};
    int count2{0};
    ServerGrabberResponder* responder{nullptr};
    ServerGrabberResponder* responder2{nullptr};
    yarp::proto::framegrabber::RgbVisualParams_Responder rgbParser;
    yarp::proto::framegrabber::RgbVisualParams_Responder rgbParser2;
    yarp::dev::IRgbVisualParams* rgbVis_p{nullptr};
    yarp::dev::IRgbVisualParams* rgbVis_p2{nullptr};
    std::string rpcPort_Name;
    std::string rpcPort2_Name;
    yarp::os::Port rpcPort;
    yarp::os::Port rpcPort2;
    std::string pImg_Name;
    std::string pImg2_Name;
    yarp::os::BufferedPort<yarp::sig::FlexImage> pImg;
    yarp::os::BufferedPort<yarp::sig::FlexImage> pImg2;
    yarp::os::Port *p2{nullptr};//audio
    yarp::dev::PolyDriver* poly{nullptr}; //subDeviceOwned convert to pointer
    yarp::dev::PolyDriver* poly2{nullptr};
    yarp::dev::IFrameGrabberImage *fgImage{nullptr};
    yarp::dev::IFrameGrabberImage *fgImage2{nullptr};
    yarp::dev::IFrameGrabberImageRaw *fgImageRaw{nullptr};
    yarp::dev::IFrameGrabberImageRaw *fgImageRaw2{nullptr};
    //yarp::sig::FlexImage  doubleImage, doubleImage2;
//    IAudioVisualGrabber *fgAv{nullptr}; //TODO: manage the AV
    yarp::dev::IFrameGrabberControls *fgCtrl{nullptr};
    yarp::dev::IFrameGrabberControls *fgCtrl2{nullptr};
    yarp::dev::IFrameGrabberControlsDC1394* fgCtrl_DC1394{nullptr};
    yarp::dev::IFrameGrabberControlsDC1394* fgCtrl2_DC1394{nullptr};
    yarp::dev::IPreciselyTimed *fgTimed{nullptr};
    yarp::proto::framegrabber::FrameGrabberControls_Responder ifgCtrl_Responder;
    yarp::proto::framegrabber::FrameGrabberControls_Responder ifgCtrl2_Responder;
    yarp::proto::framegrabber::FrameGrabberControlsDC1394_Responder ifgCtrl_DC1394_Responder;
    yarp::proto::framegrabber::FrameGrabberControlsDC1394_Responder ifgCtrl2_DC1394_Responder;
    Configuration param;
    yarp::sig::ImageOf<yarp::sig::PixelRgb>* img{nullptr};
    yarp::sig::ImageOf<yarp::sig::PixelRgb>* img2{nullptr};
    yarp::sig::ImageOf<yarp::sig::PixelMono>* img_Raw{nullptr};
    yarp::sig::ImageOf<yarp::sig::PixelMono>* img2_Raw{nullptr};
 
    // Open the wrapper only, the attach method needs to be called before using it
    // Typical usage: yarprobotinterface
    bool openDeferredAttach(yarp::os::Searchable& prop);
 
    // If a subdevice parameter is given, the wrapper will open it(or them) and attach to immediately.
    // Typical usage: simulator or command line
    bool isSubdeviceOwned{false};
    bool openAndAttachSubDevice(yarp::os::Searchable& prop);
 
public:
    ServerGrabber();
    ServerGrabber(const ServerGrabber&) = delete;
    ServerGrabber(ServerGrabber&&) = delete;
    ServerGrabber& operator=(const ServerGrabber&) = delete;
    ServerGrabber& operator=(ServerGrabber&&) = delete;
    ~ServerGrabber() override;
 
    //DeviceDriver
    bool close() override;
    bool open(yarp::os::Searchable& config) override;
 
    //bool read(ConnectionReader& connection) override;
 
    //DeviceResponder
    bool respond(const yarp::os::Bottle& command,
                         yarp::os::Bottle& reply, bool left, bool both);
    // IMultipleWrapper interface
    bool        attachAll(const yarp::dev::PolyDriverList &device2attach) override;
 
    bool        detachAll() override;
 
    // IWrapper interface
    bool        attach(yarp::dev::PolyDriver *poly) override;
 
    bool        detach() override;
 
    //RateThread
    bool threadInit() override;
 
    void threadRelease() override;
 
    void run() override;
protected:
 
    bool fromConfig(yarp::os::Searchable &config);
 
    bool initialize_YARP(yarp::os::Searchable &params);
 
    void stopThread();
 
    void setupFlexImage(const yarp::sig::Image& img, yarp::sig::FlexImage& flex_i);
 
    void shallowCopyImages(const yarp::sig::FlexImage& src, yarp::sig::FlexImage& dest);
 
    void cleanUp();
};
 
#endif // YARP_DEV_SERVERGRABBER_H