d305997a2345792a43d4207bad32f62e30aebb4204508478c416af54d9c81106

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/shared_memory.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/utils/posix/condition_variable.h>
+#include <pangolin/utils/posix/shared_memory_buffer.h>
+
+#include <memory>
+#include <vector>
+
+namespace pangolin
+{
+
+class SharedMemoryVideo : public VideoInterface
+{
+public:
+  SharedMemoryVideo(size_t w, size_t h, std::string pix_fmt,
+    const std::shared_ptr<SharedMemoryBufferInterface>& shared_memory,
+    const std::shared_ptr<ConditionVariableInterface>& buffer_full);
+  ~SharedMemoryVideo();
+
+  size_t SizeBytes() const;
+  const std::vector<StreamInfo>& Streams() const;
+  void Start();
+  void Stop();
+  bool GrabNext(unsigned char *image, bool wait);
+  bool GrabNewest(unsigned char *image, bool wait);
+
+private:
+  PixelFormat _fmt;
+  size_t _frame_size;
+  std::vector<StreamInfo> _streams;
+  std::shared_ptr<SharedMemoryBufferInterface> _shared_memory;
+  std::shared_ptr<ConditionVariableInterface> _buffer_full;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/shift.h

@@ -0,0 +1,78 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <set>
+
+namespace pangolin
+{
+
+// Video class that debayers its video input using the given method.
+class PANGOLIN_EXPORT ShiftVideo : public VideoInterface, public VideoFilterInterface
+{
+public:
+    ShiftVideo(std::unique_ptr<VideoInterface>& videoin,
+               const std::map<size_t, int>& shift_right_bits,
+               const std::map<size_t, uint32_t>& masks);
+    ~ShiftVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( uint8_t* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( uint8_t* image, bool wait = true );
+
+    std::vector<VideoInterface*>& InputStreams();
+
+protected:
+    void Process(uint8_t* buffer_out, const uint8_t* buffer_in);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    std::unique_ptr<uint8_t[]> buffer;
+    const std::map<size_t, int> shift_right_bits;
+    const std::map<size_t, uint32_t> masks;
+    std::set<std::string> formats_supported;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/split.h

@@ -0,0 +1,65 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <vector>
+#include <pangolin/video/video_interface.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT SplitVideo
+    : public VideoInterface, public VideoFilterInterface
+{
+public:
+    SplitVideo(std::unique_ptr<VideoInterface>& videoin, const std::vector<StreamInfo>& streams);
+
+    ~SplitVideo();
+    
+    size_t SizeBytes() const;
+    
+    const std::vector<StreamInfo>& Streams() const;
+    
+    void Start();
+    
+    void Stop();
+    
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    std::vector<VideoInterface*>& InputStreams();
+    
+protected:
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+};
+
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/teli.h

@@ -0,0 +1,122 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/utils/timer.h>
+
+#if defined(_WIN_)
+#  define WIN32_LEAN_AND_MEAN
+#  include <windows.h>
+#endif
+
+#include <TeliCamApi.h>
+
+namespace pangolin
+{
+
+// Video class that outputs test video signal.
+class PANGOLIN_EXPORT TeliVideo : public VideoInterface, public VideoPropertiesInterface,
+        public BufferAwareVideoInterface, public GenicamVideoInterface
+{
+public:
+    TeliVideo(const Params &p);
+    ~TeliVideo();
+
+    Params OpenCameraAndGetRemainingParameters(Params &params);
+    
+    //! Implement VideoInput::Start()
+    void Start();
+    
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    inline Teli::CAM_HANDLE GetCameraHandle() {
+        return cam;
+    }
+
+    inline Teli::CAM_STRM_HANDLE GetCameraStreamHandle() {
+        return strm;
+    }
+
+    bool GetParameter(const std::string& name, std::string& result);
+
+    bool SetParameter(const std::string& name, const std::string& value);
+
+    //! Returns number of available frames
+    uint32_t AvailableFrames() const;
+
+    //! Drops N frames in the queue starting from the oldest
+    //! returns false if less than n frames arae available
+    bool DropNFrames(uint32_t n);
+
+    //! Access JSON properties of device
+    const picojson::value& DeviceProperties() const;
+
+    //! Access JSON properties of most recently captured frame
+    const picojson::value& FrameProperties() const;
+
+    void PopulateEstimatedCenterCaptureTime(pangolin::basetime host_reception_time);
+
+protected:
+    void Initialise();
+    void InitPangoDeviceProperties();
+    void SetDeviceParams(const Params &p);
+    void SetNodeValStr(Teli::CAM_HANDLE cam, Teli::CAM_NODE_HANDLE node, std::string node_str, std::string val_str);
+
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+
+    Teli::CAM_HANDLE cam;
+    Teli::CAM_STRM_HANDLE strm;
+
+#ifdef _WIN_
+    HANDLE hStrmCmpEvt;
+#endif
+#ifdef _LINUX_
+    Teli::SIGNAL_HANDLE hStrmCmpEvt;
+#endif
+    double transfer_bandwidth_gbps;
+    int exposure_us;
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/test.h

@@ -0,0 +1,65 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+
+namespace pangolin
+{
+
+// Video class that outputs test video signal.
+class PANGOLIN_EXPORT TestVideo : public VideoInterface
+{
+public:
+    TestVideo(size_t w, size_t h, size_t n, std::string pix_fmt);
+    ~TestVideo();
+    
+    //! Implement VideoInput::Start()
+    void Start() override;
+    
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+    
+protected:
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/thread.h

@@ -0,0 +1,111 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <memory>
+#include <pangolin/video/video_interface.h>
+#include <pangolin/utils/fix_size_buffer_queue.h>
+
+namespace pangolin
+{
+
+
+// Video class that creates a thread that keeps pulling frames and processing from its children.
+class PANGOLIN_EXPORT ThreadVideo :  public VideoInterface, public VideoPropertiesInterface,
+        public BufferAwareVideoInterface, public VideoFilterInterface
+{
+public:
+    ThreadVideo(std::unique_ptr<VideoInterface>& videoin, size_t num_buffers, const std::string& name);
+    ~ThreadVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    const picojson::value& DeviceProperties() const;
+
+    const picojson::value& FrameProperties() const;
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+    void operator()();
+
+    std::vector<VideoInterface*>& InputStreams();
+
+protected:
+    struct GrabResult
+    {
+        GrabResult(const size_t buffer_size)
+            : return_status(false),
+              buffer(new unsigned char[buffer_size])
+        {
+        }
+
+        // No copy constructor.
+        GrabResult(const GrabResult& o) = delete;
+
+        // Default move constructor
+        GrabResult(GrabResult&& o) = default;
+
+        bool return_status;
+        std::unique_ptr<unsigned char[]> buffer;
+        picojson::value frame_properties;
+    };
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+
+    bool quit_grab_thread;
+    FixSizeBuffersQueue<GrabResult> queue;
+
+    std::condition_variable cv;
+    std::mutex cvMtx;
+    std::thread grab_thread;
+    std::string thread_name;
+
+    mutable picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/transform.h

@@ -0,0 +1,90 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+
+namespace pangolin
+{
+
+enum class TransformOptions
+{
+    None, FlipX, FlipY, FlipXY,
+    Transpose, RotateCW, RotateCCW,
+};
+
+// Video class that transforms its video input using the specified method.
+class PANGOLIN_EXPORT TransformVideo :
+    public VideoInterface,
+    public VideoFilterInterface,
+    public BufferAwareVideoInterface
+{
+public:
+    TransformVideo(std::unique_ptr<VideoInterface>& videoin, const std::vector<TransformOptions>& flips);
+    ~TransformVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! Implement VideoFilterInterface method
+    std::vector<VideoInterface*>& InputStreams();
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+    void Process(unsigned char* image, const unsigned char* buffer);
+
+    std::unique_ptr<VideoInterface> videoin;
+    std::vector<VideoInterface*> inputs;
+    std::vector<StreamInfo> streams;
+    std::vector<TransformOptions> flips;
+    size_t size_bytes;
+    unsigned char* buffer;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/truncate.h

@@ -0,0 +1,71 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <vector>
+#include <pangolin/video/video_interface.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT TruncateVideo
+    : public VideoInterface, public VideoFilterInterface
+{
+public:
+    TruncateVideo(std::unique_ptr<VideoInterface>& videoin, size_t begin, size_t end);
+
+    ~TruncateVideo();
+
+    size_t SizeBytes() const;
+
+    const std::vector<StreamInfo>& Streams() const;
+
+    void Start();
+
+    void Stop();
+
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    std::vector<VideoInterface*>& InputStreams();
+
+protected:
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+
+    size_t begin;
+    size_t end;
+    size_t next_frame_to_grab;
+
+    inline VideoPlaybackInterface* GetVideoPlaybackInterface(){ return dynamic_cast<VideoPlaybackInterface*>(src.get()); }
+};
+
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/unpack.h

@@ -0,0 +1,83 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+
+namespace pangolin
+{
+
+// Video class that debayers its video input using the given method.
+class PANGOLIN_EXPORT UnpackVideo :
+    public VideoInterface,
+    public VideoFilterInterface,
+    public BufferAwareVideoInterface
+{
+public:
+    UnpackVideo(std::unique_ptr<VideoInterface>& videoin, PixelFormat new_fmt);
+    ~UnpackVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! Implement VideoFilterInterface method
+    std::vector<VideoInterface*>& InputStreams();
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+    void Process(unsigned char* image, const unsigned char* buffer);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    unsigned char* buffer;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/uvc.h

@@ -0,0 +1,114 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/utils/timer.h>
+
+#ifdef _MSC_VER
+// Define missing timeval struct
+typedef struct timeval {
+    long tv_sec;
+    long tv_usec;
+} timeval;
+#endif // _MSC_VER
+
+#include <libuvc/libuvc.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT UvcVideo : public VideoInterface, public VideoUvcInterface, public VideoPropertiesInterface
+{
+public:
+    UvcVideo(int vendor_id, int product_id, const char* sn, int deviceid, int width, int height, int fps);
+    ~UvcVideo();
+    
+    void InitDevice(int vid, int pid, const char* sn, int deviceid, int width, int height, int fps);
+    void DeinitDevice();
+    
+    //! Implement VideoInput::Start()
+    void Start();
+    
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! Implement VideoUvcInterface::GetCtrl()
+    int IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code);
+
+    //! Implement VideoUvcInterface::GetExposure()
+    bool GetExposure(int& exp_us);
+
+    //! Implement VideoUvcInterface::SetExposure()
+    bool SetExposure(int exp_us);
+
+    //! Implement VideoUvcInterface::GetGain()
+    bool GetGain(float& gain);
+
+    //! Implement VideoUvcInterface::SetGain()
+    bool SetGain(float gain);
+
+    //! Access JSON properties of device
+    const picojson::value& DeviceProperties() const;
+
+    //! Access JSON properties of most recently captured frame
+    const picojson::value& FrameProperties() const;
+
+protected:
+    void InitPangoDeviceProperties();
+    static uvc_error_t FindDevice(
+        uvc_context_t *ctx, uvc_device_t **dev,
+        int vid, int pid, const char *sn, int device_id);
+
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    
+    uvc_context* ctx_;
+    uvc_device*  dev_;
+    uvc_device_handle* devh_;
+    uvc_stream_handle* strm_;
+    uvc_stream_ctrl_t ctrl_;
+    uvc_frame_t* frame_;
+    picojson::value device_properties;
+    picojson::value frame_properties;
+    bool is_streaming;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/uvc_mediafoundation.h

@@ -0,0 +1,93 @@
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+
+struct IMFActivate;
+struct IMFMediaSource;
+struct IMFSourceReader;
+struct IBaseFilter;
+struct IKsControl;
+
+namespace pangolin
+{
+
+class AsyncSourceReader;
+class PANGOLIN_EXPORT UvcMediaFoundationVideo
+    : public pangolin::VideoInterface, public pangolin::VideoUvcInterface, public pangolin::VideoPropertiesInterface
+{
+  public:
+    UvcMediaFoundationVideo(int vendorId, int productId, const std::string& instanceId, size_t width, size_t height, int fps);
+    ~UvcMediaFoundationVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<pangolin::StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext(unsigned char* image, bool wait = true);
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest(unsigned char* image, bool wait = true);
+
+    //! Implement VideoUvcInterface::GetCtrl()
+    int IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, pangolin::UvcRequestCode req_code);
+
+    //! Implement VideoUvcInterface::GetExposure()
+    bool GetExposure(int& exp_us);
+
+    //! Implement VideoUvcInterface::SetExposure()
+    bool SetExposure(int exp_us);
+
+    //! Implement VideoUvcInterface::GetGain()
+    bool GetGain(float& gain);
+
+    //! Implement VideoUvcInterface::SetGain()
+    bool SetGain(float gain);
+
+    //! Access JSON properties of device
+    const picojson::value& DeviceProperties() const;
+
+    //! Access JSON properties of most recently captured frame
+    const picojson::value& FrameProperties() const;
+
+  protected:
+    bool FindDevice(int vendorId, int productId, const std::string& instanceId);
+    void InitDevice(size_t width, size_t height, bool async);
+    void DeinitDevice();
+    void PopulateGainControls();
+
+    static bool DeviceMatches(const std::wstring& symLink, int vendorId, int productId, std::wstring& instanceId);
+    static bool SymLinkIDMatches(const std::wstring& symLink, const wchar_t* idStr, int id);
+
+    std::vector<pangolin::StreamInfo> streams;
+    size_t size_bytes;
+
+    IMFMediaSource* mediaSource;
+    AsyncSourceReader* asyncSourceReader;
+    IMFSourceReader* sourceReader;
+    IBaseFilter* baseFilter;
+    IKsControl* ksControl;
+    DWORD ksControlNodeId;
+    IAMCameraControl* camera_control;
+    IAMVideoProcAmp* video_control;
+
+    long gainCamMin;
+    long gainCamMax;
+    long gainCamDefault;
+
+    const float gainApiMin = 1.0f;
+    const float gainApiMax = 15.5f;
+    int64_t expected_fps;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/v4l.h

@@ -0,0 +1,128 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+
+#include <asm/types.h>
+#include <linux/videodev2.h>
+
+namespace pangolin
+{
+
+typedef enum {
+    IO_METHOD_READ,
+    IO_METHOD_MMAP,
+    IO_METHOD_USERPTR,
+} io_method;
+
+struct buffer {
+    void*  start;
+    size_t length;
+};
+
+class PANGOLIN_EXPORT V4lVideo : public VideoInterface, public VideoUvcInterface, public VideoPropertiesInterface
+{
+public:
+    V4lVideo(const char* dev_name, uint32_t period, io_method io = IO_METHOD_MMAP, unsigned iwidth=0, unsigned iheight=0, unsigned v4l_format=V4L2_PIX_FMT_YUYV);
+    ~V4lVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! Implement VideoUvcInterface::IoCtrl()
+    int IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code);
+
+    bool GetExposure(int& exp_us);
+
+    bool SetExposure(int exp_us);
+
+    bool GetGain(float& gain);
+
+    bool SetGain(float gain);
+
+    int GetFileDescriptor() const{
+        return fd;
+    }
+
+    //! Access JSON properties of device
+    const picojson::value& DeviceProperties() const;
+
+    //! Access JSON properties of most recently captured frame
+    const picojson::value& FrameProperties() const;
+
+protected:
+    void InitPangoDeviceProperties();
+
+
+    int ReadFrame(unsigned char* image, bool wait = true);
+    void Mainloop();
+
+    void init_read(unsigned int buffer_size);
+    void init_mmap(const char* dev_name);
+    void init_userp(const char* dev_name, unsigned int buffer_size);
+
+    void init_device(const char* dev_name, unsigned iwidth, unsigned iheight, unsigned ifps, unsigned v4l_format = V4L2_PIX_FMT_YUYV, v4l2_field field = V4L2_FIELD_INTERLACED);
+    void uninit_device();
+
+    void open_device(const char* dev_name);
+    void close_device();
+
+    std::vector<StreamInfo> streams;
+
+    io_method io;
+    int       fd;
+    buffer*   buffers;
+    unsigned  int n_buffers;
+    bool running;
+    unsigned width;
+    unsigned height;
+    float fps;
+    size_t image_size;
+    uint32_t period;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/iostream_operators.h

@@ -0,0 +1,132 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <cctype>
+
+#include <pangolin/video/video_exception.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/video/stream_info.h>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT Point
+{
+    inline Point() : x(0), y(0) {}
+    inline Point(size_t x, size_t y) : x(x), y(y) {}
+    size_t x;
+    size_t y;
+};
+
+typedef Point ImageDim;
+
+struct PANGOLIN_EXPORT ImageRoi
+{
+    inline ImageRoi() : x(0), y(0), w(0), h(0) {}
+    inline ImageRoi(size_t x, size_t y, size_t w, size_t h) : x(x), y(y), w(w), h(h) {}
+    size_t x; size_t y;
+    size_t w; size_t h;
+};
+
+inline std::istream& operator>> (std::istream &is, ImageDim &dim)
+{
+    if(std::isdigit(is.peek()) ) {
+        // Expect 640x480, 640*480, ...
+        is >> dim.x; is.get(); is >> dim.y;
+    }else{
+        // Expect 'VGA', 'QVGA', etc
+        std::string sdim;
+        is >> sdim;
+        ToUpper(sdim);
+
+        if( !sdim.compare("QQVGA") ) {
+            dim = ImageDim(160,120);
+        }else if( !sdim.compare("HQVGA") ) {
+            dim = ImageDim(240,160);
+        }else if( !sdim.compare("QVGA") ) {
+            dim = ImageDim(320,240);
+        }else if( !sdim.compare("WQVGA") ) {
+            dim = ImageDim(360,240);
+        }else if( !sdim.compare("HVGA") ) {
+            dim = ImageDim(480,320);
+        }else if( !sdim.compare("VGA") ) {
+            dim = ImageDim(640,480);
+        }else if( !sdim.compare("WVGA") ) {
+            dim = ImageDim(720,480);
+        }else if( !sdim.compare("SVGA") ) {
+            dim = ImageDim(800,600);
+        }else if( !sdim.compare("DVGA") ) {
+            dim = ImageDim(960,640);
+        }else if( !sdim.compare("WSVGA") ) {
+            dim = ImageDim(1024,600);
+        }else{
+            throw VideoException("Unrecognised image-size string.");
+        }
+    }
+    return is;
+}
+
+inline std::istream& operator>> (std::istream &is, ImageRoi &roi)
+{
+    is >> roi.x; is.get(); is >> roi.y; is.get();
+    is >> roi.w; is.get(); is >> roi.h;
+    return is;
+}
+
+inline std::istream& operator>> (std::istream &is, PixelFormat& fmt)
+{
+    std::string sfmt;
+    is >> sfmt;
+    fmt = PixelFormatFromString(sfmt);
+    return is;
+}
+
+inline std::istream& operator>> (std::istream &is, Image<unsigned char>& img)
+{
+    size_t offset;
+    is >> offset; is.get();
+    img.ptr = (unsigned char*)(offset);
+    is >> img.w; is.get();
+    is >> img.h; is.get();
+    is >> img.pitch;
+    return is;
+}
+
+inline std::istream& operator>> (std::istream &is, StreamInfo &stream)
+{
+    PixelFormat fmt;
+    Image<unsigned char> img_offset;
+    is >> img_offset; is.get();
+    is >> fmt;
+    stream = StreamInfo(fmt, img_offset);
+    return is;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/stream_encoder_factory.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <memory>
+
+#include <pangolin/image/image_io.h>
+
+namespace pangolin {
+
+using ImageEncoderFunc = std::function<void(std::ostream&, const Image<unsigned char>&)>;
+using ImageDecoderFunc = std::function<TypedImage(std::istream&)>;
+
+class StreamEncoderFactory
+{
+public:
+    static StreamEncoderFactory& I();
+
+    ImageEncoderFunc GetEncoder(const std::string& encoder_spec, const PixelFormat& fmt);
+
+    ImageDecoderFunc GetDecoder(const std::string& encoder_spec, const PixelFormat& fmt);
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/stream_info.h

@@ -0,0 +1,100 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/image/image.h>
+#include <pangolin/image/pixel_format.h>
+
+namespace pangolin {
+
+class PANGOLIN_EXPORT StreamInfo
+{
+public:
+    inline StreamInfo()
+        : fmt(PixelFormatFromString("GRAY8")) {}
+
+    inline StreamInfo(PixelFormat fmt, const Image<unsigned char> img_offset )
+        : fmt(fmt), img_offset(img_offset) {}
+
+    inline StreamInfo(PixelFormat fmt, size_t w, size_t h, size_t pitch, unsigned char* offset = 0)
+        : fmt(fmt), img_offset(offset,w,h,pitch) {}
+
+    //! Format representing how image is laid out in memory
+    inline const PixelFormat &PixFormat() const { return fmt; }
+
+    //! Image width in pixels
+    inline size_t Width() const { return img_offset.w; }
+
+    //! Image height in pixels
+    inline size_t Height() const { return img_offset.h; }
+
+    inline double Aspect() const { return (double)Width() / (double)Height(); }
+
+    //! Pitch: Number of bytes between one image row and the next
+    inline size_t Pitch() const { return img_offset.pitch; }
+
+    //! Number of contiguous bytes in memory that the image occupies
+    inline size_t RowBytes() const {
+        // Row size without padding
+        return (fmt.bpp*img_offset.w)/8;
+    }
+
+    //! Returns true iff image contains padding or stridded access
+    //! This implies that the image data is not contiguous in memory.
+    inline bool IsPitched() const {
+        return Pitch() != RowBytes();
+    }
+
+    //! Number of contiguous bytes in memory that the image occupies
+    inline size_t SizeBytes() const {
+        return (img_offset.h-1) * img_offset.pitch + RowBytes();
+    }
+
+    //! Offset in bytes relative to start of frame buffer
+    inline unsigned char* Offset() const { return img_offset.ptr; }
+
+    //! Return Image wrapper around raw base pointer
+    inline Image<unsigned char> StreamImage(unsigned char* base_ptr) const {
+        Image<unsigned char> img = img_offset;
+        img.ptr += (size_t)base_ptr;
+        return img;
+    }
+
+    //! Return Image wrapper around raw base pointer
+    inline const Image<unsigned char> StreamImage(const unsigned char* base_ptr) const {
+        Image<unsigned char> img = img_offset;
+        img.ptr += (size_t)base_ptr;
+        return img;
+    }
+
+protected:
+    PixelFormat fmt;
+    Image<unsigned char> img_offset;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video.h

@@ -0,0 +1,169 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/utils/uri.h>
+#include <pangolin/video/video_exception.h>
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/video_output_interface.h>
+
+namespace pangolin
+{
+
+//! Open Video Interface from string specification (as described in this files header)
+PANGOLIN_EXPORT
+std::unique_ptr<VideoInterface> OpenVideo(const std::string& uri);
+
+//! Open Video Interface from Uri specification
+PANGOLIN_EXPORT
+std::unique_ptr<VideoInterface> OpenVideo(const Uri& uri);
+
+//! Open VideoOutput Interface from string specification (as described in this files header)
+PANGOLIN_EXPORT
+std::unique_ptr<VideoOutputInterface> OpenVideoOutput(const std::string& str_uri);
+
+//! Open VideoOutput Interface from Uri specification
+PANGOLIN_EXPORT
+std::unique_ptr<VideoOutputInterface> OpenVideoOutput(const Uri& uri);
+
+//! Create vector of matching interfaces either through direct cast or filter interface.
+template<typename T>
+std::vector<T*> FindMatchingVideoInterfaces( VideoInterface& video )
+{
+    std::vector<T*> matches;
+
+    T* vid = dynamic_cast<T*>(&video);
+    if(vid) {
+        matches.push_back(vid);
+    }
+
+    VideoFilterInterface* vidf = dynamic_cast<VideoFilterInterface*>(&video);
+    if(vidf) {
+        std::vector<T*> fmatches = vidf->FindMatchingStreams<T>();
+        matches.insert(matches.begin(), fmatches.begin(), fmatches.end());
+    }
+
+    return matches;
+}
+
+template<typename T>
+T* FindFirstMatchingVideoInterface( VideoInterface& video )
+{
+    T* vid = dynamic_cast<T*>(&video);
+    if(vid) {
+        return vid;
+    }
+
+    VideoFilterInterface* vidf = dynamic_cast<VideoFilterInterface*>(&video);
+    if(vidf) {
+        std::vector<T*> fmatches = vidf->FindMatchingStreams<T>();
+        if(fmatches.size()) {
+            return fmatches[0];
+        }
+    }
+
+    return 0;
+}
+
+inline
+picojson::value GetVideoFrameProperties(VideoInterface* video)
+{
+    VideoPropertiesInterface* pi = dynamic_cast<VideoPropertiesInterface*>(video);
+    VideoFilterInterface* fi = dynamic_cast<VideoFilterInterface*>(video);
+
+    if(pi) {
+        return pi->FrameProperties();
+    }else if(fi){
+        if(fi->InputStreams().size() == 1) {
+            return GetVideoFrameProperties(fi->InputStreams()[0]);
+        }else if(fi->InputStreams().size() > 0){
+            picojson::value streams;
+
+            for(size_t i=0; i< fi->InputStreams().size(); ++i) {
+                const picojson::value dev_props = GetVideoFrameProperties(fi->InputStreams()[i]);
+                if(dev_props.contains("streams")) {
+                    const picojson::value& dev_streams = dev_props["streams"];
+                    for(size_t j=0; j < dev_streams.size(); ++j) {
+                        streams.push_back(dev_streams[j]);
+                    }
+                }else{
+                    streams.push_back(dev_props);
+                }
+            }
+
+            if(streams.size() > 1) {
+                picojson::value json = streams[0];
+                json["streams"] = streams;
+                return json;
+            }else{
+                return streams[0];
+            }
+        }
+    }
+    return picojson::value();
+}
+
+inline
+picojson::value GetVideoDeviceProperties(VideoInterface* video)
+{
+    VideoPropertiesInterface* pi = dynamic_cast<VideoPropertiesInterface*>(video);
+    VideoFilterInterface* fi = dynamic_cast<VideoFilterInterface*>(video);
+
+    if(pi) {
+        return pi->DeviceProperties();
+    }else if(fi){
+        if(fi->InputStreams().size() == 1) {
+            return GetVideoDeviceProperties(fi->InputStreams()[0]);
+        }else if(fi->InputStreams().size() > 0){
+            picojson::value streams;
+
+            for(size_t i=0; i< fi->InputStreams().size(); ++i) {
+                const picojson::value dev_props = GetVideoDeviceProperties(fi->InputStreams()[i]);
+                if(dev_props.contains("streams")) {
+                    const picojson::value& dev_streams = dev_props["streams"];
+                    for(size_t j=0; j < dev_streams.size(); ++j) {
+                        streams.push_back(dev_streams[j]);
+                    }
+                }else{
+                    streams.push_back(dev_props);
+                }
+            }
+
+            if(streams.size() > 1) {
+                picojson::value json = streams[0];
+                json["streams"] = streams;
+                return json;
+            }else{
+                return streams[0];
+            }
+        }
+    }
+    return picojson::value();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_exception.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <exception>
+#include <pangolin/platform.h>
+#include <string>
+
+namespace pangolin {
+
+struct PANGOLIN_EXPORT VideoException : std::exception
+{
+    VideoException(std::string str) : desc(str) {}
+    VideoException(std::string str, std::string detail) {
+        desc = str + "\n\t" + detail;
+    }
+    ~VideoException() throw() {}
+    const char* what() const throw() { return desc.c_str(); }
+    std::string desc;
+};
+
+struct PANGOLIN_EXPORT VideoExceptionNoKnownHandler : public VideoException
+{
+    VideoExceptionNoKnownHandler(const std::string& scheme)
+        : VideoException("No known video handler for URI '" + scheme + "'")
+    {
+    }
+};
+
+}
+

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_help.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <iostream>
+#include <pangolin/factory/factory_help.h>
+
+namespace pangolin {
+
+/// Print to \p out supported pixel format codes
+/// \p color whether ANSI Color codes should be used for formatting
+void PrintPixelFormats(std::ostream& out = std::cout, bool color = true);
+
+/// Print to \p out general Video URL usage and registered VideoFactories
+/// \p out the stream to stream the help message to
+/// \p scheme_filter a constraint on schemes to print, or empty if all should be listed
+/// \p level the level of detail to use when printing (see enum above)
+void VideoHelp(
+    std::ostream& out = std::cout, const std::string& scheme_filter="",
+    HelpVerbosity verbosity = HelpVerbosity::SYNOPSIS
+);
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_input.h

@@ -0,0 +1,140 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/video/video.h>
+#include <pangolin/video/video_output.h>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT VideoInput
+    : public VideoInterface,
+      public VideoFilterInterface
+{
+    /////////////////////////////////////////////////////////////
+    // VideoInterface Methods
+    /////////////////////////////////////////////////////////////
+
+    size_t SizeBytes() const override;
+    const std::vector<StreamInfo>& Streams() const override;
+    void Start() override;
+    void Stop() override;
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    /////////////////////////////////////////////////////////////
+    // VideoFilterInterface Methods
+    /////////////////////////////////////////////////////////////
+
+    std::vector<VideoInterface*>& InputStreams() override
+    {
+        return videos;
+    }
+
+    /////////////////////////////////////////////////////////////
+    // VideoInput Methods
+    /////////////////////////////////////////////////////////////
+
+    VideoInput();
+    VideoInput(VideoInput&& other) = default;
+    VideoInput(const std::string &input_uri, const std::string &output_uri = "pango:[buffer_size_mb=100]//video_log.pango");
+    ~VideoInput();
+
+    void Open(const std::string &input_uri, const std::string &output_uri = "pango:[buffer_size_mb=100]//video_log.pango");
+    void Close();
+
+    // experimental - not stable
+    bool Grab( unsigned char* buffer, std::vector<Image<unsigned char> >& images, bool wait = true, bool newest = false);
+
+    // Return details of first stream
+    unsigned int Width() const {
+        return (unsigned int)Streams()[0].Width();
+    }
+    unsigned int Height() const {
+        return (unsigned int)Streams()[0].Height();
+    }
+    PixelFormat PixFormat() const {
+        return Streams()[0].PixFormat();
+    }
+    const Uri& VideoUri() const {
+        return uri_input;
+    }
+
+    void Reset() {
+        Close();
+        Open(uri_input.full_uri, uri_output.full_uri);
+    }
+
+    // Return pointer to inner video class as VideoType
+    template<typename VideoType>
+    VideoType* Cast() {
+        return dynamic_cast<VideoType*>(video_src.get());
+    }
+
+    const std::string& LogFilename() const;
+    std::string& LogFilename();
+
+    // Switch to live video and record output to file
+    void Record();
+
+    // Switch to live video and record a single frame
+    void RecordOneFrame();
+
+    // Specify that one in n frames are logged to file. Default is 1.
+    void SetTimelapse(size_t one_in_n_frames);
+
+    // True iff grabbed live frames are being logged to file
+    bool IsRecording() const;
+
+protected:
+    void InitialiseRecorder();
+
+    Uri uri_input;
+    Uri uri_output;
+
+    std::unique_ptr<VideoInterface> video_src;
+    std::unique_ptr<VideoOutputInterface> video_recorder;
+
+    // Use to store either video_src or video_file for VideoFilterInterface,
+    // depending on which is active
+    std::vector<VideoInterface*> videos;
+
+    int buffer_size_bytes;
+
+    int frame_num;
+    size_t record_frame_skip;
+
+    bool record_once;
+    bool record_continuous;
+};
+
+// VideoInput subsumes the previous VideoRecordRepeat class.
+typedef VideoInput VideoRecordRepeat;
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_interface.h

@@ -0,0 +1,184 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/utils/picojson.h>
+#include <pangolin/video/stream_info.h>
+
+#include <memory>
+#include <vector>
+
+#define PANGO_HAS_TIMING_DATA        "has_timing_data"
+#define PANGO_HOST_RECEPTION_TIME_US "host_reception_time_us"
+#define PANGO_CAPTURE_TIME_US        "capture_time_us"
+#define PANGO_EXPOSURE_US            "exposure_us"
+#define PANGO_GAMMA                  "gamma"
+// analog gain is in linear scale and not dB
+#define PANGO_ANALOG_GAIN            "analog_gain" 
+#define PANGO_ANALOG_BLACK_LEVEL     "analog_black_level"
+#define PANGO_SENSOR_TEMPERATURE_C   "sensor_temperature_C"
+#define PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US "estimated_center_capture_time_us"
+#define PANGO_JOIN_OFFSET_US         "join_offset_us"
+#define PANGO_FRAME_COUNTER          "frame_counter"
+#define PANGO_HAS_LINE0_METADATA     "line0_metadata"
+
+namespace pangolin {
+
+//! Interface to video capture sources
+struct PANGOLIN_EXPORT VideoInterface
+{
+    virtual ~VideoInterface() {}
+
+    //! Required buffer size to store all frames
+    virtual size_t SizeBytes() const = 0;
+
+    //! Get format and dimensions of all video streams
+    virtual const std::vector<StreamInfo>& Streams() const = 0;
+
+    //! Start Video device
+    virtual void Start() = 0;
+
+    //! Stop Video device
+    virtual void Stop() = 0;
+
+    //! Copy the next frame from the camera to image.
+    //! Optionally wait for a frame if one isn't ready
+    //! Returns true iff image was copied
+    virtual bool GrabNext( unsigned char* image, bool wait = true ) = 0;
+
+    //! Copy the newest frame from the camera to image
+    //! discarding all older frames.
+    //! Optionally wait for a frame if one isn't ready
+    //! Returns true iff image was copied
+    virtual bool GrabNewest( unsigned char* image, bool wait = true ) = 0;
+};
+
+//! Interface to GENICAM video capture sources
+struct PANGOLIN_EXPORT GenicamVideoInterface
+{
+    virtual ~GenicamVideoInterface() {}
+
+    virtual bool GetParameter(const std::string& name, std::string& result) = 0;
+
+    virtual bool SetParameter(const std::string& name, const std::string& value) = 0;
+
+    virtual size_t CameraCount() const
+    {
+        return 1;
+    }
+};
+
+struct PANGOLIN_EXPORT BufferAwareVideoInterface
+{
+    virtual ~BufferAwareVideoInterface() {}
+
+    //! Returns number of available frames
+    virtual uint32_t AvailableFrames() const = 0;
+
+    //! Drops N frames in the queue starting from the oldest
+    //! returns false if less than n frames arae available
+    virtual bool DropNFrames(uint32_t n) = 0;
+};
+
+struct PANGOLIN_EXPORT VideoPropertiesInterface
+{
+    virtual ~VideoPropertiesInterface() {}
+
+    //! Access JSON properties of device
+    virtual const picojson::value& DeviceProperties() const = 0;
+
+    //! Access JSON properties of most recently captured frame
+    virtual const picojson::value& FrameProperties() const = 0;
+};
+
+enum UvcRequestCode {
+  UVC_RC_UNDEFINED = 0x00,
+  UVC_SET_CUR = 0x01,
+  UVC_GET_CUR = 0x81,
+  UVC_GET_MIN = 0x82,
+  UVC_GET_MAX = 0x83,
+  UVC_GET_RES = 0x84,
+  UVC_GET_LEN = 0x85,
+  UVC_GET_INFO = 0x86,
+  UVC_GET_DEF = 0x87
+};
+
+struct PANGOLIN_EXPORT VideoFilterInterface
+{
+    virtual ~VideoFilterInterface() {}
+
+    template<typename T>
+    std::vector<T*> FindMatchingStreams()
+    {
+        std::vector<T*> matches;
+        std::vector<VideoInterface*> children = InputStreams();
+        for(size_t c=0; c < children.size(); ++c) {
+            T* concrete_video = dynamic_cast<T*>(children[c]);
+            if(concrete_video) {
+                matches.push_back(concrete_video);
+            }else{
+                VideoFilterInterface* filter_video = dynamic_cast<VideoFilterInterface*>(children[c]);
+                if(filter_video) {
+                    std::vector<T*> child_matches = filter_video->FindMatchingStreams<T>();
+                    matches.insert(matches.end(), child_matches.begin(), child_matches.end());
+                }
+            }
+        }
+        return matches;
+    }
+
+    virtual std::vector<VideoInterface*>& InputStreams() = 0;
+};
+
+struct PANGOLIN_EXPORT VideoUvcInterface
+{
+    virtual ~VideoUvcInterface() {}
+    virtual int IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code) = 0;
+    virtual bool GetExposure(int& exp_us) = 0;
+    virtual bool SetExposure(int exp_us) = 0;
+    virtual bool GetGain(float& gain) = 0;
+    virtual bool SetGain(float gain) = 0;
+};
+
+struct PANGOLIN_EXPORT VideoPlaybackInterface
+{
+    virtual ~VideoPlaybackInterface() {}
+
+    /// Return monotonic id of current frame
+    /// The 'current frame' is the frame returned from the last successful call to Grab
+    virtual size_t GetCurrentFrameId() const = 0;
+
+    /// Return total number of frames to be captured from device,
+    /// or 0 if unknown.
+    virtual size_t GetTotalFrames() const = 0;
+
+    /// Return frameid on success, or next frame on failure
+    virtual size_t Seek(size_t frameid) = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_output.h

@@ -0,0 +1,93 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+// Pangolin video output supports various formats using
+// different 3rd party libraries. (Only one right now)
+//
+// VideoOutput URI's take the following form:
+//  scheme:[param1=value1,param2=value2,...]//device
+//
+// scheme = ffmpeg
+//
+// ffmpeg - encode to compressed file using ffmpeg
+//  fps : fps to embed in encoded file.
+//  bps : bits per second
+//  unique_filename : append unique suffix if file already exists
+//
+//  e.g. ffmpeg://output_file.avi
+//  e.g. ffmpeg:[fps=30,bps=1000000,unique_filename]//output_file.avi
+
+#include <pangolin/video/video_output_interface.h>
+#include <pangolin/utils/uri.h>
+#include <memory>
+
+namespace pangolin
+{
+
+//! VideoOutput wrap to generically construct instances of VideoOutputInterface.
+class PANGOLIN_EXPORT VideoOutput : public VideoOutputInterface
+{
+public:
+    VideoOutput();
+    VideoOutput(VideoOutput&& other) = default;
+    VideoOutput(const std::string& uri);
+    ~VideoOutput();
+    
+    bool IsOpen() const;
+    void Open(const std::string& uri);
+    void Close();
+
+    const std::vector<StreamInfo>& Streams() const override;
+
+    void SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri = "", const picojson::value& properties = picojson::value() ) override;
+
+    int WriteStreams(const unsigned char* data, const picojson::value& frame_properties = picojson::value() ) override;
+
+    bool IsPipe() const override;
+
+    void AddStream(const PixelFormat& pf, size_t w,size_t h,size_t pitch);
+
+    void AddStream(const PixelFormat& pf, size_t w,size_t h);
+
+    void SetStreams(const std::string& uri = "", const picojson::value& properties = picojson::value() );
+
+    size_t SizeBytes(void) const ;
+
+    std::vector<Image<unsigned char>> GetOutputImages(unsigned char* buffer) const ;
+
+    std::vector<Image<unsigned char>> GetOutputImages(std::vector<unsigned char>& buffer) const ;
+
+
+protected:
+    std::vector<StreamInfo> streams;
+    Uri uri;
+    std::unique_ptr<VideoOutputInterface> recorder;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_output_interface.h

@@ -0,0 +1,52 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <vector>
+#include <pangolin/platform.h>
+#include <pangolin/video/stream_info.h>
+#include <pangolin/utils/picojson.h>
+
+namespace pangolin {
+
+//! Interface to video recording destinations
+struct PANGOLIN_EXPORT VideoOutputInterface
+{
+    virtual ~VideoOutputInterface() {}
+
+    //! Get format and dimensions of all video streams
+    virtual const std::vector<StreamInfo>& Streams() const = 0;
+
+    virtual void SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri ="", const picojson::value& properties = picojson::value() ) = 0;
+
+    virtual int WriteStreams(const unsigned char* data, const picojson::value& frame_properties = picojson::value() ) = 0;
+
+    virtual bool IsPipe() const = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/video_record_repeat.h

@@ -0,0 +1,31 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+// VideoInput subsumes the previous VideoRecordRepeat class.
+#include <pangolin/video/video_input.h>

third-party/DPVO/Pangolin/components/pango_video/src/drivers/debayer.cpp

@@ -0,0 +1,392 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/debayer.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+#ifdef HAVE_DC1394
+#   include <dc1394/conversions.h>
+    const bool have_dc1394 = true;
+#else
+    const bool have_dc1394 = false;
+#endif
+
+namespace pangolin
+{
+
+pangolin::StreamInfo BayerOutputFormat( const StreamInfo& stream_in, bayer_method_t method, size_t start_offset)
+{
+    const bool downsample = (method == BAYER_METHOD_DOWNSAMPLE) || (method == BAYER_METHOD_DOWNSAMPLE_MONO);
+
+    const size_t w = downsample ? stream_in.Width() / 2 : stream_in.Width();
+    const size_t h = downsample ? stream_in.Height() / 2 : stream_in.Height();
+
+    pangolin::PixelFormat fmt =
+        (method == BAYER_METHOD_NONE) ?
+            stream_in.PixFormat() :
+            pangolin::PixelFormatFromString(
+                (stream_in.PixFormat().bpp == 16) ?
+                (method == BAYER_METHOD_DOWNSAMPLE_MONO ? "GRAY16LE" : "RGB48") :
+                (method == BAYER_METHOD_DOWNSAMPLE_MONO ? "GRAY8" : "RGB24")
+            );
+
+    fmt.channel_bit_depth = stream_in.PixFormat().channel_bit_depth;
+
+    return pangolin::StreamInfo( fmt, w, h, w*fmt.bpp / 8, reinterpret_cast<unsigned char*>(start_offset) );
+}
+
+DebayerVideo::DebayerVideo(std::unique_ptr<VideoInterface> &src_, const std::vector<bayer_method_t>& bayer_method, color_filter_t tile, const WbGains& input_wb_gains)
+    : src(std::move(src_)), size_bytes(0), methods(bayer_method), tile(tile), wb_gains(input_wb_gains)
+{
+    if(!src.get()) {
+        throw VideoException("DebayerVideo: VideoInterface in must not be null");
+    }
+    videoin.push_back(src.get());
+
+    while(methods.size() < src->Streams().size()) {
+        methods.push_back(BAYER_METHOD_NONE);
+    }
+
+    for(size_t s=0; s< src->Streams().size(); ++s) {
+        if( (methods[s] < BAYER_METHOD_NONE) && (!have_dc1394 || src->Streams()[0].IsPitched()) ) {
+            pango_print_warn("debayer: Switching to simple downsampling method because No DC1394 or image is pitched.\n");
+            methods[s] = BAYER_METHOD_DOWNSAMPLE;
+        }
+
+        const StreamInfo& stin = src->Streams()[s];
+        streams.push_back(BayerOutputFormat(stin, methods[s], size_bytes));
+        size_bytes += streams.back().SizeBytes();
+    }
+    buffer = std::unique_ptr<unsigned char[]>(new unsigned char[src->SizeBytes()]);
+}
+
+DebayerVideo::~DebayerVideo()
+{
+}
+
+//! Implement VideoInput::Start()
+void DebayerVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+//! Implement VideoInput::Stop()
+void DebayerVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t DebayerVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& DebayerVideo::Streams() const
+{
+    return streams;
+}
+
+
+unsigned int DebayerVideo::AvailableFrames() const
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Debayer: child interface is not buffer aware.");
+        return 0;
+    }
+    else
+    {
+        return vpi->AvailableFrames();
+    }
+}
+
+bool DebayerVideo::DropNFrames(uint32_t n)
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Debayer: child interface is not buffer aware.");
+        return false;
+    }
+    else
+    {
+        return vpi->DropNFrames(n);
+    }
+}
+
+template<typename Tup, typename Tout, typename Tin>
+void DownsampleToMono(Image<Tout>& out, const Image<Tin>& in)
+{
+    for(int y=0; y< (int)out.h; ++y) {
+      Tout* pixout = out.RowPtr(y);
+      const Tin* irow0 = in.RowPtr(2*y);
+      const Tin* irow1 = in.RowPtr(2*y+1);
+      for(size_t x=0; x<out.w; ++x) {
+          Tup val = ((Tup)irow0[0] + (Tup)irow0[1] + (Tup)irow1[0] + (Tup)irow1[1]) / 4;
+          *(pixout++) = (Tout)std::min(std::max(static_cast<Tup>(0), val), static_cast<Tup>(std::numeric_limits<Tout>::max()));
+          irow0 += 2;
+          irow1 += 2;
+      }
+    }
+}
+
+template<typename Tout, typename Tin>
+void DownsampleDebayer(Image<Tout>& out, const Image<Tin>& in, color_filter_t tile, WbGains wb_gains, const bool has_metadata_line)
+{
+    int y_offset = 0;
+    if (has_metadata_line) {
+        ++y_offset;
+    }
+
+    switch(tile) {
+      case DC1394_COLOR_FILTER_RGGB:
+        for(int y=0; y< (int)out.h; ++y) {
+          Tout* pixout = out.RowPtr(y);
+          const Tin* irow0 = in.RowPtr(2*y+y_offset);
+          const Tin* irow1 = in.RowPtr(2*y+1+y_offset);
+          for(size_t x=0; x<out.w; ++x) {
+              *(pixout++) = irow0[2*x] * wb_gains.r;
+              *(pixout++) = ((irow0[2*x+1] + irow1[2*x]) >> 1) * wb_gains.g;
+              *(pixout++) = irow1[2*x+1] * wb_gains.b;
+          }
+        }
+        break;
+      case DC1394_COLOR_FILTER_GBRG:
+        for(int y=0; y< (int)out.h; ++y) {
+          Tout* pixout = out.RowPtr(y);
+          const Tin* irow0 = in.RowPtr(2*y+y_offset);
+          const Tin* irow1 = in.RowPtr(2*y+1+y_offset);
+          for(size_t x=0; x<out.w; ++x) {
+             *(pixout++) = irow1[2*x] * wb_gains.r;
+             *(pixout++) = ((irow0[2*x] + irow1[2*x+1]) >> 1) * wb_gains.g;
+             *(pixout++) = irow0[2*x+1] * wb_gains.b;
+          }
+        }
+        break;
+      case DC1394_COLOR_FILTER_GRBG:
+        for(int y=0; y< (int)out.h; ++y) {
+          Tout* pixout = out.RowPtr(y);
+          const Tin* irow0 = in.RowPtr(2*y+y_offset);
+          const Tin* irow1 = in.RowPtr(2*y+1+y_offset);
+          for(size_t x=0; x<out.w; ++x) {
+             *(pixout++) = irow0[2*x+1] * wb_gains.r;
+             *(pixout++) = ((irow0[2*x] + irow1[2*x+1]) >> 1) * wb_gains.g;
+             *(pixout++) = irow1[2*x] * wb_gains.b;
+          }
+        }
+        break;
+      case DC1394_COLOR_FILTER_BGGR:
+        for(int y=0; y< (int)out.h; ++y) {
+          Tout* pixout = out.RowPtr(y);
+          const Tin* irow0 = in.RowPtr(2*y+y_offset);
+          const Tin* irow1 = in.RowPtr(2*y+1+y_offset);
+          for(size_t x=0; x<out.w; ++x) {
+             *(pixout++) = irow1[2*x+1] * wb_gains.r;
+             *(pixout++) = ((irow0[2*x+1] + irow1[2*x]) >> 1) * wb_gains.g;
+             *(pixout++) = irow0[2*x] * wb_gains.b;
+          }
+        }
+        break;
+    }
+}
+
+template<typename T>
+void PitchedImageCopy( Image<T>& img_out, const Image<T>& img_in ) {
+    if( img_out.w != img_in.w || img_out.h != img_in.h || sizeof(T) * img_in.w > img_out.pitch) {
+        throw std::runtime_error("PitchedImageCopy: Incompatible image sizes");
+    }
+
+    for(size_t y=0; y < img_out.h; ++y) {
+        std::memcpy(img_out.RowPtr((int)y), img_in.RowPtr((int)y), sizeof(T) * img_in.w);
+    }
+}
+
+template<typename Tout, typename Tin>
+void ProcessImage(Image<Tout>& img_out, const Image<Tin>& img_in, bayer_method_t method, color_filter_t tile, WbGains wb_gains, const bool has_metadata_line)
+{
+    if(method == BAYER_METHOD_NONE) {
+        PitchedImageCopy(img_out, img_in.template UnsafeReinterpret<Tout>() );
+    }else if(method == BAYER_METHOD_DOWNSAMPLE_MONO) {
+        if( sizeof(Tout) == 1) {
+            DownsampleToMono<int,Tout, Tin>(img_out, img_in);
+        }else{
+            DownsampleToMono<double,Tout, Tin>(img_out, img_in);
+        }
+    }else if(method == BAYER_METHOD_DOWNSAMPLE) {
+        DownsampleDebayer(img_out, img_in, tile, wb_gains, has_metadata_line);
+    }else{
+#ifdef HAVE_DC1394
+        if(sizeof(Tout) == 1) {
+            dc1394_bayer_decoding_8bit(
+                (uint8_t*)img_in.ptr, (uint8_t*)img_out.ptr, img_in.w, img_in.h,
+                (dc1394color_filter_t)tile, (dc1394bayer_method_t)method
+            );
+        }else if(sizeof(Tout) == 2) {
+            dc1394_bayer_decoding_16bit(
+                (uint16_t*)img_in.ptr, (uint16_t*)img_out.ptr, img_in.w, img_in.h,
+                (dc1394color_filter_t)tile, (dc1394bayer_method_t)method,
+                16
+            );
+        }
+#endif
+    }
+}
+
+void DebayerVideo::ProcessStreams(unsigned char* out, const unsigned char *in)
+{
+    const bool has_metadata_line = frame_properties.get_value<bool>(PANGO_HAS_LINE0_METADATA, false);
+
+    for(size_t s=0; s<streams.size(); ++s) {
+        const StreamInfo& stin = videoin[0]->Streams()[s];
+        Image<unsigned char> img_in  = stin.StreamImage(in);
+        Image<unsigned char> img_out = Streams()[s].StreamImage(out);
+
+        if(methods[s] == BAYER_METHOD_NONE) {
+            const size_t num_bytes = std::min(img_in.w, img_out.w) * stin.PixFormat().bpp / 8;
+            for(size_t y=0; y < img_out.h; ++y) {
+                std::memcpy(img_out.RowPtr((int)y), img_in.RowPtr((int)y), num_bytes);
+            }
+        }else if(stin.PixFormat().bpp == 8) {
+            ProcessImage(img_out, img_in, methods[s], tile, wb_gains, has_metadata_line);
+        }else if(stin.PixFormat().bpp == 16){
+            Image<uint16_t> img_in16  = img_in.UnsafeReinterpret<uint16_t>();
+            Image<uint16_t> img_out16 = img_out.UnsafeReinterpret<uint16_t>();
+            ProcessImage(img_out16, img_in16, methods[s], tile, wb_gains, has_metadata_line);
+        }else {
+            throw std::runtime_error("debayer: unhandled format combination: " + stin.PixFormat().format );
+        }
+    }
+}
+
+//! Implement VideoInput::GrabNext()
+bool DebayerVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNext(buffer.get(),wait)) {
+        frame_properties = GetVideoFrameProperties(videoin[0]);
+        ProcessStreams(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool DebayerVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNewest(buffer.get(),wait)) {
+        frame_properties = GetVideoFrameProperties(videoin[0]);
+        ProcessStreams(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& DebayerVideo::InputStreams()
+{
+    return videoin;
+}
+
+color_filter_t DebayerVideo::ColorFilterFromString(std::string str)
+{
+  if(!str.compare("rggb") || !str.compare("RGGB")) return DC1394_COLOR_FILTER_RGGB;
+  else if(!str.compare("gbrg") || !str.compare("GBRG")) return DC1394_COLOR_FILTER_GBRG;
+  else if(!str.compare("grbg") || !str.compare("GRBG")) return DC1394_COLOR_FILTER_GRBG;
+  else if(!str.compare("bggr") || !str.compare("BGGR")) return DC1394_COLOR_FILTER_BGGR;
+  else {
+     pango_print_error("Debayer error, %s is not a valid tile type using RGGB\n", str.c_str());
+     return DC1394_COLOR_FILTER_RGGB;
+  }
+}
+
+bayer_method_t DebayerVideo::BayerMethodFromString(std::string str)
+{
+  if(!str.compare("nearest")) return BAYER_METHOD_NEAREST;
+  else if(!str.compare("simple")) return BAYER_METHOD_SIMPLE;
+  else if(!str.compare("bilinear")) return BAYER_METHOD_BILINEAR;
+  else if(!str.compare("hqlinear")) return BAYER_METHOD_HQLINEAR;
+  else if(!str.compare("downsample")) return BAYER_METHOD_DOWNSAMPLE;
+  else if(!str.compare("edgesense")) return BAYER_METHOD_EDGESENSE;
+  else if(!str.compare("vng")) return BAYER_METHOD_VNG;
+  else if(!str.compare("ahd")) return BAYER_METHOD_AHD;
+  else if(!str.compare("mono")) return BAYER_METHOD_DOWNSAMPLE_MONO;
+  else if(!str.compare("none")) return BAYER_METHOD_NONE;
+  else {
+     pango_print_error("Debayer error, %s is not a valid debayer method using downsample\n", str.c_str());
+     return BAYER_METHOD_DOWNSAMPLE;
+  }
+}
+
+PANGOLIN_REGISTER_FACTORY(DebayerVideo)
+{
+    struct DebayerVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"debayer",10}};
+        }
+        const char* Description() const override
+        {
+            return "Demosaics raw RGB sensor data (one or multiple streams) to RGB images";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"tile","rggb","Tiling pattern: possible values: rggb,gbrg,grbg,bggr"},
+                {"method(\\d+)?","none","method, or methodN for multiple sub-streams, N >= 1. Possible values: nearest,simple,bilinear,hqlinear,downsample,edgesense,vng,ahd,mono,none. For methodN, the default values are set to the value of method."},
+                {"wb_r","1.0","White balance - red component"},
+                {"wb_g","1.0","White balance - green component"},
+                {"wb_b","1.0","White balance - blue component"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(DebayerVideoFactory::Params(),uri);
+
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            const std::string tile_string = reader.Get<std::string>("tile");
+            const std::string method = reader.Get<std::string>("method");
+            const color_filter_t tile = DebayerVideo::ColorFilterFromString(tile_string);
+            WbGains input_wb_gains(reader.Get<float>("wb_r"), reader.Get<float>("wb_g"), reader.Get<float>("wb_b"));
+
+            std::vector<bayer_method_t> methods;
+            for(size_t s=0; s < subvid->Streams().size(); ++s) {
+                const std::string key = std::string("method") + ToString(s+1);
+                std::string method_s = reader.Get<std::string>(key, method);
+                methods.push_back(DebayerVideo::BayerMethodFromString(method_s));
+            }
+            return std::unique_ptr<VideoInterface>( new DebayerVideo(subvid, methods, tile, input_wb_gains) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>( std::make_shared<DebayerVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/deinterlace.cpp

@@ -0,0 +1,121 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/deinterlace.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <dc1394/conversions.h>
+#include <pangolin/video/video.h>
+
+namespace pangolin
+{
+
+DeinterlaceVideo::DeinterlaceVideo(std::unique_ptr<VideoInterface> &videoin_)
+    : videoin(std::move(videoin_)), buffer(0)
+{
+    if(videoin->Streams().size() != 1)
+        throw VideoException("FirewireDeinterlace input must have exactly one stream");
+
+    const StreamInfo& stmin = videoin->Streams()[0];
+
+    StreamInfo stm1(PixelFormatFromString("GRAY8"), stmin.Width(), stmin.Height(), stmin.Width(), 0);
+    StreamInfo stm2(PixelFormatFromString("GRAY8"), stmin.Width(), stmin.Height(), stmin.Width(), (unsigned char*)0 + stmin.Width()*stmin.Height());
+    streams.push_back(stm1);
+    streams.push_back(stm2);
+
+    buffer = new unsigned char[videoin->SizeBytes()];
+
+    std::cout << videoin->Streams()[0].Width() << ", " << videoin->Streams()[0].Height() << std::endl;
+}
+
+DeinterlaceVideo::~DeinterlaceVideo()
+{
+    delete[] buffer;
+}
+
+size_t DeinterlaceVideo::SizeBytes() const
+{
+    return videoin->SizeBytes();
+}
+
+const std::vector<StreamInfo>& DeinterlaceVideo::Streams() const
+{
+    return streams;
+}
+
+void DeinterlaceVideo::Start()
+{
+    videoin->Start();
+}
+
+void DeinterlaceVideo::Stop()
+{
+    videoin->Stop();
+}
+
+bool DeinterlaceVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(videoin->GrabNext(buffer, wait)) {
+        return ( dc1394_deinterlace_stereo(buffer,image, videoin->Streams()[0].Width(), 2*videoin->Streams()[0].Height() ) == DC1394_SUCCESS );
+    }
+    return false;
+}
+
+bool DeinterlaceVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    if(videoin->GrabNewest(buffer, wait)) {
+        return ( dc1394_deinterlace_stereo(buffer,image, videoin->Streams()[0].Width(), 2*videoin->Streams()[0].Height() ) == DC1394_SUCCESS );
+    }
+    return false;
+}
+
+PANGOLIN_REGISTER_FACTORY(DeinterlaceVideo)
+{
+    struct DeinterlaceVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"deinterlace",10}};
+        }
+        const char* Description() const override
+        {
+            return "Deinterlace sub-video.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            return std::unique_ptr<VideoInterface>( new DeinterlaceVideo(subvid) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<DeinterlaceVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/depthsense.cpp

@@ -0,0 +1,656 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/depthsense.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <iomanip>
+
+namespace pangolin
+{
+
+const size_t ROGUE_ADDR = 0x01;
+const double MAX_DELTA_TIME = 20000.0; //u_s
+
+DepthSenseContext& DepthSenseContext::I()
+{
+    static DepthSenseContext s;
+    return s;
+}
+
+DepthSense::Context& DepthSenseContext::Context()
+{
+    return g_context;
+}
+
+void DepthSenseContext::NewDeviceRunning()
+{
+    running_devices++;
+    if(running_devices == 1) {
+        StartNodes();
+    }
+}
+
+void DepthSenseContext::DeviceClosing()
+{
+    running_devices--;
+    if(running_devices == 0) {
+        StopNodes();
+
+        // Force destruction of current context
+        g_context = DepthSense::Context();
+    }
+}
+
+DepthSenseVideo* DepthSenseContext::GetDepthSenseVideo(size_t device_num, DepthSenseSensorType s1, DepthSenseSensorType s2, ImageDim dim1, ImageDim dim2, unsigned int fps1, unsigned int fps2, const Uri& uri)
+{
+    if(running_devices == 0) {
+        // Initialise SDK
+        g_context = DepthSense::Context::create("localhost");
+    }
+
+    // Get the list of currently connected devices
+    std::vector<DepthSense::Device> da = g_context.getDevices();
+
+    if( da.size() > device_num )
+    {
+        return new DepthSenseVideo(da[device_num], s1, s2, dim1, dim2, fps1, fps2, uri);
+    }
+
+    throw VideoException("DepthSense device not connected.");
+}
+
+DepthSenseContext::DepthSenseContext()
+    : is_running(false), running_devices(0)
+{
+}
+
+DepthSenseContext::~DepthSenseContext()
+{
+    StopNodes();
+}
+
+
+void DepthSenseContext::StartNodes()
+{
+    if(!is_running) {
+        // Launch EventLoop thread
+        event_thread = std::thread(&DepthSenseContext::EventLoop, this );
+    }
+}
+
+void DepthSenseContext::StopNodes()
+{
+    if(is_running && event_thread.joinable()) {
+        g_context.quit();
+        event_thread.join();
+    }
+}
+
+void DepthSenseContext::EventLoop()
+{
+    is_running = true;
+    g_context.startNodes();
+    g_context.run();
+    g_context.stopNodes();
+    is_running = false;
+}
+
+DepthSenseVideo::DepthSenseVideo(DepthSense::Device device, DepthSenseSensorType s1, DepthSenseSensorType s2, ImageDim dim1, ImageDim dim2, unsigned int fps1, unsigned int fps2, const Uri& uri)
+    : device(device), fill_image(0), depthmap_stream(-1), rgb_stream(-1), gotDepth(0), gotColor(0),
+      enableDepth(false), enableColor(false), depthTs(0.0), colorTs(0.0), size_bytes(0)
+{
+    streams_properties = &frame_properties["streams"];
+    *streams_properties = picojson::value(picojson::array_type, false);
+    streams_properties->get<picojson::array>().resize(2);
+
+    sensorConfig[0] = {s1, dim1, fps1};
+    sensorConfig[1] = {s2, dim2, fps2};
+    ConfigureNodes(uri);
+
+    DepthSenseContext::I().NewDeviceRunning();
+}
+
+DepthSenseVideo::~DepthSenseVideo()
+{
+    if (g_cnode.isSet()) DepthSenseContext::I().Context().unregisterNode(g_cnode);
+    if (g_dnode.isSet()) DepthSenseContext::I().Context().unregisterNode(g_dnode);
+
+    fill_image = (unsigned char*)ROGUE_ADDR;
+    cond_image_requested.notify_all();
+
+    DepthSenseContext::I().DeviceClosing();
+}
+
+picojson::value Json(DepthSense::IntrinsicParameters& p)
+{
+    picojson::value js;
+    js["model"] = "polynomial";
+    js["width"] = p.width;
+    js["height"] = p.height;
+    js["RDF"] = "[1,0,0; 0,1,0; 0,0,1]";
+
+    js["fx"] = p.fx;
+    js["fy"] = p.fy;
+    js["u0"] = p.cx;
+    js["v0"] = p.cy;
+    js["k1"] = p.k1;
+    js["k2"] = p.k2;
+    js["k3"] = p.k3;
+    js["p1"] = p.p1;
+    js["p2"] = p.p2;
+
+    return js;
+}
+
+picojson::value Json(DepthSense::ExtrinsicParameters& p)
+{
+    picojson::value js;
+    js["rows"] = "3";
+    js["cols"] = "4";
+
+    std::ostringstream oss;
+    oss << std::setprecision(17);
+    oss << "[" << p.r11 << "," << p.r12 << "," << p.r13 << "," << p.t1 << ";";
+    oss        << p.r21 << "," << p.r22 << "," << p.r23 << "," << p.t2 << ";";
+    oss        << p.r31 << "," << p.r32 << "," << p.r33 << "," << p.t3 << "]";
+
+    js["data"] = oss.str();
+    return js;
+}
+
+void DepthSenseVideo::ConfigureNodes(const Uri& uri)
+{
+    std::vector<DepthSense::Node> nodes = device.getNodes();
+
+    for (int i = 0; i<2; ++i)
+    {
+        switch (sensorConfig[i].type)
+        {
+        case DepthSenseDepth:
+        {
+            for (int n = 0; n < (int)nodes.size(); n++)
+            {
+                DepthSense::Node node = nodes[n];
+                if ((node.is<DepthSense::DepthNode>()) && (!g_dnode.isSet()))
+                {
+                    depthmap_stream = i;
+                    g_dnode = node.as<DepthSense::DepthNode>();
+                    ConfigureDepthNode(sensorConfig[i], uri);
+                    DepthSenseContext::I().Context().registerNode(node);
+                }
+            }
+            break;
+        }
+        case DepthSenseRgb:
+        {
+            for (int n = 0; n < (int)nodes.size(); n++)
+            {
+                DepthSense::Node node = nodes[n];
+                if ((node.is<DepthSense::ColorNode>()) && (!g_cnode.isSet()))
+                {
+                    rgb_stream = i;
+                    g_cnode = node.as<DepthSense::ColorNode>();
+                    ConfigureColorNode(sensorConfig[i], uri);
+                    DepthSenseContext::I().Context().registerNode(node);
+                }
+            }
+            break;
+        }
+        default:
+            continue;
+        }
+    }
+
+    DepthSense::StereoCameraParameters scp = device.getStereoCameraParameters();
+
+    //Set json device properties for intrinsics and extrinsics
+    picojson::value& jsintrinsics = device_properties["intrinsics"];
+    if (jsintrinsics.is<picojson::null>()) {
+        jsintrinsics = picojson::value(picojson::array_type, false);
+        jsintrinsics.get<picojson::array>().resize(streams.size());
+        if (depthmap_stream >= 0) jsintrinsics[depthmap_stream] = Json(scp.depthIntrinsics);
+        if (rgb_stream >= 0) jsintrinsics[rgb_stream] = Json(scp.colorIntrinsics);
+    }
+
+    picojson::value& jsextrinsics = device_properties["extrinsics"];
+    if(jsextrinsics.is<picojson::null>()){
+        jsextrinsics = Json(scp.extrinsics);
+    }
+}
+
+inline DepthSense::FrameFormat ImageDim2FrameFormat(const ImageDim& dim)
+{
+    DepthSense::FrameFormat retVal = DepthSense::FRAME_FORMAT_UNKNOWN;
+    if(dim.x == 160 && dim.y == 120)
+    {
+        retVal = DepthSense::FRAME_FORMAT_QQVGA;
+    }
+    else if(dim.x == 176 && dim.y == 144)
+    {
+        retVal = DepthSense::FRAME_FORMAT_QCIF;
+    }
+    else if(dim.x == 240 && dim.y == 160)
+    {
+        retVal = DepthSense::FRAME_FORMAT_HQVGA;
+    }
+    else if(dim.x == 320 && dim.y == 240)
+    {
+        retVal = DepthSense::FRAME_FORMAT_QVGA;
+    }
+    else if(dim.x == 352 && dim.y == 288)
+    {
+        retVal = DepthSense::FRAME_FORMAT_CIF;
+    }
+    else if(dim.x == 480 && dim.y == 320)
+    {
+        retVal = DepthSense::FRAME_FORMAT_HVGA;
+    }
+    else if(dim.x == 640 && dim.y == 480)
+    {
+        retVal = DepthSense::FRAME_FORMAT_VGA;
+    }
+    else if(dim.x == 1280 && dim.y == 720)
+    {
+        retVal = DepthSense::FRAME_FORMAT_WXGA_H;
+    }
+    else if(dim.x == 320 && dim.y == 120)
+    {
+        retVal = DepthSense::FRAME_FORMAT_DS311;
+    }
+    else if(dim.x == 1024 && dim.y == 768)
+    {
+        retVal = DepthSense::FRAME_FORMAT_XGA;
+    }
+    else if(dim.x == 800 && dim.y == 600)
+    {
+        retVal = DepthSense::FRAME_FORMAT_SVGA;
+    }
+    else if(dim.x == 636 && dim.y == 480)
+    {
+        retVal = DepthSense::FRAME_FORMAT_OVVGA;
+    }
+    else if(dim.x == 640 && dim.y == 240)
+    {
+        retVal = DepthSense::FRAME_FORMAT_WHVGA;
+    }
+    else if(dim.x == 640 && dim.y == 360)
+    {
+        retVal = DepthSense::FRAME_FORMAT_NHD;
+    }
+    return retVal;
+}
+
+void DepthSenseVideo::UpdateParameters(const DepthSense::Node& node, const Uri& uri)
+{
+    DepthSense::Type type = node.getType();
+    picojson::value& jsnode = device_properties[type.name()];
+
+    std::vector<DepthSense::PropertyBase> properties = type.getProperties();
+    for(std::vector<DepthSense::PropertyBase>::const_iterator it = properties.begin(); it != properties.end(); ++it) {
+        const DepthSense::PropertyBase& prop = *it;
+
+        if (prop.is<DepthSense::Property<int32_t> >()) {
+            DepthSense::Property<int32_t> tprop = prop.as<DepthSense::Property<int32_t> >();
+            if (uri.Contains(prop.name())) {
+                if (!prop.isReadOnly()) {
+                    tprop.setValue(node, uri.Get<int32_t>(prop.name(), tprop.getValue(node)));
+                } else {
+                    pango_print_warn("DepthSense property '%s' is read-only\n", prop.name().c_str() );
+                }
+            }
+            jsnode[prop.name()] = tprop.getValue(node);
+        } else if (prop.is<DepthSense::Property<float> >()) {
+            DepthSense::Property<float> tprop = prop.as<DepthSense::Property<float> >();
+            if (uri.Contains(prop.name())) {
+                if (!prop.isReadOnly()) {
+                    tprop.setValue(node, uri.Get<float>(prop.name(), tprop.getValue(node)));
+                } else {
+                    pango_print_warn("DepthSense property '%s' is read-only\n", prop.name().c_str() );
+                }
+            }
+            jsnode[prop.name()] = tprop.getValue(node);
+        } else if (prop.is<DepthSense::Property<bool> >()) {
+            DepthSense::Property<bool> tprop = prop.as<DepthSense::Property<bool> >();
+            if (uri.Contains(prop.name())) {
+                if (!prop.isReadOnly()) {
+                    tprop.setValue(node, uri.Get<bool>(prop.name(), tprop.getValue(node)));
+                } else {
+                    pango_print_warn("DepthSense property '%s' is read-only\n", prop.name().c_str() );
+                }
+            }
+            jsnode[prop.name()] = tprop.getValue(node);
+        } else if (prop.is<DepthSense::Property<std::string> >()){
+            DepthSense::Property<std::string> tprop = prop.as<DepthSense::Property<std::string> >();
+            if (uri.Contains(prop.name())) {
+                if (!prop.isReadOnly()) {
+                    tprop.setValue(node, uri.Get<std::string>(prop.name(), tprop.getValue(node)).c_str() );
+                } else {
+                    pango_print_warn("DepthSense property '%s' is read-only\n", prop.name().c_str() );
+                }
+            }
+            jsnode[prop.name()] = tprop.getValue(node);
+        }
+    }
+}
+
+void DepthSenseVideo::ConfigureDepthNode(const SensorConfig& sensorConfig, const Uri& uri)
+{
+    g_dnode.newSampleReceivedEvent().connect(this, &DepthSenseVideo::onNewDepthSample);
+
+    DepthSense::DepthNode::Configuration config = g_dnode.getConfiguration();
+
+    config.frameFormat = ImageDim2FrameFormat(sensorConfig.dim);
+    config.framerate = sensorConfig.fps;
+    config.mode = DepthSense::DepthNode::CAMERA_MODE_CLOSE_MODE;
+    config.saturation = true;
+
+    try {
+        DepthSenseContext::I().Context().requestControl(g_dnode, 0);
+        g_dnode.setConfiguration(config);
+        g_dnode.setEnableDepthMap(true);
+    } catch (DepthSense::Exception& e) {
+        throw pangolin::VideoException("DepthSense exception whilst configuring node", e.what());
+    }
+
+    //Set pangolin stream for this channel
+    const int w = sensorConfig.dim.x;
+    const int h = sensorConfig.dim.y;
+
+    const PixelFormat pfmt = PixelFormatFromString("GRAY16LE");
+
+    const StreamInfo stream_info(pfmt, w, h, (w*pfmt.bpp) / 8, (unsigned char*)0);
+    streams.push_back(stream_info);
+
+    size_bytes += stream_info.SizeBytes();
+
+    enableDepth = true;
+
+    UpdateParameters(g_dnode, uri);
+}
+
+void DepthSenseVideo::ConfigureColorNode(const SensorConfig& sensorConfig, const Uri& uri)
+{
+    // connect new color sample handler
+    g_cnode.newSampleReceivedEvent().connect(this, &DepthSenseVideo::onNewColorSample);
+
+    DepthSense::ColorNode::Configuration config = g_cnode.getConfiguration();
+    config.frameFormat = ImageDim2FrameFormat(sensorConfig.dim);
+    config.compression = DepthSense::COMPRESSION_TYPE_MJPEG;
+    config.powerLineFrequency = DepthSense::POWER_LINE_FREQUENCY_50HZ;
+    config.framerate = sensorConfig.fps;
+
+    try {
+        DepthSenseContext::I().Context().requestControl(g_cnode,0);
+        g_cnode.setConfiguration(config);
+        g_cnode.setEnableColorMap(true);
+        UpdateParameters(g_cnode, uri);
+    } catch (DepthSense::Exception& e) {
+        throw pangolin::VideoException("DepthSense exception whilst configuring node", e.what());
+    }
+
+    //Set pangolin stream for this channel
+    const int w = sensorConfig.dim.x;
+    const int h = sensorConfig.dim.y;
+
+    const PixelFormat pfmt = PixelFormatFromString("BGR24");
+
+    const StreamInfo stream_info(pfmt, w, h, (w*pfmt.bpp) / 8, (unsigned char*)0 + size_bytes);
+    streams.push_back(stream_info);
+
+    size_bytes += stream_info.SizeBytes();
+
+    enableColor = true;
+}
+
+void DepthSenseVideo::onNewColorSample(DepthSense::ColorNode node, DepthSense::ColorNode::NewSampleReceivedData data)
+{
+    {
+        std::unique_lock<std::mutex> lock(update_mutex);
+
+        // Wait for fill request
+        while (!fill_image) {
+            cond_image_requested.wait(lock);
+        }
+
+        // Update per-frame parameters
+        //printf("Color delta: %.1f\n", fabs(colorTs - data.timeOfCapture));
+        colorTs = data.timeOfCapture;
+        picojson::value& jsstream = frame_properties["streams"][rgb_stream];
+        jsstream["time_us"] = data.timeOfCapture;
+
+        if (fill_image != (unsigned char*)ROGUE_ADDR) {
+            // Fill with data
+            unsigned char* imagePtr = fill_image;
+            bool copied = false;
+            for (int i = 0; !copied && i < 2; ++i)
+            {
+                switch (sensorConfig[i].type)
+                {
+                case DepthSenseDepth:
+                {
+                    imagePtr += streams[i].SizeBytes();
+                    break;
+                }
+                case DepthSenseRgb:
+                {
+                    // Leave as BGR
+                    std::memcpy(imagePtr, data.colorMap, streams[i].SizeBytes());
+                    copied = true;
+                    break;
+                }
+                default:
+                    continue;
+                }
+            }
+            gotColor++;
+        }
+
+        //printf("Got color at: %.1f\n", colorTs);
+
+        if(gotDepth)
+        {
+            double delta = fabs(GetDeltaTime());
+            if(delta > MAX_DELTA_TIME)
+            {
+                //printf("**** Waiting for another depth, delta: %.1f ****\n", delta);
+                gotDepth = 0;
+                return;
+            }
+        }
+    }
+
+    cond_image_filled.notify_one();
+}
+
+void DepthSenseVideo::onNewDepthSample(DepthSense::DepthNode node, DepthSense::DepthNode::NewSampleReceivedData data)
+{
+    {
+        std::unique_lock<std::mutex> lock(update_mutex);
+
+        // Wait for fill request
+        while(!fill_image) {
+            cond_image_requested.wait(lock);
+        }
+
+        // Update per-frame parameters
+        //printf("Depth delta: %.1f\n", fabs(depthTs - data.timeOfCapture));
+        depthTs = data.timeOfCapture;
+
+        picojson::value& jsstream = frame_properties["streams"][depthmap_stream];
+        jsstream["time_us"] = depthTs;
+
+        if(fill_image != (unsigned char*)ROGUE_ADDR) {
+            // Fill with data
+            unsigned char* imagePtr = fill_image;
+            bool copied = false;
+            for (int i = 0; i < 2; ++i)
+            {
+                switch (sensorConfig[i].type)
+                {
+                case DepthSenseDepth:
+                {
+                    memcpy(imagePtr, data.depthMap, streams[i].SizeBytes());
+                    copied = true;
+                    break;
+                }
+                case DepthSenseRgb:
+                {
+                    imagePtr += streams[i].SizeBytes();
+                    break;
+                }
+                default:
+                    continue;
+                }
+                if(copied)
+                {
+                    break;
+                }
+            }
+            gotDepth++;
+        }
+
+        //printf("Got depth at: %.1f\n", depthTs);
+
+        if(gotColor)
+        {
+            double delta = fabs(GetDeltaTime());
+            if(delta > MAX_DELTA_TIME)
+            {
+                //printf("**** Waiting for another color, delta: %.1f ****\n", delta);
+                gotColor = 0;
+                return;
+            }
+        }
+    }
+
+    cond_image_filled.notify_one();
+}
+
+void DepthSenseVideo::Start()
+{
+}
+
+void DepthSenseVideo::Stop()
+{
+}
+
+size_t DepthSenseVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+const std::vector<StreamInfo>& DepthSenseVideo::Streams() const
+{
+    return streams;
+}
+
+bool DepthSenseVideo::GrabNext( unsigned char* image, bool /*wait*/ )
+{
+    if(fill_image) {
+        throw std::runtime_error("GrabNext Cannot be called concurrently");
+    }
+
+    //printf("#### Grab Next ####\n");
+
+    // Request that image is filled with data
+    fill_image = image;
+    cond_image_requested.notify_one();
+
+    // Wait until it has been filled successfully.
+    {
+        std::unique_lock<std::mutex> lock(update_mutex);
+        while ((enableDepth && !gotDepth) || (enableColor && !gotColor))
+        {
+            cond_image_filled.wait(lock);
+        }
+
+        if (gotDepth)
+        {
+            gotDepth = 0;
+        }
+        if (gotColor)
+        {
+            gotColor = 0;
+        }
+        fill_image = 0;
+    }
+
+    //printf("Delta time: %.1f\n", fabs(GetDeltaTime()));
+
+    return true;
+}
+
+bool DepthSenseVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image,wait);
+}
+
+double DepthSenseVideo::GetDeltaTime() const
+{
+    return depthTs - colorTs;
+}
+
+DepthSenseSensorType depthsense_sensor(const std::string& str)
+{
+    if (!str.compare("rgb")) {
+        return DepthSenseRgb;
+    }
+    else if (!str.compare("depth")) {
+        return DepthSenseDepth;
+    }
+    else if (str.empty()) {
+        return DepthSenseUnassigned;
+    }
+    else{
+        throw pangolin::VideoException("Unknown DepthSense sensor", str);
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(DepthSenseVideo)
+{
+    struct DepthSenseVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            DepthSenseSensorType img1 = depthsense_sensor(uri.Get<std::string>("img1", "depth"));
+            DepthSenseSensorType img2 = depthsense_sensor(uri.Get<std::string>("img2", ""));
+
+            const ImageDim dim1 = uri.Get<ImageDim>("size1", img1 == DepthSenseDepth ? ImageDim(320, 240) : ImageDim(640, 480) );
+            const ImageDim dim2 = uri.Get<ImageDim>("size2", img2 == DepthSenseDepth ? ImageDim(320, 240) : ImageDim(640, 480) );
+
+            const unsigned int fps1 = uri.Get<unsigned int>("fps1", 30);
+            const unsigned int fps2 = uri.Get<unsigned int>("fps2", 30);
+
+            return std::unique_ptr<VideoInterface>(
+                DepthSenseContext::I().GetDepthSenseVideo(0, img1, img2, dim1, dim2, fps1, fps2, uri)
+            );
+        }
+    };
+
+    FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<DepthSenseVideoFactory>(), 10, "depthsense");
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/ffmpeg.cpp

@@ -0,0 +1,419 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// It is impossible to keep up with ffmpeg deprecations, so ignore these warnings.
+#if defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wdeprecated"
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <array>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/drivers/ffmpeg.h>
+#include <pangolin/utils/file_extension.h>
+
+extern "C"
+{
+#include <libavformat/avio.h>
+#include <libavutil/mathematics.h>
+#include <libavdevice/avdevice.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+}
+
+// Found https://github.com/leandromoreira/ffmpeg-libav-tutorial
+// Best reference I've seen for ffmpeg api
+
+namespace pangolin
+{
+
+std::string ffmpeg_error_string(int err)
+{
+    std::string ret(256, '\0');
+    av_make_error_string(ret.data(), ret.size(), err);
+    return ret;
+}
+
+std::ostream& operator<<(std::ostream& os, const AVRational& v)
+{
+    os << v.num << "/" << v.den;
+    return os;
+}
+
+// Implementation of sws_scale_frame for versions which don't have it.
+int pango_sws_scale_frame(struct SwsContext *c, AVFrame *dst, const AVFrame *src)
+{
+    return sws_scale(c,
+        src->data, src->linesize, 0, src->height,
+        dst->data, dst->linesize
+    );
+}
+
+FfmpegVideo::FfmpegVideo(const std::string filename, const std::string strfmtout, const std::string codec_hint, bool dump_info, int user_video_stream, ImageDim size)
+    :pFormatCtx(nullptr), pCodecContext(nullptr)
+{
+    InitUrl(PathExpand(filename), strfmtout, codec_hint, dump_info, user_video_stream, size);
+}
+
+void FfmpegVideo::InitUrl(const std::string url, const std::string strfmtout, const std::string codec_hint, bool dump_info, int user_video_stream, ImageDim size)
+{
+    if( url.find('*') != url.npos )
+        throw VideoException("Wildcards not supported. Please use ffmpegs printf style formatting for image sequences. e.g. img-000000%04d.ppm");
+
+    // Register all devices
+    avdevice_register_all();
+
+#if (LIBAVFORMAT_VERSION_MAJOR >= 59)
+    const AVInputFormat* fmt = nullptr;
+#else
+    AVInputFormat* fmt = nullptr;
+#endif
+
+    if( !codec_hint.empty() ) {
+        fmt = av_find_input_format(codec_hint.c_str());
+    }
+
+    AVDictionary* options = nullptr;
+    if(size.x != 0 && size.y != 0) {
+        std::string s = std::to_string(size.x) + "x" + std::to_string(size.y);
+        av_dict_set(&options, "video_size", s.c_str(), 0);
+    }
+    if( avformat_open_input(&pFormatCtx, url.c_str(), fmt, &options) )
+        throw VideoException("Couldn't open stream");
+
+    if( !ToLowerCopy(codec_hint).compare("mjpeg") )
+#ifdef HAVE_FFMPEG_MAX_ANALYZE_DURATION2
+        pFormatCtx->max_analyze_duration2 = AV_TIME_BASE * 0.0;
+#else
+        pFormatCtx->max_analyze_duration = AV_TIME_BASE * 0.0;
+#endif
+
+
+    // Retrieve stream information
+    if(avformat_find_stream_info(pFormatCtx, 0)<0)
+        throw VideoException("Couldn't find stream information");
+
+    if(dump_info) {
+        // Dump information about file onto standard error
+        av_dump_format(pFormatCtx, 0, url.c_str(), false);
+    }
+
+    const AVCodec *pCodec = nullptr;
+    const AVCodecParameters *pCodecParameters =  NULL;
+    int found_video_streams = 0;
+
+    // loop though all the streams and print its main information
+    for (int i = 0; i < pFormatCtx->nb_streams; i++)
+    {
+        AVStream * stream = pFormatCtx->streams[i];
+        const AVCodecParameters *pLocalCodecParameters = stream->codecpar;
+
+        // finds the registered decoder for a codec ID
+        const AVCodec *pLocalCodec = avcodec_find_decoder(pLocalCodecParameters->codec_id);
+        if (!pLocalCodec) {
+            pango_print_debug("Skipping stream with unsupported codec.\n");
+            stream->discard = AVDISCARD_ALL;
+            continue;
+        }
+
+        // When the stream is a video we store its index, codec parameters and codec
+        if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
+            if (found_video_streams == user_video_stream) {
+                pCodec = pLocalCodec;
+                pCodecParameters = pLocalCodecParameters;
+                videoStream = i;
+            }
+            ++found_video_streams;
+        }else{
+            stream->discard = AVDISCARD_ALL;
+            pango_print_debug("Skipping stream with supported but non-video codec.\n");
+        }
+    }
+
+    if(found_video_streams==0 || user_video_stream >= found_video_streams)
+        throw VideoException("Couldn't find appropriate video stream");
+
+    packet = av_packet_alloc();
+    if (!packet)
+        throw VideoException("Failed to allocated memory for AVPacket");
+
+    // try to work out how many frames we have in video and conversion from frames to pts
+    auto vid_stream = pFormatCtx->streams[videoStream];
+
+    auto set_or_check = [this](int64_t& var, int64_t val){
+        if(!var) {
+            var = val;
+        }else if(var != val) {
+            pango_print_warn("Inconsistent calculation for video.");
+        }
+    };
+
+    numFrames = vid_stream->nb_frames;
+
+    // try to fix missing duration if we have numFrames
+    if(numFrames > 0 && vid_stream->duration <= 0 && vid_stream->avg_frame_rate.num > 0) {
+        auto duration_s = av_div_q( av_make_q(numFrames,1), vid_stream->avg_frame_rate);
+        auto duration_pts = av_div_q( duration_s, vid_stream->time_base);
+        if(duration_pts.den == 1) {
+            vid_stream->duration = duration_pts.num;
+        }else{
+            pango_print_warn("Non integral result for duration in pts. Ignoring.\n");
+        }
+    }
+
+    // try to fix numFrames if we have no duration
+    if(numFrames <= 0 && vid_stream->duration > 0 && vid_stream->avg_frame_rate.num > 0 && vid_stream->time_base.num > 0) {
+        auto duration_s = av_mul_q( av_make_q(vid_stream->duration,1), vid_stream->time_base);
+        auto frames_rational = av_mul_q(duration_s, vid_stream->avg_frame_rate);
+        if(frames_rational.num > 0 && frames_rational.den == 1) {
+            numFrames = frames_rational.num;
+        }else{
+            pango_print_warn("Non integral result for numFrames. Ignoring.\n");
+        }
+    }
+
+    if(numFrames && vid_stream->duration && vid_stream->duration % numFrames == 0) {
+        ptsPerFrame = vid_stream->duration / numFrames;
+    }else{
+        ptsPerFrame = 0;
+        numFrames = 0;
+        pango_print_warn("Video Doesn't contain seeking information\n");
+    }
+
+    next_frame = 0;
+
+    // Find the decoder for the video stream
+    pVidCodec = pCodec;
+    if(pVidCodec==0)
+        throw VideoException("Codec not found");
+
+    // Allocate video frames
+    pFrame = av_frame_alloc();
+    pFrameOut = av_frame_alloc();
+    if(!pFrame || !pFrameOut)
+        throw VideoException("Couldn't allocate frames");
+
+    fmtout = FfmpegFmtFromString(strfmtout);
+    if(fmtout == AV_PIX_FMT_NONE )
+        throw VideoException("Output format not recognised",strfmtout);
+
+    pCodecContext = avcodec_alloc_context3(pCodec);
+    if (!pCodecContext)
+        throw VideoException("failed to allocated memory for AVCodecContext");
+
+    if (avcodec_parameters_to_context(pCodecContext, pCodecParameters) < 0)
+        throw VideoException("failed to copy codec params to codec context");
+
+    if (avcodec_open2(pCodecContext, pCodec, NULL) < 0)
+        throw VideoException("failed to open codec through avcodec_open2");
+
+
+    // Image dimensions
+    const int w = pCodecContext->width;
+    const int h = pCodecContext->height;
+
+    pFrameOut->width = w;
+    pFrameOut->height = h;
+    pFrameOut->format = fmtout;
+    if(av_frame_get_buffer(pFrameOut, 0) != 0) {
+        throw VideoException("");
+    }
+
+    // Allocate SWS for converting pixel formats
+    img_convert_ctx = sws_getContext(w, h,
+                                     pCodecContext->pix_fmt,
+                                     w, h, fmtout, SWS_FAST_BILINEAR,
+                                     NULL, NULL, NULL);
+    if(!img_convert_ctx) {
+        throw VideoException("Cannot initialize the conversion context");
+    }
+
+    // Populate stream info for users to query
+    numBytesOut = 0;
+    {
+        const PixelFormat strm_fmt = PixelFormatFromString(FfmpegFmtToString(fmtout));
+        const size_t pitch = (w*strm_fmt.bpp)/8;
+        const size_t size_bytes = h*pitch;
+        streams.emplace_back(strm_fmt, w, h, pitch, (unsigned char*)0 + numBytesOut);
+        numBytesOut += size_bytes;
+    }
+
+    auto s = pFormatCtx->streams[videoStream];
+}
+
+FfmpegVideo::~FfmpegVideo()
+{
+    av_free(pFrameOut);
+    av_free(pFrame);
+
+    avcodec_close(pCodecContext);
+    avformat_close_input(&pFormatCtx);
+    sws_freeContext(img_convert_ctx);
+}
+
+const std::vector<StreamInfo>& FfmpegVideo::Streams() const
+{
+    return streams;
+}
+
+size_t FfmpegVideo::SizeBytes() const
+{
+    return numBytesOut;
+}
+
+void FfmpegVideo::Start()
+{
+}
+
+void FfmpegVideo::Stop()
+{
+}
+
+bool FfmpegVideo::GrabNext(unsigned char* image, bool /*wait*/)
+{
+    auto vid_stream = pFormatCtx->streams[videoStream];
+
+    while(true)
+    {
+        const int rx_res = avcodec_receive_frame(pCodecContext, pFrame);
+        if(rx_res == 0) {
+            const int expected_pts = vid_stream->start_time + next_frame * ptsPerFrame;
+            if(ptsPerFrame > 0 && expected_pts > pFrame->pts) {
+                // We dont have the right frame, probably from seek to keyframe.
+                continue;
+            }
+            pango_sws_scale_frame(img_convert_ctx, pFrameOut, pFrame);
+            av_image_copy_to_buffer(image, numBytesOut, pFrameOut->data, pFrameOut->linesize, fmtout, pFrameOut->width, pFrameOut->height, 1);
+            next_frame++;
+            return true;
+        }else{
+            while(true) {
+                const int read_res = av_read_frame(pFormatCtx, packet);
+                if(read_res == 0) {
+                    if(packet->stream_index==videoStream) {
+                        if(avcodec_send_packet(pCodecContext, packet) == 0) {
+                            break; // have frame for codex
+                        }
+                    }
+                    av_packet_unref(packet);
+                }else{
+                    // No more packets for codec
+                    return false;
+                }
+            }
+        }
+    }
+}
+
+bool FfmpegVideo::GrabNewest(unsigned char *image, bool wait)
+{
+    return GrabNext(image,wait);
+}
+
+size_t FfmpegVideo::GetCurrentFrameId() const
+{
+    return next_frame-1;
+}
+
+size_t FfmpegVideo::GetTotalFrames() const
+{
+    return numFrames;
+}
+
+size_t FfmpegVideo::Seek(size_t frameid)
+{
+    if(ptsPerFrame && frameid != next_frame) {
+        const int64_t pts = ptsPerFrame*frameid;
+        const int res = avformat_seek_file(pFormatCtx, videoStream, 0, pts, pts, 0);
+        avcodec_flush_buffers(pCodecContext);
+
+        if(res >= 0) {
+            // success - next frame to read will be frameid, so 'current frame' is one before that.
+            next_frame = frameid;
+        }else{
+            pango_print_info("error whilst seeking. %u, %s\n", (unsigned)frameid, ffmpeg_error_string(res).data());
+        }
+    }
+
+    return next_frame;
+}
+
+
+PANGOLIN_REGISTER_FACTORY(FfmpegVideo)
+{
+    struct FfmpegVideoFactory : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"ffmpeg",0}, {"file",15}, {"files",15}};
+        }
+        const char* Description() const override
+        {
+            return "Use the FFMPEG library to decode videos.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","RGB24","Use FFMPEG to decode to this output format."},
+                {"stream","0","Decode stream with this index."},
+                {"codec_hint","","Apply a hint to FFMPEG on codec. Examples include {MJPEG,video4linux,...}"},
+                {"size","","Request a particular size output from FFMPEG"},
+                {"verbose","0","Output FFMPEG instantiation information."},
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const std::array<std::string,43> ffmpeg_ext = {{
+                ".3g2",".3gp", ".amv", ".asf", ".avi", ".drc", ".flv", ".f4v",
+                ".f4p", ".f4a", ".f4b", ".gif", ".gifv", ".m4v", ".mkv", ".mng", ".mov", ".qt",
+                ".mp4", ".m4p", ".m4v", ".mpg", ".mp2", ".mpeg", ".mpe", ".mpv", ".mpg", ".mpeg",
+                ".m2v", ".mxf", ".nsv",  ".ogv", ".ogg", ".rm", ".rmvb", ".roq", ".svi", ".vob",
+                ".webm", ".wmv", ".yuv", ".h264", ".h265"
+            }};
+
+            if(!uri.scheme.compare("file") || !uri.scheme.compare("files")) {
+                const std::string ext = FileLowercaseExtention(uri.url);
+                if(std::find(ffmpeg_ext.begin(), ffmpeg_ext.end(), ext) == ffmpeg_ext.end()) {
+                    // Don't try to load unknown files without the ffmpeg:// scheme.
+                    return std::unique_ptr<VideoInterface>();
+                }
+            }
+
+            const bool verbose = uri.Get<bool>("verbose",false);
+            std::string outfmt = uri.Get<std::string>("fmt","RGB24");
+            std::string codec_hint = uri.Get<std::string>("codec_hint","");
+            ToUpper(outfmt);
+            ToUpper(codec_hint);
+            const int video_stream = uri.Get<int>("stream",0);
+            const ImageDim size = uri.Get<ImageDim>("size",ImageDim(0,0));
+            return std::unique_ptr<VideoInterface>( new FfmpegVideo(uri.url.c_str(), outfmt, codec_hint, verbose, video_stream) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<FfmpegVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/ffmpeg_convert.cpp

@@ -0,0 +1,158 @@
+// It is impossible to keep up with ffmpeg deprecations, so ignore these warnings.
+#if defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wdeprecated"
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <pangolin/video/video.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/drivers/ffmpeg_convert.h>
+
+namespace pangolin {
+
+// Defined in ffmpeg.cpp
+int pango_sws_scale_frame(struct SwsContext *c, AVFrame *dst, const AVFrame *src);
+
+void FfmpegConverter::ConvertContext::convert(const unsigned char* src, unsigned char* dst)
+{
+    // Copy into ffmpeg src buffer from user buffer
+    memcpy(avsrc->buf[0]->data, src + src_buffer_offset, avsrc->buf[0]->size);
+    pango_sws_scale_frame(img_convert_ctx, avdst, avsrc);
+    av_image_copy_to_buffer(dst + dst_buffer_offset, avdst->buf[0]->size, avdst->data, avdst->linesize, fmtdst, avdst->width, avdst->height, 1);
+}
+
+FfmpegConverter::FfmpegConverter(std::unique_ptr<VideoInterface> &videoin_, const std::string sfmtdst, FfmpegMethod method )
+    :videoin(std::move(videoin_))
+{
+    if( !videoin )
+        throw VideoException("Source video interface not specified");
+
+    input_buffer = std::unique_ptr<unsigned char[]>(new unsigned char[videoin->SizeBytes()]);
+
+    converters.resize(videoin->Streams().size());
+
+    dst_buffer_size = 0;
+
+    for(size_t i=0; i < videoin->Streams().size(); ++i) {
+        const StreamInfo instrm = videoin->Streams()[i];
+
+        converters[i].w=instrm.Width();
+        converters[i].h=instrm.Height();
+
+        converters[i].fmtdst = FfmpegFmtFromString(sfmtdst);
+        converters[i].fmtsrc = FfmpegFmtFromString(instrm.PixFormat());
+        converters[i].img_convert_ctx = sws_getContext(
+            instrm.Width(), instrm.Height(), converters[i].fmtsrc,
+            instrm.Width(), instrm.Height(), converters[i].fmtdst,
+            method, NULL, NULL, NULL
+        );
+        if(!converters[i].img_convert_ctx)
+            throw VideoException("Could not create SwScale context for pixel conversion");
+
+        converters[i].dst_buffer_offset=dst_buffer_size;
+        converters[i].src_buffer_offset=instrm.Offset() - (unsigned char*)0;
+        //converters[i].src_buffer_offset=src_buffer_size;
+
+        converters[i].avsrc = av_frame_alloc();
+        converters[i].avsrc->width = instrm.Width();
+        converters[i].avsrc->height = instrm.Height();
+        converters[i].avsrc->format = FfmpegFmtFromString(instrm.PixFormat());
+        av_frame_get_buffer(converters[i].avsrc, 0);
+
+        converters[i].avdst = av_frame_alloc();
+        converters[i].avdst->width = instrm.Width();
+        converters[i].avdst->height = instrm.Height();
+        converters[i].avdst->format = FfmpegFmtFromString(sfmtdst);
+        av_frame_get_buffer(converters[i].avdst, 0);
+
+        const PixelFormat pxfmtdst = PixelFormatFromString(sfmtdst);
+        const StreamInfo sdst( pxfmtdst, instrm.Width(), instrm.Height(), (instrm.Width()*pxfmtdst.bpp)/8, (unsigned char*)0 + converters[i].dst_buffer_offset );
+        streams.push_back(sdst);
+
+        dst_buffer_size += av_image_get_buffer_size(converters[i].fmtdst, instrm.Width(), instrm.Height(), 0);
+    }
+
+}
+
+FfmpegConverter::~FfmpegConverter()
+{
+    for(ConvertContext&c:converters)
+    {
+        av_free(c.avsrc);
+        av_free(c.avdst);
+    }
+}
+
+void FfmpegConverter::Start()
+{
+    // No-Op
+}
+
+void FfmpegConverter::Stop()
+{
+    // No-Op
+}
+
+size_t FfmpegConverter::SizeBytes() const
+{
+    return dst_buffer_size;
+}
+
+const std::vector<StreamInfo>& FfmpegConverter::Streams() const
+{
+    return streams;
+}
+
+bool FfmpegConverter::GrabNext( unsigned char* image, bool wait )
+{
+    if( videoin->GrabNext(input_buffer.get(),wait) )
+    {
+        for(ConvertContext&c:converters) {
+            c.convert(input_buffer.get(), image);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool FfmpegConverter::GrabNewest( unsigned char* image, bool wait )
+{
+    if( videoin->GrabNewest(input_buffer.get(),wait) )
+    {
+        for(ConvertContext&c:converters) {
+            c.convert(input_buffer.get(),image);
+        }
+        return true;
+    }
+    return false;
+}
+
+PANGOLIN_REGISTER_FACTORY(FfmpegVideoConvert)
+{
+    struct FfmpegVideoFactory : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"ffmpeg_convert", 0}, {"convert", 20}};
+        }
+        const char* Description() const override
+        {
+            return "Use FFMPEG library to convert pixel format.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","RGB24","Pixel format: see pixel format help for all possible values"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::string outfmt = uri.Get<std::string>("fmt","RGB24");
+            ToUpper(outfmt);
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            return std::unique_ptr<VideoInterface>( new FfmpegConverter(subvid,outfmt,FFMPEG_POINT) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<FfmpegVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/ffmpeg_output.cpp

@@ -0,0 +1,341 @@
+// It is impossible to keep up with ffmpeg deprecations, so ignore these warnings.
+#if defined(__GNUC__)
+#  pragma GCC diagnostic ignored "-Wdeprecated"
+#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#include <pangolin/video/drivers/ffmpeg_output.h>
+#include <pangolin/factory/factory_registry.h>
+
+namespace pangolin {
+
+// Defined in ffmpeg.cpp
+int pango_sws_scale_frame(struct SwsContext *c, AVFrame *dst, const AVFrame *src);
+
+AVCodecContext* CreateVideoCodecContext(AVCodecID codec_id, uint64_t frame_rate, int bit_rate, AVPixelFormat EncoderFormat, int width, int height)
+{
+    const AVCodec* codec = avcodec_find_encoder(codec_id);
+    if (!(codec))
+        throw VideoException("Could not find encoder");
+
+    if(codec->type != AVMEDIA_TYPE_VIDEO)
+        throw VideoException("Encoder is not a video encoder");
+
+    AVCodecContext* codec_context = avcodec_alloc_context3(codec);
+    if(!codec_context)
+        throw VideoException("Unable to create codec context");
+
+    codec_context->codec_id = codec_id;
+    codec_context->bit_rate = bit_rate;
+    codec_context->width    = width;
+    codec_context->height   = height;
+    codec_context->time_base = av_make_q(1,frame_rate);
+    codec_context->framerate = av_make_q(frame_rate,1);
+    codec_context->gop_size      = 10;
+    codec_context->max_b_frames  = 1;
+    codec_context->pix_fmt       = EncoderFormat;
+
+    /* open the codec */
+    int ret = avcodec_open2(codec_context, nullptr, nullptr);
+    if (ret < 0)  throw VideoException("Could not open video codec");
+
+    return codec_context;
+}
+
+// Based on this example
+// http://cekirdek.pardus.org.tr/~ismail/ffmpeg-docs/output-example_8c-source.html
+static AVStream* CreateStream(AVFormatContext *oc, AVCodecContext* codec_context)
+{
+    /* Some formats want stream headers to be separate. */
+    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
+        codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
+
+    AVStream* stream = avformat_new_stream(oc, codec_context->codec);
+    if (!stream) throw VideoException("Could not allocate stream");
+
+    stream->id = oc->nb_streams-1;
+    stream->time_base = codec_context->time_base;
+    stream->avg_frame_rate = codec_context->framerate;
+    stream->r_frame_rate = stream->avg_frame_rate;
+    stream->duration = codec_context->framerate.num * 60 / codec_context->framerate.den;
+    avcodec_parameters_from_context(stream->codecpar, codec_context);
+
+    return stream;
+}
+
+void FfmpegVideoOutputStream::WriteFrame(AVFrame* frame)
+{
+    AVPacket* pkt = av_packet_alloc();
+    av_init_packet(pkt);
+    pkt->data = NULL;
+    pkt->size = 0;
+
+    int ret;
+    int got_packet = 1;
+
+    /* encode the image */
+    int response = avcodec_send_frame(codec_context, frame);
+    while (response >= 0) {
+       response = avcodec_receive_packet(codec_context, pkt);
+       if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
+         break;
+       } else if (response < 0) {
+         pango_print_error("Error while receiving packet from encoder.\n");
+         return;
+       }
+
+       pkt->stream_index = stream->index;
+//       pkt->pts = frame->pts;
+//       pkt->dts = frame->pkt_dts;
+//       pkt->time_base = codec_context->time_base;
+       pkt->duration = 1; //av_div_q(codec_context->framerate, codec_context->time_base).num;
+//       av_packet_rescale_ts(pkt, codec_context->time_base, pkt->time_base);
+
+       if (pkt->size) {
+           int64_t pts = pkt->pts;
+           int ret = av_interleaved_write_frame(recorder.oc, pkt);
+           if (ret < 0) throw VideoException("Error writing video frame");
+           if(pkt->pts != (int64_t)AV_NOPTS_VALUE) last_pts = pts;
+       }
+     }
+     av_packet_free(&pkt);
+     return;
+}
+
+void FfmpegVideoOutputStream::WriteImage(const uint8_t* img, int w, int h)
+{
+    static int64_t pts = 0;
+
+    av_frame_make_writable(src_frame);
+    memcpy(src_frame->buf[0]->data, img, src_frame->buf[0]->size);
+
+    recorder.StartStream();
+
+    AVFrame* frame_to_write = nullptr;
+
+    if (codec_context->pix_fmt != input_format || codec_context->width != w || codec_context->height != h) {
+        if(!sws_ctx) {
+            sws_ctx = sws_getCachedContext( sws_ctx,
+                w, h, input_format,
+                codec_context->width, codec_context->height, codec_context->pix_fmt,
+                SWS_BICUBIC, NULL, NULL, NULL
+            );
+            if (!sws_ctx) throw VideoException("Could not initialize the conversion context");
+        }
+        av_frame_make_writable(frame);
+        pango_sws_scale_frame(sws_ctx, frame, src_frame);
+        frame_to_write = frame;
+    } else {
+        frame_to_write = src_frame;
+    }
+
+    if(frame_to_write) {
+        frame_to_write->pts = pts;
+        WriteFrame(frame_to_write);
+        ++pts;
+    }
+}
+
+void FfmpegVideoOutputStream::Flush()
+{
+    WriteFrame(nullptr);
+}
+
+const StreamInfo& FfmpegVideoOutputStream::GetStreamInfo() const
+{
+    return input_info;
+}
+
+double FfmpegVideoOutputStream::BaseFrameTime()
+{
+    return (double)codec_context->time_base.num / (double)codec_context->time_base.den;
+}
+
+FfmpegVideoOutputStream::FfmpegVideoOutputStream(
+    FfmpegVideoOutput& recorder, CodecID codec_id, uint64_t frame_rate,
+    int bit_rate, const StreamInfo& input_info, bool flip_image
+)
+    : recorder(recorder), input_info(input_info),
+      input_format(FfmpegFmtFromString(input_info.PixFormat())),
+      output_format( FfmpegFmtFromString("YUV420P") ),
+      last_pts(-1), sws_ctx(NULL), frame(NULL), flip(flip_image)
+{
+    codec_context = CreateVideoCodecContext(codec_id, frame_rate, bit_rate, output_format, input_info.Width(), input_info.Height());
+    stream = CreateStream(recorder.oc, codec_context);
+
+    // Allocate frame
+    frame = av_frame_alloc();
+    frame->format = codec_context->pix_fmt;
+    frame->width = codec_context->width;
+    frame->height = codec_context->height;
+    if(av_frame_get_buffer(frame,0)) {
+        throw VideoException("Could not allocate picture");
+    }
+
+    src_frame = av_frame_alloc();
+    src_frame->format = input_format;
+    src_frame->width = input_info.Width();
+    src_frame->height = input_info.Height();
+    if(av_frame_get_buffer(src_frame,0)) {
+        throw VideoException("Could not allocate picture");
+    }
+
+    if(flip) {
+        // setup data pointer to end of memory, and negate line sizes.
+        for(int i=0; i<4; ++i) {
+            if(src_frame->data[i]) {
+                src_frame->data[i] += (src_frame->height-1) * src_frame->linesize[i];
+            }
+            if(src_frame->linesize[i]) {
+                src_frame->linesize[i] *= -1;
+            }
+        }
+    }
+}
+
+FfmpegVideoOutputStream::~FfmpegVideoOutputStream()
+{
+    Flush();
+
+    if(sws_ctx) {
+        sws_freeContext(sws_ctx);
+    }
+
+    av_free(frame);
+    avcodec_close(codec_context);
+}
+
+FfmpegVideoOutput::FfmpegVideoOutput(const std::string& filename, int base_frame_rate, int bit_rate, bool flip_image)
+    : filename(filename), started(false), oc(NULL),
+      frame_count(0), base_frame_rate(base_frame_rate), bit_rate(bit_rate), is_pipe(pangolin::IsPipe(filename)), flip(flip_image)
+{
+    Initialise(filename);
+}
+
+FfmpegVideoOutput::~FfmpegVideoOutput()
+{
+    Close();
+}
+
+bool FfmpegVideoOutput::IsPipe() const
+{
+    return is_pipe;
+}
+
+void FfmpegVideoOutput::Initialise(std::string filename)
+{
+    int ret = avformat_alloc_output_context2(&oc, NULL, NULL, filename.c_str());
+
+    if (ret < 0 || !oc) {
+        pango_print_error("Could not deduce output format from file extension: using MPEG.\n");
+        ret = avformat_alloc_output_context2(&oc, NULL, "mpeg", filename.c_str());
+        if (ret < 0 || !oc) throw VideoException("Couldn't create AVFormatContext");
+    }
+
+    /* open the output file, if needed */
+    if (!(oc->oformat->flags & AVFMT_NOFILE)) {
+        ret = avio_open(&oc->pb, filename.c_str(), AVIO_FLAG_WRITE);
+        if (ret < 0) throw VideoException("Could not open '%s'\n", filename);
+    }
+}
+
+void FfmpegVideoOutput::StartStream()
+{
+    if(!started) {
+        av_dump_format(oc, 0, filename.c_str(), 1);
+
+        /* Write the stream header, if any. */
+        int ret = avformat_write_header(oc, NULL);
+        if (ret < 0) throw VideoException("Error occurred when opening output file");
+
+        started = true;
+    }
+}
+
+void FfmpegVideoOutput::Close()
+{
+    for(std::vector<FfmpegVideoOutputStream*>::iterator i = streams.begin(); i!=streams.end(); ++i)
+    {
+        (*i)->Flush();
+        delete *i;
+    }
+
+    av_write_trailer(oc);
+
+    if (!(oc->oformat->flags & AVFMT_NOFILE)) avio_close(oc->pb);
+
+    avformat_free_context(oc);
+}
+
+const std::vector<StreamInfo>& FfmpegVideoOutput::Streams() const
+{
+    return strs;
+}
+
+void FfmpegVideoOutput::SetStreams(const std::vector<StreamInfo>& str, const std::string& /*uri*/, const picojson::value& properties)
+{
+    strs.insert(strs.end(), str.begin(), str.end());
+
+    for(std::vector<StreamInfo>::const_iterator i = str.begin(); i!= str.end(); ++i)
+    {
+        streams.push_back( new FfmpegVideoOutputStream(
+            *this, oc->oformat->video_codec, base_frame_rate, bit_rate, *i, flip
+        ) );
+    }
+
+    if(!properties.is<picojson::null>()) {
+        pango_print_warn("Ignoring attached video properties.");
+    }
+}
+
+int FfmpegVideoOutput::WriteStreams(const unsigned char* data, const picojson::value& /*frame_properties*/)
+{
+    for(std::vector<FfmpegVideoOutputStream*>::iterator i = streams.begin(); i!= streams.end(); ++i)
+    {
+        FfmpegVideoOutputStream& s = **i;
+        Image<unsigned char> img = s.GetStreamInfo().StreamImage(data);
+        s.WriteImage(img.ptr, img.w, img.h);
+    }
+    return frame_count++;
+}
+
+PANGOLIN_REGISTER_FACTORY(FfmpegVideoOutput)
+{
+    struct FfmpegVideoFactory final : public TypedFactoryInterface<VideoOutputInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"ffmpeg",10}};
+        }
+        const char* Description() const override
+        {
+            return "Use FFMPEG lib to encode video";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fps","60","Playback frames-per-second to recommend in meta-data"},
+                {"bps","20000*1024","desired bitrate (hint)"},
+                {"flip","0","Flip the output vertically before recording"},
+                {"unique_filename","","Automatically append a unique number instead of overwriting files"},
+            }};
+        }
+        std::unique_ptr<VideoOutputInterface> Open(const Uri& uri) override {
+            const int desired_frame_rate = uri.Get("fps", 60);
+            const int desired_bit_rate = uri.Get("bps", 20000*1024);
+            const bool flip = uri.Get("flip", false);
+            std::string filename = uri.url;
+
+            if(uri.Contains("unique_filename")) {
+                filename = MakeUniqueFilename(filename);
+            }
+
+            return std::unique_ptr<VideoOutputInterface>(
+                new FfmpegVideoOutput(filename, desired_frame_rate, desired_bit_rate, flip)
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoOutputInterface>(std::make_shared<FfmpegVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/firewire.cpp

@@ -0,0 +1,987 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/firewire.h>
+#include <pangolin/video/drivers/deinterlace.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <inttypes.h>
+
+using namespace std;
+
+namespace pangolin
+{
+
+void FirewireVideo::init_camera(
+        uint64_t guid, int dma_frames,
+        dc1394speed_t iso_speed,
+        dc1394video_mode_t video_mode,
+        dc1394framerate_t framerate
+        ) {
+
+    if(video_mode>=DC1394_VIDEO_MODE_FORMAT7_0)
+        throw VideoException("format7 modes need to be initialized through the constructor that allows for specifying the roi");
+
+    camera = dc1394_camera_new (d, guid);
+    if (!camera)
+        throw VideoException("Failed to initialize camera");
+
+    // Attempt to stop camera if it is already running
+    dc1394switch_t is_iso_on = DC1394_OFF;
+    dc1394_video_get_transmission(camera, &is_iso_on);
+    if (is_iso_on==DC1394_ON) {
+        dc1394_video_set_transmission(camera, DC1394_OFF);
+    }
+
+
+    cout << "Using camera with GUID " << camera->guid << endl;
+
+    //-----------------------------------------------------------------------
+    //  setup capture
+    //-----------------------------------------------------------------------
+
+    if( iso_speed >= DC1394_ISO_SPEED_800)
+    {
+        err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not set DC1394_OPERATION_MODE_1394B");
+    }
+
+    err=dc1394_video_set_iso_speed(camera, iso_speed);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set iso speed");
+
+    err=dc1394_video_set_mode(camera, video_mode);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set video mode");
+
+    err=dc1394_video_set_framerate(camera, framerate);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set framerate");
+
+    err=dc1394_capture_setup(camera,dma_frames, DC1394_CAPTURE_FLAGS_DEFAULT);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not setup camera - check settings");
+
+    //-----------------------------------------------------------------------
+    //  initialise width and height from mode
+    //-----------------------------------------------------------------------
+    dc1394_get_image_size_from_video_mode(camera, video_mode, &width, &height);
+
+    init_stream_info();
+    Start();
+}
+
+
+// Note:
+// the following was tested on a IIDC camera over USB therefore might not work as
+// well on a camera over proper firewire transport
+void FirewireVideo::init_format7_camera(
+        uint64_t guid, int dma_frames,
+        dc1394speed_t iso_speed,
+        dc1394video_mode_t video_mode,
+        float framerate,
+        uint32_t width, uint32_t height,
+        uint32_t left, uint32_t top, bool reset_at_boot
+        ) {
+
+    if(video_mode< DC1394_VIDEO_MODE_FORMAT7_0)
+        throw VideoException("roi can be specified only for format7 modes");
+
+    camera = dc1394_camera_new (d, guid);
+    if (!camera)
+        throw VideoException("Failed to initialize camera");
+
+    // Attempt to stop camera if it is already running
+    dc1394switch_t is_iso_on = DC1394_OFF;
+    dc1394_video_get_transmission(camera, &is_iso_on);
+    if (is_iso_on==DC1394_ON) {
+        dc1394_video_set_transmission(camera, DC1394_OFF);
+    }
+
+    cout << "Using camera with GUID " << camera->guid << endl;
+
+    if(reset_at_boot){
+        dc1394_camera_reset(camera);
+    }
+
+    //-----------------------------------------------------------------------
+    //  setup mode and roi
+    //-----------------------------------------------------------------------
+
+    if(iso_speed >= DC1394_ISO_SPEED_800)
+    {
+        err=dc1394_video_set_operation_mode(camera, DC1394_OPERATION_MODE_1394B);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not set DC1394_OPERATION_MODE_1394B");
+    }
+
+    err=dc1394_video_set_iso_speed(camera, iso_speed);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set iso speed");
+
+    // check that the required mode is actually supported
+    dc1394format7mode_t format7_info;
+
+    err = dc1394_format7_get_mode_info(camera, video_mode, &format7_info);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not get format7 mode info");
+
+    // safely set the video mode
+    err=dc1394_video_set_mode(camera, video_mode);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set format7 video mode");
+
+    // set position to 0,0 so that setting any size within min and max is a valid command
+    err = dc1394_format7_set_image_position(camera, video_mode,0,0);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set format7 image position");
+
+    // work out the desired image size
+    width = nearest_value(width, format7_info.unit_pos_x, 0, format7_info.max_size_x - left);
+    height = nearest_value(height, format7_info.unit_pos_y, 0, format7_info.max_size_y - top);
+
+    // set size
+    err = dc1394_format7_set_image_size(camera,video_mode,width,height);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set format7 size");
+
+    // get the info again since many parameters depend on image size
+    err = dc1394_format7_get_mode_info(camera, video_mode, &format7_info);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not get format7 mode info");
+
+    // work out position of roi
+    left = nearest_value(left, format7_info.unit_size_x, format7_info.unit_size_x, format7_info.max_size_x - width);
+    top = nearest_value(top, format7_info.unit_size_y, format7_info.unit_size_y, format7_info.max_size_y - height);
+
+    // set roi position
+    err = dc1394_format7_set_image_position(camera,video_mode,left,top);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set format7 size");
+
+    this->width = width;
+    this->height = height;
+    this->top = top;
+    this->left = left;
+
+    cout<<"roi: "<<left<<" "<<top<<" "<<width<<" "<<height<<"  ";
+
+
+    //-----------------------------------------------------------------------
+    //  setup frame rate
+    //-----------------------------------------------------------------------
+
+    err=dc1394_format7_set_packet_size(camera,video_mode, format7_info.max_packet_size);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not set format7 packet size");
+
+    if((framerate != MAX_FR) && (framerate != EXT_TRIG)){
+        //set the framerate by using the absolute feature as suggested by the
+        //folks at PointGrey
+        err = dc1394_feature_set_absolute_control(camera,DC1394_FEATURE_FRAME_RATE,DC1394_ON);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not turn on absolute frame rate control");
+
+        err = dc1394_feature_set_mode(camera,DC1394_FEATURE_FRAME_RATE,DC1394_FEATURE_MODE_MANUAL);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not make frame rate manual ");
+
+        err=dc1394_feature_set_absolute_value(camera,DC1394_FEATURE_FRAME_RATE,framerate);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not set format7 framerate ");
+    }
+
+    // ask the camera what is the resulting framerate (this assume that such a rate is actually
+    // allowed by the shutter time)
+    float value;
+    err=dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_FRAME_RATE,&value);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not get framerate");
+
+    cout<<" framerate(shutter permitting):"<<value<<endl;
+
+    //-----------------------------------------------------------------------
+    //  setup capture
+    //-----------------------------------------------------------------------
+
+    err=dc1394_capture_setup(camera,dma_frames, DC1394_CAPTURE_FLAGS_DEFAULT);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Could not setup camera - check settings");
+
+    init_stream_info();
+    Start();
+}
+
+std::string Dc1394ColorCodingToString(dc1394color_coding_t coding)
+{
+    switch(coding)
+    {
+    case DC1394_COLOR_CODING_RGB8 :    return "RGB24";
+    case DC1394_COLOR_CODING_MONO8 :   return "GRAY8";
+
+    case DC1394_COLOR_CODING_MONO16 :  return "GRAY16LE";
+    case DC1394_COLOR_CODING_RGB16 :   return "RGB48LE";
+
+    case DC1394_COLOR_CODING_MONO16S : return "GRAY16BE";
+    case DC1394_COLOR_CODING_RGB16S :  return "RGB48BE";
+
+    case DC1394_COLOR_CODING_YUV411 :  return "YUV411P";
+    case DC1394_COLOR_CODING_YUV422 :  return "YUV422P";
+    case DC1394_COLOR_CODING_YUV444 :  return "YUV444P";
+
+    case DC1394_COLOR_CODING_RAW8 :    return "GRAY8";
+    case DC1394_COLOR_CODING_RAW16 :   return "GRAY16LE";
+
+    default:
+        throw VideoException("Unknown colour coding");
+    }
+}
+
+dc1394color_coding_t Dc1394ColorCodingFromString(std::string coding)
+{
+    if(     !coding.compare("RGB24"))    return DC1394_COLOR_CODING_RGB8;
+    else if(!coding.compare("GRAY8"))    return DC1394_COLOR_CODING_MONO8;
+
+    else if(!coding.compare("GRAY16LE")) return DC1394_COLOR_CODING_MONO16;
+    else if(!coding.compare("RGB48LE"))  return DC1394_COLOR_CODING_RGB16;
+    else if(!coding.compare("GRAY16BE")) return DC1394_COLOR_CODING_MONO16S;
+    else if(!coding.compare("RGB48BE"))  return DC1394_COLOR_CODING_RGB16S;
+
+    else if(!coding.compare("YUV411P"))  return DC1394_COLOR_CODING_YUV411;
+    else if(!coding.compare("YUV422P"))  return DC1394_COLOR_CODING_YUV422;
+    else if(!coding.compare("YUV444P"))  return DC1394_COLOR_CODING_YUV444;
+    //    else if(!coding.compare("RAW8"))     return DC1394_COLOR_CODING_RAW8;
+    //    else if(!coding.compare("RAW16"))    return DC1394_COLOR_CODING_RAW16;
+    throw VideoException("Unknown colour coding");
+}
+
+void Dc1394ModeDetails(dc1394video_mode_t mode, unsigned& w, unsigned& h, string& format )
+{
+    switch( mode )
+    {
+    // RGB Modes
+    case DC1394_VIDEO_MODE_1024x768_RGB8:
+        w=1024;    h=768;    format = "RGB24";
+        break;
+    case DC1394_VIDEO_MODE_640x480_RGB8:
+        w=640;    h=480;    format = "RGB24";
+        break;
+    case DC1394_VIDEO_MODE_800x600_RGB8:
+        w=800;    h=600;    format = "RGB24";
+        break;
+    case DC1394_VIDEO_MODE_1280x960_RGB8:
+        w=1280;    h=960;    format = "RGB24";
+        break;
+    case DC1394_VIDEO_MODE_1600x1200_RGB8:
+        w=1600;    h=1200;    format = "RGB24";
+        break;
+
+        // Greyscale modes
+    case DC1394_VIDEO_MODE_640x480_MONO8:
+        w=640;    h=480;    format = "GRAY8";
+        break;
+    case DC1394_VIDEO_MODE_800x600_MONO8:
+        w=800;    h=600;    format = "GRAY8";
+        break;
+    case DC1394_VIDEO_MODE_1024x768_MONO8:
+        w=1024;    h=768;    format = "GRAY8";
+        break;
+    case DC1394_VIDEO_MODE_1280x960_MONO8:
+        w=1280;    h=960;    format = "GRAY8";
+        break;
+    case DC1394_VIDEO_MODE_1600x1200_MONO8:
+        w=1600;    h=1200;    format = "GRAY8";
+        break;
+    case DC1394_VIDEO_MODE_640x480_MONO16:
+        w=640;    h=480;    format = "GRAY16";
+        break;
+    case DC1394_VIDEO_MODE_800x600_MONO16:
+        w=800;    h=600;    format = "GRAY16";
+        break;
+    case DC1394_VIDEO_MODE_1024x768_MONO16:
+        w=1024;    h=768;    format = "GRAY16";
+        break;
+    case DC1394_VIDEO_MODE_1280x960_MONO16:
+        w=1280;    h=960;    format = "GRAY16";
+        break;
+    case DC1394_VIDEO_MODE_1600x1200_MONO16:
+        w=1600;    h=1200;    format = "GRAY16";
+        break;
+
+        // Chrome modes
+    case DC1394_VIDEO_MODE_640x480_YUV411:
+        w=640;    h=480;    format = "YUV411P";
+        break;
+    case DC1394_VIDEO_MODE_160x120_YUV444:
+        w=160;    h=120;    format = "YUV444P";
+        break;
+    case DC1394_VIDEO_MODE_320x240_YUV422:
+        w=320;    h=240;    format = "YUV422P";
+        break;
+    case DC1394_VIDEO_MODE_640x480_YUV422:
+        w=640;    h=480;    format = "YUV422P";
+        break;
+    case DC1394_VIDEO_MODE_800x600_YUV422:
+        w=800;    h=600;    format = "YUV422P";
+        break;
+    case DC1394_VIDEO_MODE_1024x768_YUV422:
+        w=1024;    h=768;    format = "YUV422P";
+        break;
+    case DC1394_VIDEO_MODE_1600x1200_YUV422:
+        w=1600;    h=1200;    format = "YUV422P";
+        break;
+    case DC1394_VIDEO_MODE_1280x960_YUV422:
+        w=1280;    h=960;    format = "YUV422P";
+        break;
+    default:
+        throw VideoException("Unknown colour coding");
+    }
+}
+
+void FirewireVideo::init_stream_info()
+{
+    streams.clear();
+
+    dc1394video_mode_t video_mode;
+    dc1394color_coding_t color_coding;
+    dc1394_video_get_mode(camera,&video_mode);
+    dc1394_get_color_coding_from_video_mode(camera,video_mode,&color_coding);
+    const std::string strformat = Dc1394ColorCodingToString(color_coding);
+    const PixelFormat fmt = PixelFormatFromString(strformat);
+
+    StreamInfo stream(fmt, width, height, (width*fmt.bpp)/8, 0 );
+    streams.push_back( stream );
+
+    frame_size_bytes = stream.Pitch() * stream.Height();
+}
+
+const std::vector<StreamInfo>& FirewireVideo::Streams() const
+{
+    return streams;
+}
+
+size_t FirewireVideo::SizeBytes() const
+{
+    return frame_size_bytes;
+}
+
+void FirewireVideo::Start()
+{
+    if( !running )
+    {
+        err=dc1394_video_set_transmission(camera, DC1394_ON);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not start camera iso transmission");
+        running = true;
+    }
+}
+
+void FirewireVideo::Stop()
+{
+    if( running )
+    {
+        // Stop transmission
+        err=dc1394_video_set_transmission(camera,DC1394_OFF);
+        if( err != DC1394_SUCCESS )
+            throw VideoException("Could not stop the camera");
+        running = false;
+    }
+}
+
+FirewireVideo::FirewireVideo(
+        Guid guid,
+        dc1394video_mode_t video_mode,
+        dc1394framerate_t framerate,
+        dc1394speed_t iso_speed,
+        int dma_buffers
+        ) :running(false),top(0),left(0)
+{
+    d = dc1394_new ();
+    if (!d)
+        throw VideoException("Failed to get 1394 bus");
+
+    init_camera(guid.guid,dma_buffers,iso_speed,video_mode,framerate);
+}
+
+FirewireVideo::FirewireVideo(
+        Guid guid,
+        dc1394video_mode_t video_mode,
+        float framerate,
+        uint32_t width, uint32_t height,
+        uint32_t left, uint32_t top,
+        dc1394speed_t iso_speed,
+        int dma_buffers, bool reset_at_boot
+        ) :running(false)
+{
+    d = dc1394_new ();
+    if (!d)
+        throw VideoException("Failed to get 1394 bus");
+
+    init_format7_camera(guid.guid,dma_buffers,iso_speed,video_mode,framerate,width,height,left,top, reset_at_boot);
+}
+
+FirewireVideo::FirewireVideo(
+        unsigned deviceid,
+        dc1394video_mode_t video_mode,
+        dc1394framerate_t framerate,
+        dc1394speed_t iso_speed,
+        int dma_buffers
+        ) :running(false),top(0),left(0)
+{
+    d = dc1394_new ();
+    if (!d)
+        throw VideoException("Failed to get 1394 bus");
+
+    err=dc1394_camera_enumerate (d, &list);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to enumerate cameras");
+
+    if (list->num == 0)
+        throw VideoException("No cameras found");
+
+    if( deviceid >= list->num )
+        throw VideoException("Invalid camera index");
+
+    const uint64_t guid = list->ids[deviceid].guid;
+
+    dc1394_camera_free_list (list);
+
+    init_camera(guid,dma_buffers,iso_speed,video_mode,framerate);
+
+}
+
+FirewireVideo::FirewireVideo(
+        unsigned deviceid,
+        dc1394video_mode_t video_mode,
+        float framerate,
+        uint32_t width, uint32_t height,
+        uint32_t left, uint32_t top,
+        dc1394speed_t iso_speed,
+        int dma_buffers, bool reset_at_boot
+        ) :running(false)
+{
+    d = dc1394_new ();
+    if (!d)
+        throw VideoException("Failed to get 1394 bus");
+
+    err=dc1394_camera_enumerate (d, &list);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to enumerate cameras");
+
+    if (list->num == 0)
+        throw VideoException("No cameras found");
+
+    if( deviceid >= list->num )
+        throw VideoException("Invalid camera index");
+
+    const uint64_t guid = list->ids[deviceid].guid;
+
+    dc1394_camera_free_list (list);
+
+    init_format7_camera(guid,dma_buffers,iso_speed,video_mode,framerate,width,height,left,top, reset_at_boot);
+
+}
+
+bool FirewireVideo::GrabNext( unsigned char* image, bool wait )
+{
+    const dc1394capture_policy_t policy =
+            wait ? DC1394_CAPTURE_POLICY_WAIT : DC1394_CAPTURE_POLICY_POLL;
+
+    dc1394video_frame_t *frame;
+    err = dc1394_capture_dequeue(camera, policy, &frame);
+    if( err != DC1394_SUCCESS)
+        throw VideoException("Could not capture frame", dc1394_error_get_string(err) );
+
+    if( frame )
+    {
+        memcpy(image,frame->image,frame->image_bytes);
+        dc1394_capture_enqueue(camera,frame);
+        return true;
+    }
+    return false;
+}
+
+bool FirewireVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    dc1394video_frame_t *f;
+    err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &f);
+    if( err != DC1394_SUCCESS)
+        throw VideoException("Could not capture frame", dc1394_error_get_string(err) );
+
+    if( f ) {
+        while( true )
+        {
+            dc1394video_frame_t *nf;
+            err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &nf);
+            if( err != DC1394_SUCCESS)
+                throw VideoException("Could not capture frame", dc1394_error_get_string(err) );
+
+            if( nf )
+            {
+                err=dc1394_capture_enqueue(camera,f);
+                f = nf;
+            }else{
+                break;
+            }
+        }
+        memcpy(image,f->image,f->image_bytes);
+        err=dc1394_capture_enqueue(camera,f);
+        return true;
+    }else if(wait){
+        return GrabNext(image,true);
+    }
+    return false;
+}
+
+FirewireFrame FirewireVideo::GetNext(bool wait)
+{
+    const dc1394capture_policy_t policy =
+            wait ? DC1394_CAPTURE_POLICY_WAIT : DC1394_CAPTURE_POLICY_POLL;
+
+    dc1394video_frame_t *frame;
+    dc1394_capture_dequeue(camera, policy, &frame);
+    return FirewireFrame(frame);
+}
+
+FirewireFrame FirewireVideo::GetNewest(bool wait)
+{
+    dc1394video_frame_t *f;
+    err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &f);
+    if( err != DC1394_SUCCESS)
+        throw VideoException("Could not capture frame", dc1394_error_get_string(err) );
+
+    if( f ) {
+        while( true )
+        {
+            dc1394video_frame_t *nf;
+            err = dc1394_capture_dequeue(camera, DC1394_CAPTURE_POLICY_POLL, &nf);
+            if( err != DC1394_SUCCESS)
+                throw VideoException("Could not capture frame", dc1394_error_get_string(err) );
+
+            if( nf )
+            {
+                err=dc1394_capture_enqueue(camera,f);
+                f = nf;
+            }else{
+                break;
+            }
+        }
+        return FirewireFrame(f);
+    }else if(wait){
+        return GetNext(true);
+    }
+    return FirewireFrame(0);
+}
+
+void FirewireVideo::PutFrame(FirewireFrame& f)
+{
+    if( f.frame )
+    {
+        dc1394_capture_enqueue(camera,f.frame);
+        f.frame = 0;
+    }
+}
+
+float FirewireVideo::GetGain() const
+{
+    float gain;
+    err = dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_GAIN,&gain);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to read gain");
+
+    return gain;
+
+}
+
+void FirewireVideo::SetAutoGain()
+{
+
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_AUTO);
+    if (err < 0) {
+        throw VideoException("Could not set auto gain mode");
+    }
+}
+
+void FirewireVideo::SetGain(float val)
+{
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_GAIN, DC1394_FEATURE_MODE_MANUAL);
+    if (err < 0) {
+        throw VideoException("Could not set manual gain mode");
+    }
+
+    err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_GAIN, DC1394_ON);
+    if (err < 0) {
+        throw VideoException("Could not set absolute control for gain");
+    }
+
+    err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_GAIN, val);
+    if (err < 0) {
+        throw VideoException("Could not set gain value");
+    }
+}
+
+
+float FirewireVideo::GetBrightness() const
+{
+    float brightness;
+    err = dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_BRIGHTNESS,&brightness);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to read brightness");
+
+    return brightness;
+
+}
+
+void FirewireVideo::SetAutoBrightness()
+{
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_AUTO);
+    if (err < 0) {
+        throw VideoException("Could not set auto brightness mode");
+    }
+}
+
+void FirewireVideo::SetBrightness(float val)
+{
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_FEATURE_MODE_MANUAL);
+    if (err < 0) {
+        throw VideoException("Could not set manual brightness mode");
+    }
+
+    err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_BRIGHTNESS, DC1394_ON);
+    if (err < 0) {
+        throw VideoException("Could not set absolute control for brightness");
+    }
+
+    err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_BRIGHTNESS, val);
+    if (err < 0) {
+        throw VideoException("Could not set brightness value");
+    }
+}
+
+float FirewireVideo::GetShutterTime() const
+{
+    float shutter;
+    err = dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_SHUTTER,&shutter);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to read shutter");
+
+    return shutter;
+}
+
+void FirewireVideo::SetAutoShutterTime()
+{
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_AUTO);
+    if (err < 0) {
+        throw VideoException("Could not set auto shutter mode");
+    }
+}
+
+void FirewireVideo::SetShutterTime(float val)
+{
+    dc1394error_t err = dc1394_feature_set_mode(camera, DC1394_FEATURE_SHUTTER, DC1394_FEATURE_MODE_MANUAL);
+    if (err < 0) {
+        throw VideoException("Could not set manual shutter mode");
+    }
+
+    err = dc1394_feature_set_absolute_control(camera, DC1394_FEATURE_SHUTTER, DC1394_ON);
+    if (err < 0) {
+        throw VideoException("Could not set absolute control for shutter");
+    }
+
+    err = dc1394_feature_set_absolute_value(camera, DC1394_FEATURE_SHUTTER, val);
+    if (err < 0) {
+        throw VideoException("Could not set shutter value");
+    }
+}
+
+void FirewireVideo::SetShutterTimeQuant(int shutter)
+{
+    // TODO: Set mode as well
+
+    err = dc1394_feature_set_value(camera,DC1394_FEATURE_SHUTTER,shutter);
+
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to set shutter");
+}
+
+float FirewireVideo::GetGamma() const
+{
+    float gamma;
+    err = dc1394_feature_get_absolute_value(camera,DC1394_FEATURE_GAMMA,&gamma);
+    if( err != DC1394_SUCCESS )
+        throw VideoException("Failed to read gamma");
+    return gamma;
+}
+
+void FirewireVideo::SetInternalTrigger()
+{
+    dc1394error_t err = dc1394_external_trigger_set_power(camera, DC1394_OFF);
+    if (err < 0) {
+        throw VideoException("Could not set internal trigger mode");
+    }
+}
+
+void FirewireVideo::SetExternalTrigger(dc1394trigger_mode_t mode, dc1394trigger_polarity_t polarity, dc1394trigger_source_t source)
+{
+    dc1394error_t err = dc1394_external_trigger_set_polarity(camera, polarity);
+    if (err < 0) {
+        throw VideoException("Could not set external trigger polarity");
+    }
+
+    err = dc1394_external_trigger_set_mode(camera, mode);
+    if (err < 0) {
+        throw VideoException("Could not set external trigger mode");
+    }
+
+    err = dc1394_external_trigger_set_source(camera, source);
+    if (err < 0) {
+        throw VideoException("Could not set external trigger source");
+    }
+
+    err = dc1394_external_trigger_set_power(camera, DC1394_ON);
+    if (err < 0) {
+        throw VideoException("Could not set external trigger power");
+    }
+}
+
+
+FirewireVideo::~FirewireVideo()
+{
+    Stop();
+
+    // Close camera
+    dc1394_video_set_transmission(camera, DC1394_OFF);
+    dc1394_capture_stop(camera);
+    dc1394_camera_free(camera);
+    dc1394_free (d);
+}
+
+void FirewireVideo::SetRegister(uint64_t offset, uint32_t value){
+    dc1394error_t err = dc1394_set_register (camera, offset, value);
+    if (err < 0) {
+        throw VideoException("Could not set camera register");
+    }
+}
+
+uint32_t FirewireVideo::GetRegister(uint64_t offset)
+{
+    uint32_t value = 0;
+    dc1394error_t err = dc1394_get_register (camera, offset, &value);
+    if (err < 0) {
+        throw VideoException("Could not get camera register");
+    }
+    return value;
+}
+
+void FirewireVideo::SetControlRegister(uint64_t offset, uint32_t value)
+{
+    dc1394error_t err = dc1394_set_control_register (camera, offset, value);
+    if (err < 0) {
+        throw VideoException("Could not set camera control register");
+    }
+}
+
+uint32_t FirewireVideo::GetControlRegister(uint64_t offset)
+{
+    uint32_t value = 0;
+    dc1394error_t err = dc1394_get_control_register(camera, offset, &value);
+    if (err < 0) {
+        throw VideoException("Could not get camera control register");
+    }
+    return value;
+}
+
+int FirewireVideo::nearest_value(int value, int step, int min, int max)
+{
+    int low, high;
+
+    low=value-(value%step);
+    high=value-(value%step)+step;
+    if (low<min)
+        low=min;
+    if (high>max)
+        high=max;
+
+    if (abs(low-value)<abs(high-value))
+        return low;
+    else
+        return high;
+}
+
+double FirewireVideo::bus_period_from_iso_speed(dc1394speed_t iso_speed)
+{
+    double bus_period;
+
+    switch(iso_speed){
+    case DC1394_ISO_SPEED_3200:
+        bus_period = 15.625e-6;
+        break;
+    case DC1394_ISO_SPEED_1600:
+        bus_period = 31.25e-6;
+        break;
+    case DC1394_ISO_SPEED_800:
+        bus_period = 62.5e-6;
+        break;
+    case DC1394_ISO_SPEED_400:
+        bus_period = 125e-6;
+        break;
+    case DC1394_ISO_SPEED_200:
+        bus_period = 250e-6;
+        break;
+    case DC1394_ISO_SPEED_100:
+        bus_period = 500e-6;
+        break;
+    default:
+        throw VideoException("iso speed not valid");
+    }
+
+    return bus_period;
+}
+
+dc1394video_mode_t get_firewire_format7_mode(const std::string fmt)
+{
+    const std::string FMT7_prefix = "FORMAT7_";
+
+    if( StartsWith(fmt, FMT7_prefix) )
+    {
+        int fmt7_mode = 0;
+        std::istringstream iss( fmt.substr(FMT7_prefix.size()) );
+        iss >> fmt7_mode;
+        if( !iss.fail() ) {
+            return (dc1394video_mode_t)(DC1394_VIDEO_MODE_FORMAT7_0 + fmt7_mode);
+        }
+    }
+
+    throw VideoException("Unknown video mode");
+}
+
+dc1394video_mode_t get_firewire_mode(unsigned width, unsigned height, const std::string fmt)
+{
+    for( dc1394video_mode_t video_mode=DC1394_VIDEO_MODE_MIN; video_mode<DC1394_VIDEO_MODE_MAX; video_mode = (dc1394video_mode_t)(video_mode +1) )
+    {
+        try {
+            unsigned w,h;
+            std::string format;
+            Dc1394ModeDetails(video_mode,w,h,format);
+
+            if( w == width && h==height && !fmt.compare(format) )
+                return video_mode;
+        } catch (const VideoException& e) {}
+    }
+
+    throw VideoException("Unknown video mode");
+}
+
+dc1394framerate_t get_firewire_framerate(float framerate)
+{
+    if(framerate==1.875)     return DC1394_FRAMERATE_1_875;
+    else if(framerate==3.75) return DC1394_FRAMERATE_3_75;
+    else if(framerate==7.5)  return DC1394_FRAMERATE_7_5;
+    else if(framerate==15)   return DC1394_FRAMERATE_15;
+    else if(framerate==30)   return DC1394_FRAMERATE_30;
+    else if(framerate==60)   return DC1394_FRAMERATE_60;
+    else if(framerate==120)  return DC1394_FRAMERATE_120;
+    else if(framerate==240)  return DC1394_FRAMERATE_240;
+    else throw VideoException("Invalid framerate");
+}
+
+PANGOLIN_REGISTER_FACTORY(FirewireVideo)
+{
+    struct FirewireVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"dc1394",10}, {"firewire",10}};
+        }
+        const char* Description() const override
+        {
+            return "Access Firewire (dc1394) cameras";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","RGB24","Pixel format: see pixel format help for all possible values. "},
+                {"size","640x480","Image dimensions in pixels. Will be crop from full sensor resolution."},
+                {"pos","0+0","top-left requested pixel offset"},
+                {"dma","10","Direct Memory Access (DMA) device queue size"},
+                {"iso","400","ISO sensitivity"},
+                {"fps","30","Frame per Second"},
+                {"deinterlace","0","Apply deinterlacing on video stream (0 off, 1 on)"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::string desired_format = uri.Get<std::string>("fmt","RGB24");
+            ToUpper(desired_format);
+            const ImageDim desired_dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const ImageDim desired_xy  = uri.Get<ImageDim>("pos", ImageDim(0,0));
+            const int desired_dma = uri.Get<int>("dma", 10);
+            const int desired_iso = uri.Get<int>("iso", 400);
+            const float desired_fps = uri.Get<float>("fps", 30);
+            const bool deinterlace = uri.Get<bool>("deinterlace", 0);
+
+            Guid guid = 0;
+            unsigned deviceid = 0;
+            dc1394framerate_t framerate = get_firewire_framerate(desired_fps);
+            dc1394speed_t iso_speed = (dc1394speed_t)(log(desired_iso/100) / log(2));
+            int dma_buffers = desired_dma;
+
+            VideoInterface* video_raw = nullptr;
+
+            if( StartsWith(desired_format, "FORMAT7") )
+            {
+                dc1394video_mode_t video_mode = get_firewire_format7_mode(desired_format);
+                if( guid.guid == 0 ) {
+                    video_raw = new FirewireVideo(deviceid,video_mode,FirewireVideo::MAX_FR, desired_dim.x, desired_dim.y, desired_xy.x, desired_xy.y, iso_speed, dma_buffers,true);
+                }else{
+                    video_raw = new FirewireVideo(guid,video_mode,FirewireVideo::MAX_FR, desired_dim.x, desired_dim.y, desired_xy.x, desired_xy.y, iso_speed, dma_buffers,true);
+                }
+            }else{
+                dc1394video_mode_t video_mode = get_firewire_mode(desired_dim.x, desired_dim.y,desired_format);
+                if( guid.guid == 0 ) {
+                    video_raw = new FirewireVideo(deviceid,video_mode,framerate,iso_speed,dma_buffers);
+                }else{
+                    video_raw = new FirewireVideo(guid,video_mode,framerate,iso_speed,dma_buffers);
+                }
+            }
+
+            if(deinterlace) {
+                std::unique_ptr<VideoInterface> video(video_raw);
+                video_raw = new DeinterlaceVideo(video);
+            }
+
+            return std::unique_ptr<VideoInterface>(video_raw);
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<FirewireVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/gamma.cpp

@@ -0,0 +1,375 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/gamma.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/utils/avx_math.h>
+
+namespace pangolin
+{
+
+
+GammaVideo::GammaVideo(std::unique_ptr<VideoInterface>& src_, const std::map<size_t, float> &stream_gammas)
+    : src(std::move(src_)), size_bytes(0), stream_gammas(stream_gammas)
+{
+    if(!src.get()) {
+        throw VideoException("GammaVideo: VideoInterface in must not be null");
+    }
+
+    videoin.push_back(src.get());
+
+    formats_supported.insert("GRAY8");
+    formats_supported.insert("GRAY16LE");
+    formats_supported.insert("RGB24");
+    formats_supported.insert("BGR24");
+    formats_supported.insert("RGB48");
+    formats_supported.insert("BGR48");
+    formats_supported.insert("RGBA32");
+    formats_supported.insert("BGRA32");
+    formats_supported.insert("RGBA64");
+    formats_supported.insert("BGRA64");
+
+    for(size_t s = 0; s < src->Streams().size(); s++)
+    {
+        auto i = stream_gammas.find(s);
+
+        if(i != stream_gammas.end() && i->second != 0.0f && i->second != 1.0f &&
+           formats_supported.count(src->Streams()[s].PixFormat().format) == 0)
+        {
+            throw VideoException("GammaVideo: Stream format not supported");
+        }
+
+        streams.push_back(src->Streams()[s]);
+        size_bytes += streams.back().SizeBytes();
+    }
+
+    buffer.reset(new uint8_t[src->SizeBytes()]);
+}
+
+GammaVideo::~GammaVideo()
+{
+}
+
+//! Implement VideoInput::Start()
+void GammaVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+//! Implement VideoInput::Stop()
+void GammaVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t GammaVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& GammaVideo::Streams() const
+{
+    return streams;
+}
+
+template <typename T>
+void ApplyGamma(Image<uint8_t>& out,
+                       const Image<uint8_t>& in,
+                       const float gamma,
+                       const float channel_max_value);
+
+#ifdef __AVX2__
+template <>
+void ApplyGamma<uint8_t>(Image<uint8_t>& out,
+                         const Image<uint8_t>& in,
+                         const float gamma,
+                         const float channel_max_value)
+{
+    //Special shuffling constants for bytes across lanes
+    const __m256i K0 = _mm256_setr_epi8(
+        0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u,
+        0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u);
+
+    const __m256i K1 = _mm256_setr_epi8(
+        0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u, 0xF0u,
+        0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u, 0x70u);
+
+    const __m256i shuffle = _mm256_setr_epi8(0, 4, 8, 12, 16, 20, 24, 28, 2, 9, 10, 11, 3, 13, 14, 15, 4,
+        17, 18, 19, 5, 21, 22, 23, 6, 25, 26, 27, 7, 29, 30, 31);
+
+    for(size_t r = 0; r < out.h; ++r)
+    {
+        uint8_t* pout = out.ptr + r * out.pitch;
+        uint8_t* pin = in.ptr + r * in.pitch;
+        const uint8_t* pin_end = in.ptr + (r + 1) * in.pitch;
+        const uint32_t numElems = in.pitch / sizeof(uint8_t);
+
+        constexpr int vecElems = 8;
+
+        const int numVecs = (numElems / vecElems) * vecElems;
+
+        //Processing eight at a time (max number of floats per vector)
+        for(int vec = 0; vec < numVecs; vec += vecElems, pin += vecElems, pout += vecElems)
+        {
+            //Convert bytes to floats
+            const __m256 floatVals = _mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(_mm_cvtsi64_si128(*(uint64_t*)pin)));
+
+            //Apply gamma and prepare for truncation (rounding) to integer
+            const __m256 gammaValues = _mm256_add_ps(_mm256_mul_ps(pow256_ps(_mm256_div_ps(floatVals, _mm256_set1_ps(channel_max_value)), _mm256_set1_ps(gamma)), _mm256_set1_ps(channel_max_value)), _mm256_set1_ps(0.5f));
+
+            //Clamp and convert to integer
+            __m256i gammaValuesI = _mm256_min_epi32(_mm256_max_epi32(_mm256_cvtps_epi32(gammaValues), _mm256_set1_epi32(0)), _mm256_set1_epi32(255));
+
+            //Unshuffle bytes to end of vector
+            gammaValuesI = _mm256_or_si256(_mm256_shuffle_epi8(gammaValuesI, _mm256_add_epi8(shuffle, K0)),
+                                           _mm256_shuffle_epi8(_mm256_permute4x64_epi64(gammaValuesI, 0x4E), _mm256_add_epi8(shuffle, K1)));
+
+            //Copy result out
+            *(uint64_t*)pout = _mm_cvtsi128_si64(_mm256_castsi256_si128(gammaValuesI));
+        }
+
+        //Remainder loose ends
+        while(pin != pin_end) {
+            *(pout++) = uint8_t(std::pow(float(*(pin++)) / channel_max_value, gamma) * channel_max_value + 0.5f);
+        }
+    }
+}
+
+template <>
+void ApplyGamma<uint16_t>(Image<uint8_t>& out,
+                          const Image<uint8_t>& in,
+                          const float gamma,
+                          const float channel_max_value)
+{
+    for(size_t r = 0; r < out.h; ++r)
+    {
+        uint16_t* pout = (uint16_t*)(out.ptr + r * out.pitch);
+        uint16_t* pin = (uint16_t*)(in.ptr + r * in.pitch);
+        const uint16_t* pin_end = (uint16_t*)(in.ptr + (r + 1) * in.pitch);
+        const uint32_t numElems = in.pitch / sizeof(uint16_t);
+
+        constexpr int vecElems = 8;
+
+        const int numVecs = (numElems / vecElems) * vecElems;
+
+        //Processing eight at a time (max number of floats per vector)
+        for(int vec = 0; vec < numVecs; vec += vecElems, pin += vecElems, pout += vecElems)
+        {
+            //Convert shorts to floats
+            const __m256 floatVals = _mm256_cvtepi32_ps(_mm256_cvtepu16_epi32(_mm_loadu_si128((const __m128i*)pin)));
+
+            //Apply gamma and prepare for truncation (rounding) to integer
+            const __m256 gammaValues = _mm256_add_ps(_mm256_mul_ps(pow256_ps(_mm256_div_ps(floatVals, _mm256_set1_ps(channel_max_value)), _mm256_set1_ps(gamma)), _mm256_set1_ps(channel_max_value)), _mm256_set1_ps(0.5f));
+
+            //Clamp and convert to integer
+            __m256i gammaValuesI = _mm256_min_epi32(_mm256_max_epi32(_mm256_cvtps_epi32(gammaValues), _mm256_set1_epi32(0)), _mm256_set1_epi32(65535));
+
+            //Unshuffle shorts to end of vector
+            gammaValuesI = _mm256_packs_epi32(gammaValuesI, _mm256_setzero_si256());
+            gammaValuesI = _mm256_permute4x64_epi64(gammaValuesI, 0xD8);
+
+            // Copy result out
+            *(__m128i*)pout = _mm256_castsi256_si128(gammaValuesI);
+        }
+
+        //Remainder loose ends
+        while(pin != pin_end) {
+            *(pout++) = uint16_t(std::pow(float(*(pin++)) / channel_max_value, gamma) * channel_max_value + 0.5f);
+        }
+    }
+}
+#else
+template <typename T>
+void ApplyGamma(Image<uint8_t>& out,
+                const Image<uint8_t>& in,
+                const float gamma,
+                const float channel_max_value)
+{
+    for(size_t r = 0; r < out.h; ++r)
+    {
+        T* pout = (T*)(out.ptr + r*out.pitch);
+        T* pin = (T*)(in.ptr + r*in.pitch);
+        const T* pin_end = (T*)(in.ptr + (r+1)*in.pitch);
+        while(pin != pin_end) {
+            *(pout++) = T(std::pow(float(*(pin++)) / channel_max_value, gamma) * channel_max_value + 0.5f);
+        }
+    }
+}
+#endif
+
+void GammaVideo::Process(uint8_t* buffer_out, const uint8_t* buffer_in)
+{
+    for(size_t s=0; s<streams.size(); ++s) {
+        Image<uint8_t> img_out = Streams()[s].StreamImage(buffer_out);
+        const Image<uint8_t> img_in  = videoin[0]->Streams()[s].StreamImage(buffer_in);
+        const size_t bytes_per_pixel = Streams()[s].PixFormat().bpp / 8;
+
+        auto i = stream_gammas.find(s);
+
+        if(i != stream_gammas.end() && i->second != 0.0f && i->second != 1.0f)
+        {
+            const float gamma = i->second;
+
+            if(Streams()[s].PixFormat().format == "GRAY8" ||
+               Streams()[s].PixFormat().format == "RGB24" ||
+               Streams()[s].PixFormat().format == "BGR24" ||
+               Streams()[s].PixFormat().format == "RGBA32" ||
+               Streams()[s].PixFormat().format == "BGRA32")
+            {
+                ApplyGamma<uint8_t>(img_out, img_in, gamma, std::pow(2, Streams()[s].PixFormat().channel_bit_depth) - 1);
+            }
+            else if(Streams()[s].PixFormat().format == "GRAY16LE" ||
+                    Streams()[s].PixFormat().format == "RGB48" ||
+                    Streams()[s].PixFormat().format == "BGR48" ||
+                    Streams()[s].PixFormat().format == "RGBA64" ||
+                    Streams()[s].PixFormat().format == "BGRA64")
+            {
+                ApplyGamma<uint16_t>(img_out, img_in, gamma, std::pow(2, Streams()[s].PixFormat().channel_bit_depth) - 1);
+            }
+            else
+            {
+                throw VideoException("GammaVideo: Stream format not supported");
+            }
+        }
+        else
+        {
+            //straight copy
+            if( img_out.w != img_in.w || img_out.h != img_in.h ) {
+                throw std::runtime_error("GammaVideo: Incompatible image sizes");
+            }
+
+            for(size_t y=0; y < img_out.h; ++y) {
+                std::memcpy(img_out.RowPtr((int)y), img_in.RowPtr((int)y), bytes_per_pixel * img_in.w);
+            }
+        }
+    }
+}
+
+//! Implement VideoInput::GrabNext()
+bool GammaVideo::GrabNext( uint8_t* image, bool wait )
+{
+    if(videoin[0]->GrabNext(buffer.get(),wait)) {
+        Process(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool GammaVideo::GrabNewest( uint8_t* image, bool wait )
+{
+    if(videoin[0]->GrabNewest(buffer.get(),wait)) {
+        Process(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& GammaVideo::InputStreams()
+{
+    return videoin;
+}
+
+uint32_t GammaVideo::AvailableFrames() const
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Gamma: child interface is not buffer aware.");
+        return 0;
+    }
+    else
+    {
+        return vpi->AvailableFrames();
+    }
+}
+
+bool GammaVideo::DropNFrames(uint32_t n)
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Gamma: child interface is not buffer aware.");
+        return false;
+    }
+    else
+    {
+        return vpi->DropNFrames(n);
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(GammaVideo)
+{
+    struct GammaVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        GammaVideoFactory()
+        {
+            param_set_ = {{
+                {"gamma\\d+","1.0","gammaK, where 1 <= K <= N where N is the number of streams"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+
+            ParamReader reader(param_set_, uri);
+            // Gamma for each stream
+            std::map<size_t, float> stream_gammas;
+            for(size_t i=0; i<100; ++i)
+            {
+                const std::string gamma_key = pangolin::FormatString("gamma%",i+1);
+
+                if(uri.Contains(gamma_key))
+                {
+                    stream_gammas[i] = reader.Get<float>(gamma_key, 1.0f);
+                }
+            }
+
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+
+            return std::unique_ptr<VideoInterface> (new GammaVideo(subvid, stream_gammas));
+        }
+        FactoryUseInfo Help( const std::string& scheme ) const override {
+            return FactoryUseInfo(scheme, "Gamma corrects a set of video streams", param_set_);
+        }
+
+        bool ValidateUri( const std::string& scheme, const Uri& uri, std::unordered_set<std::string>& unrecognized_params) const override {
+            return ValidateUriAgainstParamSet(scheme, param_set_, uri, unrecognized_params );
+        }
+
+        bool IsValidated( const std::string& ) const override {return true;}
+
+        ParamSet param_set_;
+    };
+
+    auto factory = std::make_shared<GammaVideoFactory>();
+    FactoryRegistry::I()->RegisterFactory<VideoInterface>(factory, 10, "gamma");
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/images.cpp

@@ -0,0 +1,315 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/video/drivers/images.h>
+#include <pangolin/video/iostream_operators.h>
+
+#include <cstring>
+#include <fstream>
+
+namespace pangolin
+{
+
+bool ImagesVideo::LoadFrame(size_t i)
+{
+    if( i < num_files) {
+        Frame& frame = loaded[i];
+        for(size_t c=0; c< num_channels; ++c) {
+            const std::string& filename = Filename(i,c);
+            const ImageFileType file_type = FileType(filename);
+
+            if(file_type == ImageFileTypeUnknown && unknowns_are_raw) {
+                // if raw_pitch is zero, assume image is packed.
+                const size_t pitch = raw_pitch ? raw_pitch : raw_fmt.bpp * raw_width / 8;
+                frame.push_back( LoadImage( filename, raw_fmt, raw_width, raw_height, pitch) );
+            }else{
+                frame.push_back( LoadImage( filename, file_type ) );
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+void ImagesVideo::PopulateFilenamesFromJson(const std::string& filename)
+{
+    std::ifstream ifs( PathExpand(filename));
+    picojson::value json;
+    const std::string err = picojson::parse(json, ifs);
+    if(err.empty()) {
+        const std::string folder = PathParent(filename) + "/";
+        device_properties = json["device_properties"];
+        json_frames = json["frames"];
+
+        num_files = json_frames.size();
+        if(num_files == 0) {
+            throw VideoException("Empty Json Image archive.");
+        }
+
+        num_channels = json_frames[0]["stream_files"].size();
+        if(num_channels == 0) {
+            throw VideoException("Empty Json Image archive.");
+        }
+
+        filenames.resize(num_channels);
+        for(size_t c=0; c < num_channels; ++c) {
+            filenames[c].resize(num_files);
+            for(size_t i = 0; i < num_files; ++i) {
+                const std::string path = json_frames[i]["stream_files"][c].get<std::string>();
+                filenames[c][i] = (path.size() && path[0] == '/') ? path : (folder + path);
+            }
+        }
+        loaded.resize(num_files);
+    }else{
+        throw VideoException(err);
+    }
+}
+
+void ImagesVideo::PopulateFilenames(const std::string& wildcard_path)
+{
+    const std::vector<std::string> wildcards = Expand(wildcard_path, '[', ']', ',');
+    num_channels = wildcards.size();
+
+    if(wildcards.size() == 1 ) {
+        const std::string expanded_path = PathExpand(wildcards[0]);
+        const std::string possible_archive_path = expanded_path + "/archive.json";
+
+        if (FileLowercaseExtention(expanded_path) == ".json" ) {
+            PopulateFilenamesFromJson(wildcards[0]);
+            return;
+        }else if(FileExists(possible_archive_path)){
+            PopulateFilenamesFromJson(possible_archive_path);
+            return;
+        }
+    }
+
+    filenames.resize(num_channels);
+
+    for(size_t i = 0; i < wildcards.size(); ++i) {
+        const std::string channel_wildcard = PathExpand(wildcards[i]);
+        FilesMatchingWildcard(channel_wildcard, filenames[i],  SortMethod::NATURAL);
+        if(num_files == size_t(-1)) {
+            num_files = filenames[i].size();
+        }else{
+            if( num_files != filenames[i].size() ) {
+                std::cerr << "Warning: Video Channels have unequal number of files" << std::endl;
+            }
+            num_files = std::min(num_files, filenames[i].size());
+        }
+        if(num_files == 0) {
+            throw VideoException("No files found for wildcard '" + channel_wildcard + "'");
+        }
+    }
+
+    // Resize empty frames vector to hold future images.
+    loaded.resize(num_files);
+}
+
+void ImagesVideo::ConfigureStreamSizes()
+{
+    size_bytes = 0;
+    for(size_t c=0; c < num_channels; ++c) {
+        const TypedImage& img = loaded[0][c];
+        const StreamInfo stream_info(img.fmt, img.w, img.h, img.pitch, (unsigned char*)(size_bytes));
+        streams.push_back(stream_info);
+        size_bytes += img.h*img.pitch;
+    }
+}
+
+ImagesVideo::ImagesVideo(const std::string& wildcard_path)
+    : num_files(-1), num_channels(0), next_frame_id(0),
+      unknowns_are_raw(false)
+{
+    // Work out which files to sequence
+    PopulateFilenames(wildcard_path);
+
+    // Load first image in order to determine stream sizes etc
+    LoadFrame(next_frame_id);
+
+    ConfigureStreamSizes();
+
+    // TODO: Queue frames in another thread.
+}
+
+ImagesVideo::ImagesVideo(const std::string& wildcard_path,
+                         const PixelFormat& raw_fmt,
+                         size_t raw_width, size_t raw_height, size_t raw_pitch
+)   : num_files(-1), num_channels(0), next_frame_id(0),
+      unknowns_are_raw(true), raw_fmt(raw_fmt),
+      raw_width(raw_width), raw_height(raw_height), raw_pitch(raw_pitch)
+{
+    // Work out which files to sequence
+    PopulateFilenames(wildcard_path);
+
+    // Load first image in order to determine stream sizes etc
+    LoadFrame(next_frame_id);
+
+    ConfigureStreamSizes();
+
+    // TODO: Queue frames in another thread.
+}
+
+ImagesVideo::~ImagesVideo()
+{
+}
+
+//! Implement VideoInput::Start()
+void ImagesVideo::Start()
+{
+
+}
+
+//! Implement VideoInput::Stop()
+void ImagesVideo::Stop()
+{
+
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t ImagesVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& ImagesVideo::Streams() const
+{
+    return streams;
+}
+
+//! Implement VideoInput::GrabNext()
+bool ImagesVideo::GrabNext( unsigned char* image, bool /*wait*/ )
+{
+    if(next_frame_id < loaded.size()) {
+        Frame& frame = loaded[next_frame_id];
+
+        if(frame.size() != num_channels) {
+            LoadFrame(next_frame_id);
+        }
+
+        for(size_t c=0; c < num_channels; ++c){
+            TypedImage& img = frame[c];
+            if(!img.ptr || img.w != streams[c].Width() || img.h != streams[c].Height() ) {
+                return false;
+            }
+            const StreamInfo& si = streams[c];
+            std::memcpy(image + (size_t)si.Offset(), img.ptr, si.SizeBytes());
+            img.Deallocate();
+        }
+        frame.clear();
+
+        next_frame_id++;
+        return true;
+    }
+
+    return false;
+}
+
+//! Implement VideoInput::GrabNewest()
+bool ImagesVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image,wait);
+}
+
+size_t ImagesVideo::GetCurrentFrameId() const
+{
+    return (int)next_frame_id - 1;
+}
+
+size_t ImagesVideo::GetTotalFrames() const
+{
+    return num_files;
+}
+
+size_t ImagesVideo::Seek(size_t frameid)
+{
+    next_frame_id = std::max(size_t(0), std::min(frameid, num_files));
+    return next_frame_id;
+}
+
+const picojson::value& ImagesVideo::DeviceProperties() const
+{
+    return device_properties;
+}
+
+const picojson::value& ImagesVideo::FrameProperties() const
+{
+    const size_t frame = GetCurrentFrameId();
+
+    if( json_frames.evaluate_as_boolean() && frame < json_frames.size()) {
+        const picojson::value& frame_props = json_frames[frame];
+        if(frame_props.contains("frame_properties")) {
+            return frame_props["frame_properties"];
+        }
+    }
+
+    return null_props;
+}
+
+PANGOLIN_REGISTER_FACTORY(ImagesVideo)
+{
+    struct ImagesVideoVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"file",20}, {"files",20}, {"image",10}, {"images",10}};
+        }
+        const char* Description() const override
+        {
+            return "Load an image collection as a video. Supports one or more synchronized streams.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","GRAY8","RAW files only. Pixel format, see pixel format help for all possible values"},
+                {"size","640x480","RAW files only. Image size, required if fmt is specified"},
+                {"pitch","0","RAW files only. Specify distance from the start of one row to the next in bytes. If not specified, assumed image is packed."}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(),uri);
+
+            const bool raw = reader.Contains("fmt");
+            const std::string path = PathExpand(uri.url);
+
+            if(raw) {
+                const std::string sfmt = reader.Get<std::string>("fmt");
+                const PixelFormat fmt = PixelFormatFromString(sfmt);
+                const ImageDim dim = reader.Get<ImageDim>("size");
+                const size_t image_pitch = reader.Get<int>("pitch");
+                return std::unique_ptr<VideoInterface>( new ImagesVideo(path, fmt, dim.x, dim.y, image_pitch) );
+            }else{
+                return std::unique_ptr<VideoInterface>( new ImagesVideo(path) );
+            }
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<ImagesVideoVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/images_out.cpp

@@ -0,0 +1,141 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <iomanip>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/video/drivers/images_out.h>
+
+namespace pangolin {
+
+ImagesVideoOutput::ImagesVideoOutput(const std::string& image_folder, const std::string& json_file_out, const std::string& image_file_extension)
+    : json_frames(picojson::array_type,true),
+      image_index(0), image_folder( PathExpand(image_folder) + "/" ), image_file_extension(image_file_extension)
+{
+    if(!json_file_out.empty()) {
+        file.open(json_file_out);
+        if(!file.is_open()) {
+            throw std::runtime_error("Unable to open json file for writing, " + json_file_out + ". Make sure output folder already exists.");
+        }
+    }
+}
+
+ImagesVideoOutput::~ImagesVideoOutput()
+{
+    if(file.is_open())
+    {
+        const std::string video_uri = "images://" + image_folder + "archive.json";
+        picojson::value json_file;
+        json_file["device_properties"] = device_properties;
+        json_file["frames"] = json_frames;
+        json_file["input_uri"] = input_uri;
+        json_file["video_uri"] = video_uri;
+
+        // Serialize json to file.
+        file << json_file.serialize(true);
+    }
+}
+
+const std::vector<StreamInfo>& ImagesVideoOutput::Streams() const
+{
+    return streams;
+}
+
+void ImagesVideoOutput::SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri, const picojson::value& device_properties)
+{
+    this->streams = streams;
+    this->input_uri = uri;
+    this->device_properties = device_properties;
+}
+
+int ImagesVideoOutput::WriteStreams(const unsigned char* data, const picojson::value& frame_properties)
+{
+    picojson::value json_filenames(picojson::array_type, true);
+
+    // Write each stream image to file.
+    for(size_t s=0; s < streams.size(); ++s) {
+        const pangolin::StreamInfo& si = streams[s];
+        const std::string filename = pangolin::FormatString("image_%%%_%.%",std::setfill('0'),std::setw(10),image_index, s, image_file_extension);
+        json_filenames.push_back(filename);
+        const Image<unsigned char> img = si.StreamImage(data);
+        pangolin::SaveImage(img, si.PixFormat(), image_folder + filename);
+    }
+
+    // Add frame_properties to json file.
+    picojson::value json_frame;
+    json_frame["frame_properties"] = frame_properties;
+    json_frame["stream_files"] = json_filenames;
+    json_frames.push_back(json_frame);
+
+    ++image_index;
+    return 0;
+}
+
+bool ImagesVideoOutput::IsPipe() const
+{
+    return false;
+}
+
+PANGOLIN_REGISTER_FACTORY(ImagesVideoOutput)
+{
+    struct ImagesVideoFactory final : public TypedFactoryInterface<VideoOutputInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"images",10}};
+        }
+        const char* Description() const override
+        {
+            return "Writes video frames out to sequance of images + json index file.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","png","Output image format. Possible values are all Pangolin image formats e.g.: png,jpg,jpeg,ppm,pgm,pxm,pdm,zstd,lzf,p12b,exr,pango"}
+            }};
+        }
+        std::unique_ptr<VideoOutputInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(),uri);
+
+            const std::string images_folder = PathExpand(uri.url);
+            const std::string json_filename = images_folder + "/archive.json";
+            const std::string image_extension = reader.Get<std::string>("fmt");
+
+            if(FileExists(json_filename)) {
+                throw std::runtime_error("Dataset already exists in directory.");
+            }
+
+            return std::unique_ptr<VideoOutputInterface>(
+                new ImagesVideoOutput(images_folder, json_filename, image_extension)
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoOutputInterface>(std::make_shared<ImagesVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/join.cpp

@@ -0,0 +1,620 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <thread>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/drivers/join.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+//#define DEBUGJOIN
+
+#ifdef DEBUGJOIN
+#include <pangolin/utils/timer.h>
+#define TSTART()                         \
+    pangolin::basetime start, last, now; \
+    start = pangolin::TimeNow();         \
+    last = start;
+#define TGRABANDPRINT(...)                                               \
+    now = pangolin::TimeNow();                                           \
+    fprintf(stderr, "JOIN: ");                                           \
+    fprintf(stderr, __VA_ARGS__);                                        \
+    fprintf(stderr, " %fms.\n", 1000 * pangolin::TimeDiff_s(last, now)); \
+    last = now;
+#define DBGPRINT(...)             \
+    fprintf(stderr, "JOIN: ");    \
+    fprintf(stderr, __VA_ARGS__); \
+    fprintf(stderr, "\n");
+#else
+#define TSTART()
+#define TGRABANDPRINT(...)
+#define DBGPRINT(...)
+#endif
+
+namespace pangolin
+{
+JoinVideo::JoinVideo(std::vector<std::unique_ptr<VideoInterface>>& src_, const bool verbose)
+    : storage(std::move(src_)), size_bytes(0), sync_tolerance_us(0), verbose(verbose)
+{
+    for(auto& p : storage)
+    {
+        src.push_back(p.get());
+        frame_seen.push_back(false);
+    }
+
+    // Add individual streams
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        VideoInterface& vid = *src[s];
+        for(size_t i = 0; i < vid.Streams().size(); ++i)
+        {
+            const StreamInfo si = vid.Streams()[i];
+            const PixelFormat fmt = si.PixFormat();
+            const Image<unsigned char> img_offset = si.StreamImage((unsigned char*)size_bytes);
+            streams.push_back(StreamInfo(fmt, img_offset));
+        }
+        size_bytes += src[s]->SizeBytes();
+    }
+}
+
+JoinVideo::~JoinVideo()
+{
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        src[s]->Stop();
+    }
+}
+
+size_t JoinVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+const std::vector<StreamInfo>& JoinVideo::Streams() const
+{
+    return streams;
+}
+
+void JoinVideo::Start()
+{
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        src[s]->Start();
+    }
+}
+
+void JoinVideo::Stop()
+{
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        src[s]->Stop();
+    }
+}
+
+bool JoinVideo::Sync(int64_t tolerance_us, double transfer_bandwidth_gbps)
+{
+    transfer_bandwidth_bytes_per_us = int64_t((transfer_bandwidth_gbps * 1E3) / 8.0);
+    //    std::cout << "transfer_bandwidth_gbps: " << transfer_bandwidth_gbps << std::endl;
+
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        picojson::value props = GetVideoDeviceProperties(src[s]);
+        if(!props.get_value(PANGO_HAS_TIMING_DATA, false))
+        {
+            if(props.contains("streams"))
+            {
+                picojson::value streams = props["streams"];
+                for(size_t i = 0; i < streams.size(); ++i)
+                {
+                    if(!streams[i].get_value(PANGO_HAS_TIMING_DATA, false))
+                    {
+                        sync_tolerance_us = 0;
+                        return false;
+                    }
+                }
+            }
+            else
+            {
+                sync_tolerance_us = 0;
+                return false;
+            }
+        }
+    }
+
+    sync_tolerance_us = tolerance_us;
+
+    //    std::cout << "transfer_bandwidth_bytes_per_us: " << transfer_bandwidth_bytes_per_us << std::endl;
+    return true;
+}
+
+// Assuming that src_index supports VideoPropertiesInterface and has a valid PANGO_HOST_RECEPTION_TIME_US, or
+// PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US
+// returns a capture time adjusted for transfer time and when possible also for exposure.
+int64_t JoinVideo::GetAdjustedCaptureTime(size_t src_index)
+{
+    picojson::value props = GetVideoFrameProperties(src[src_index]);
+    if(props.contains(PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US))
+    {
+        // great, the driver already gave us an estimated center of capture
+        if(props.contains(PANGO_JOIN_OFFSET_US))
+        {
+            // apply join offset if the driver gave it to us
+            return props[PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US].get<int64_t>() +
+                   props[PANGO_JOIN_OFFSET_US].get<int64_t>();
+        }
+        else
+        {
+            return props[PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US].get<int64_t>();
+        }
+    }
+    else
+    {
+        if(props.contains(PANGO_HOST_RECEPTION_TIME_US))
+        {
+            int64_t transfer_time_us = 0;
+            if(transfer_bandwidth_bytes_per_us > 0)
+            {
+                transfer_time_us = src[src_index]->SizeBytes() / transfer_bandwidth_bytes_per_us;
+            }
+            std::cerr << "JoinVideo: Stream " << src_index << " does contain PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US using incorrect fallback. " << std::endl;
+            return props[PANGO_HOST_RECEPTION_TIME_US].get<int64_t>() - transfer_time_us;
+        }
+        else
+        {
+            if(props.contains("streams"))
+            {
+                picojson::value streams = props["streams"];
+
+                if(streams.size() > 0)
+                {
+                    if(streams[0].contains(PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US))
+                    {
+                        // great, the driver already gave us an estimated center of capture
+                        return streams[0][PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US].get<int64_t>();
+                    }
+                    else if(streams[0].contains(PANGO_HOST_RECEPTION_TIME_US))
+                    {
+                        int64_t transfer_time_us = 0;
+                        if(transfer_bandwidth_bytes_per_us > 0)
+                        {
+                            transfer_time_us = src[src_index]->SizeBytes() / transfer_bandwidth_bytes_per_us;
+                        }
+                     std::cerr << "JoinVideo: Stream " << src_index << " does contain PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US using incorrect fallback. " << std::endl;
+                        return streams[0][PANGO_HOST_RECEPTION_TIME_US].get<int64_t>() - transfer_time_us;
+                    }
+                }
+            }
+        }
+
+        PANGO_ENSURE(false,
+                     "JoinVideo: Stream % does contain suffcient timing info to obtain or estimate the host center "
+                     "capture time.\n",
+                     src_index);
+        return 0;
+    }
+}
+
+bool JoinVideo::GrabNext(unsigned char* image, bool wait)
+{
+    std::vector<size_t> offsets(src.size(), 0);
+    std::vector<int64_t> capture_us(src.size(), 0);
+
+    TSTART()
+    DBGPRINT("Entering GrabNext:")
+
+    constexpr size_t loop_sleep_us = 500;
+    size_t total_sleep_us = 0;
+    // Arbitrary length of time larger than any reasonble period/exposure.
+    const size_t total_sleep_threshold_us = 200000;
+    size_t unfilled_images = src.size();
+
+    while (true)
+    {
+        size_t offset = 0;
+        for(size_t s = 0; s < src.size(); ++s)
+        {
+            if (capture_us[s] == 0) {
+                if(src[s]->GrabNext(image + offset, false))
+                {
+                    if(sync_tolerance_us > 0)
+                    {
+                        capture_us[s] = GetAdjustedCaptureTime(s);
+                    }
+                    else
+                    {
+                        capture_us[s] = std::numeric_limits<int64_t>::max();
+                    }
+
+                    frame_seen[s] = true;
+                    offsets[s] = offset;
+                    unfilled_images -= 1;
+                }
+            }
+
+            offset += src[s]->SizeBytes();
+        }
+
+        if (!wait || unfilled_images == 0)
+        {
+            // If the caller did not request to wait, or all images were retrieved, we are done.
+            break;
+        }
+
+        // Sleep to simulate the blocking behavior of wait == true.
+        std::this_thread::sleep_for(std::chrono::microseconds(loop_sleep_us));
+
+        total_sleep_us += loop_sleep_us;
+        if (sync_tolerance_us != 0 && total_sleep_us > total_sleep_threshold_us)
+        {
+            // We've waited long enough. Report on which cameras were not responding.
+            pango_print_warn(
+                "JoinVideo: Not all frames were delivered within the threshold of %zuus. Cameras not reporting:\n",
+                total_sleep_threshold_us);
+            for(size_t blocked = 0; blocked < src.size(); ++blocked)
+            {
+                if (capture_us[blocked] == 0)
+                {
+                    // Unfortunately, at this level we don't have any good label/description for the stream.
+                    pango_print_warn("           Stream %zu%s\n",
+                                     blocked,
+                                     frame_seen[blocked] ? "" : " [never reported]");
+                }
+            }
+            // Give up on this frame.
+            break;
+        }
+    }
+
+    // Check if any streams didn't return an image. This means a stream is waiting on data or has finished.
+    if(std::any_of(capture_us.begin(), capture_us.end(), [](int64_t v) { return v == 0; }))
+    {
+        return false;
+    }
+
+    // Check Sync if a tolerence has been specified.
+    if(sync_tolerance_us > 0)
+    {
+        auto range = std::minmax_element(capture_us.begin(), capture_us.end());
+        if((*range.second - *range.first) > sync_tolerance_us)
+        {
+            if(verbose)
+            {
+                pango_print_warn(
+                    "JoinVideo: Source timestamps span  %lu us, not within %lu us. Ignoring frames, trying to "
+                    "sync...\n",
+                    (unsigned long)((*range.second - *range.first)),
+                    (unsigned long)sync_tolerance_us);
+            }
+
+            // Attempt to resync...
+            for(size_t n = 0; n < 10; ++n)
+            {
+                for(size_t s = 0; s < src.size(); ++s)
+                {
+                    // Catch up frames that are behind
+                    if(capture_us[s] < (*range.second - sync_tolerance_us))
+                    {
+                        if(src[s]->GrabNext(image + offsets[s], true))
+                        {
+                            capture_us[s] = GetAdjustedCaptureTime(s);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Check sync again
+        range = std::minmax_element(capture_us.begin(), capture_us.end());
+        if((*range.second - *range.first) > sync_tolerance_us)
+        {
+            TGRABANDPRINT("NOT IN SYNC oldest:%ld newest:%ld delta:%ld",
+                          *range.first,
+                          *range.second,
+                          (*range.second - *range.first));
+            return false;
+        }
+        else
+        {
+            TGRABANDPRINT("    IN SYNC oldest:%ld newest:%ld delta:%ld",
+                          *range.first,
+                          *range.second,
+                          (*range.second - *range.first));
+            return true;
+        }
+    }
+    else
+    {
+        pango_print_warn("JoinVideo: sync_tolerance_us = 0, frames are not synced!\n");
+        return true;
+    }
+}
+
+bool AllInterfacesAreBufferAware(std::vector<VideoInterface*>& src)
+{
+    for(size_t s = 0; s < src.size(); ++s)
+    {
+        if(!dynamic_cast<BufferAwareVideoInterface*>(src[s]))
+            return false;
+    }
+    return true;
+}
+
+bool JoinVideo::GrabNewest(unsigned char* image, bool wait)
+{
+    // TODO: Tidy to correspond to GrabNext()
+    TSTART()
+    DBGPRINT("Entering GrabNewest:");
+    if(AllInterfacesAreBufferAware(src))
+    {
+        DBGPRINT("All interfaces are BufferAwareVideoInterface.")
+        unsigned int minN = std::numeric_limits<unsigned int>::max();
+        // Find smallest number of frames it is safe to drop.
+        for(size_t s = 0; s < src.size(); ++s)
+        {
+            auto bai = dynamic_cast<BufferAwareVideoInterface*>(src[s]);
+            unsigned int n = bai->AvailableFrames();
+            minN = std::min(n, minN);
+            DBGPRINT("Interface %ld has %u frames available.", s, n)
+        }
+        TGRABANDPRINT("Quering avalable frames took ")
+        DBGPRINT("Safe number of buffers to drop: %d.", ((minN > 1) ? (minN - 1) : 0));
+
+        // Safely drop minN-1 frames on each interface.
+        if(minN > 1)
+        {
+            for(size_t s = 0; s < src.size(); ++s)
+            {
+                auto bai = dynamic_cast<BufferAwareVideoInterface*>(src[s]);
+                if(!bai->DropNFrames(minN - 1))
+                {
+                    pango_print_error(
+                            "Stream %lu did not drop %u frames altough available.\n", (unsigned long)s, (minN - 1));
+                    return false;
+                }
+            }
+            TGRABANDPRINT("Dropping %u frames on each interface took ", (minN - 1));
+        }
+        return GrabNext(image, wait);
+    }
+    else
+    {
+        DBGPRINT("NOT all interfaces are BufferAwareVideoInterface.")
+        // Simply calling GrabNewest on the child streams might cause loss of sync,
+        // instead we perform as many GrabNext as possible on the first stream and
+        // then pull the same number of frames from every other stream.
+        size_t offset = 0;
+        std::vector<size_t> offsets;
+        std::vector<int64_t> reception_times;
+        int64_t newest = std::numeric_limits<int64_t>::min();
+        int64_t oldest = std::numeric_limits<int64_t>::max();
+        bool grabbed_any = false;
+        int first_stream_backlog = 0;
+        int64_t rt = 0;
+        bool got_frame = false;
+
+        do
+        {
+            got_frame = src[0]->GrabNext(image + offset, false);
+            if(got_frame)
+            {
+                if(sync_tolerance_us > 0)
+                {
+                    rt = GetAdjustedCaptureTime(0);
+                }
+                first_stream_backlog++;
+                grabbed_any = true;
+            }
+        } while(got_frame);
+        offsets.push_back(offset);
+        offset += src[0]->SizeBytes();
+        if(sync_tolerance_us > 0)
+        {
+            reception_times.push_back(rt);
+            if(newest < rt)
+                newest = rt;
+            if(oldest > rt)
+                oldest = rt;
+        }
+        TGRABANDPRINT("Stream 0 grab took ");
+
+        for(size_t s = 1; s < src.size(); ++s)
+        {
+            for(int i = 0; i < first_stream_backlog; i++)
+            {
+                grabbed_any |= src[s]->GrabNext(image + offset, true);
+                if(sync_tolerance_us > 0)
+                {
+                    rt = GetAdjustedCaptureTime(s);
+                }
+            }
+            offsets.push_back(offset);
+            offset += src[s]->SizeBytes();
+            if(sync_tolerance_us > 0)
+            {
+                reception_times.push_back(rt);
+                if(newest < rt)
+                    newest = rt;
+                if(oldest > rt)
+                    oldest = rt;
+            }
+        }
+        TGRABANDPRINT("Stream >=1 grab took ");
+
+        if(sync_tolerance_us > 0)
+        {
+            if(std::abs(newest - oldest) > sync_tolerance_us)
+            {
+                if(verbose)
+                {
+                    pango_print_warn("Join timestamps not within %lu us trying to sync\n",
+                                 (unsigned long)sync_tolerance_us);
+                }
+                for(size_t n = 0; n < 10; ++n)
+                {
+                    for(size_t s = 0; s < src.size(); ++s)
+                    {
+                        if(reception_times[s] < (newest - sync_tolerance_us))
+                        {
+                            VideoInterface& vid = *src[s];
+                            if(vid.GrabNewest(image + offsets[s], false))
+                            {
+                                rt = GetAdjustedCaptureTime(s);
+                                if(newest < rt)
+                                    newest = rt;
+                                if(oldest > rt)
+                                    oldest = rt;
+                                reception_times[s] = rt;
+                            }
+                        }
+                    }
+                }
+            }
+
+            if(std::abs(newest - oldest) > sync_tolerance_us)
+            {
+                TGRABANDPRINT(
+                        "NOT IN SYNC newest:%ld oldest:%ld delta:%ld syncing took ", newest, oldest, (newest - oldest));
+                return false;
+            }
+            else
+            {
+                TGRABANDPRINT(
+                        "    IN SYNC newest:%ld oldest:%ld delta:%ld syncing took ", newest, oldest, (newest - oldest));
+                return true;
+            }
+        }
+        else
+        {
+            return true;
+        }
+    }
+}
+
+std::vector<VideoInterface*>& JoinVideo::InputStreams()
+{
+    return src;
+}
+
+std::vector<std::string> SplitBrackets(const std::string src, char open = '{', char close = '}')
+{
+    std::vector<std::string> splits;
+
+    int nesting = 0;
+    int begin = -1;
+
+    for(size_t i = 0; i < src.length(); ++i)
+    {
+        if(src[i] == open)
+        {
+            if(nesting == 0)
+            {
+                begin = (int)i;
+            }
+            nesting++;
+        }
+        else if(src[i] == close)
+        {
+            nesting--;
+            if(nesting == 0)
+            {
+                // matching close bracket.
+                int str_start = begin + 1;
+                splits.push_back(src.substr(str_start, i - str_start));
+            }
+        }
+    }
+
+    return splits;
+}
+
+PANGOLIN_REGISTER_FACTORY(JoinVideo)
+{
+    struct JoinVideoFactory final : public TypedFactoryInterface<VideoInterface>
+    {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"join",10}, {"zip",10}};
+        }
+        const char* Description() const override
+        {
+            return "Zips two or more videos together to create a new video containing all of constituent streams in correspondence.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"sync_tolerance_us", "0", "The maximum timestamp difference (in microsecs) between images that are considered to be in sync for joining"},
+                {"transfer_bandwidth_gbps","0", "Bandwidth used to compute exposure end time from reception time for sync logic"},
+                {"Verbose","false","For verbose error/warning messages"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override
+        {
+            std::vector<std::string> uris = SplitBrackets(uri.url);
+
+            ParamReader reader(Params(), uri);
+
+            // Standard by which we should measure if frames are in sync.
+            const unsigned long sync_tol_us = reader.Get<unsigned long>("sync_tolerance_us");
+
+            // Bandwidth used to compute exposure end time from reception time for sync logic
+            const double transfer_bandwidth_gbps = reader.Get<double>("transfer_bandwidth_gbps");
+            const bool verbose = reader.Get<bool>("Verbose");
+            if(uris.size() == 0)
+            {
+                throw VideoException("No VideoSources found in join URL.",
+                                     "Specify videos to join with curly braces, e.g. join://{test://}{test://}");
+            }
+
+            std::vector<std::unique_ptr<VideoInterface>> src;
+            for(size_t i = 0; i < uris.size(); ++i)
+            {
+                src.push_back(pangolin::OpenVideo(uris[i]));
+            }
+
+            JoinVideo* video_raw = new JoinVideo(src, verbose);
+
+            if(sync_tol_us > 0)
+            {
+                if(!video_raw->Sync(sync_tol_us, transfer_bandwidth_gbps))
+                {
+                    pango_print_error(
+                            "WARNING: not all streams in join support sync_tolerance_us option. Not using "
+                            "tolerance.\n");
+                }
+            }
+
+            return std::unique_ptr<VideoInterface>(video_raw);
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<JoinVideoFactory>());
+}
+}
+
+#undef TSTART
+#undef TGRABANDPRINT
+#undef DBGPRINT

third-party/DPVO/Pangolin/components/pango_video/src/drivers/json.cpp

@@ -0,0 +1,98 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/video.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/file_extension.h>
+#include <pangolin/utils/transform.h>
+
+#include <fstream>
+#include <functional>
+
+namespace pangolin {
+
+PANGOLIN_REGISTER_FACTORY(JsonVideo)
+{
+    struct JsonVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"json",0}, {"file",5}};
+        }
+        const char* Description() const override
+        {
+            return "Construct Video URI from supplied json file. Json file should contain video_uri string and video_uri_defaults map for overridable substitutions.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"*","","Override any video_uri_defaults keys in the json file."},
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            if(uri.scheme == "json" || (uri.scheme == "file" && FileLowercaseExtention(uri.url) == ".json")) {
+                const std::string json_filename = PathExpand(uri.url);
+                std::ifstream f( json_filename );
+
+                // Parse json file to determine sub-video
+                if(f.is_open())
+                {
+                    picojson::value file_json(picojson::object_type,true);
+                    const std::string err = picojson::parse(file_json,f);
+                    if(err.empty())
+                    {
+                        // Json loaded. Parse output.
+                        std::string input_uri = file_json.get_value<std::string>("video_uri", "");
+                        if(!input_uri.empty())
+                        {
+                            // Transform input_uri based on sub args.
+                            const picojson::value input_uri_params = file_json.get_value<picojson::object>("video_uri_defaults", picojson::object());
+                            input_uri = Transform(input_uri, [&](const std::string& k) {
+                                return uri.Get<std::string>(k, input_uri_params.contains(k) ? input_uri_params[k].to_str() : "#");
+                            });
+
+                            return pangolin::OpenVideo(input_uri);
+                        }else{
+                            throw VideoException("JsonVideo failed.", "Bad input URI.");
+                        }
+                    }else{
+                        throw VideoException("JsonVideo failed.", err);
+                    }
+                }else{
+                    throw VideoException("JsonVideo failed. Unable to load file.", json_filename);
+                }
+            }else{
+                // Not applicable for this factory.
+                return std::unique_ptr<VideoInterface>();
+            }
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<JsonVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/merge.cpp

@@ -0,0 +1,182 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/merge.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/video.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/utils/range.h>
+#include <assert.h>
+
+#include <assert.h>
+
+namespace pangolin
+{
+
+MergeVideo::MergeVideo(std::unique_ptr<VideoInterface>& src_, const std::vector<Point>& stream_pos, size_t w = 0, size_t h = 0 )
+    : src( std::move(src_) ), buffer(new uint8_t[src->SizeBytes()]), stream_pos(stream_pos)
+{
+    videoin.push_back(src.get());
+
+    // Must be a stream_pos for each stream
+    // Each stream must have the same format.
+    assert(stream_pos.size() == src->Streams().size());
+    assert(src->Streams().size() > 0);
+    const PixelFormat fmt = src->Streams()[0].PixFormat();
+    for(size_t i=1; i < src->Streams().size(); ++i) {
+        assert(src->Streams()[i].PixFormat().format == fmt.format);
+    }
+
+    // Compute buffer regions for data copying.
+    XYRange<size_t> r = XYRange<size_t>::Empty();
+    for(size_t i=0; i < src->Streams().size(); ++i) {
+        const StreamInfo& si = src->Streams()[i];
+        const size_t x = stream_pos[i].x;
+        const size_t y = stream_pos[i].y;
+        XYRange<size_t> sr(x, x + si.Width(), y, y + si.Height());
+        r.Insert(sr);
+    }
+
+    // Use implied min / max based on points
+    if(!w && !h) {
+        w = r.x.max;
+        h = r.y.max;
+    }
+
+    size_bytes = w*h*fmt.bpp/8;
+    streams.emplace_back(fmt,w,h,w*fmt.bpp/8,(unsigned char*)0);
+}
+
+MergeVideo::~MergeVideo()
+{
+
+}
+
+//! Implement VideoInput::Start()
+void MergeVideo::Start()
+{
+    src->Start();
+}
+
+//! Implement VideoInput::Stop()
+void MergeVideo::Stop()
+{
+    src->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t MergeVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& MergeVideo::Streams() const
+{
+    return streams;
+}
+
+void MergeVideo::CopyBuffer(unsigned char* dst_bytes, unsigned char* src_bytes)
+{
+    Image<unsigned char> dst_image = Streams()[0].StreamImage(dst_bytes);
+    const size_t dst_pix_bytes = Streams()[0].PixFormat().bpp / 8;
+
+    for(size_t i=0; i < stream_pos.size(); ++i) {
+        const StreamInfo& src_stream = src->Streams()[i];
+        const Image<unsigned char> src_image = src_stream.StreamImage(src_bytes);
+        const Point& p = stream_pos[i];
+        for(size_t y=0; y < src_stream.Height(); ++y) {
+            // Copy row from src to dst
+            std::memcpy(
+                dst_image.RowPtr(y + p.y) + p.x * dst_pix_bytes,
+                src_image.RowPtr(y), src_stream.RowBytes()
+            );
+        }
+    }
+}
+
+//! Implement VideoInput::GrabNext()
+bool MergeVideo::GrabNext( unsigned char* image, bool wait )
+{
+    const bool success = src->GrabNext(buffer.get(), wait);
+    if(success) CopyBuffer(image, buffer.get());
+    return success;
+}
+
+//! Implement VideoInput::GrabNewest()
+bool MergeVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    const bool success = src->GrabNewest(buffer.get(), wait);
+    if(success) CopyBuffer(image, buffer.get());
+    return success;
+}
+
+std::vector<VideoInterface*>& MergeVideo::InputStreams()
+{
+    return videoin;
+}
+
+PANGOLIN_REGISTER_FACTORY(MergeVideo)
+{
+    struct MergeVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"merge",10}};
+        }
+        const char* Description() const override
+        {
+            return "Merges seperate video streams into one larger stream with configurable position.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","0x0","Destination image size. 0x0 will dynamically create a bounding box size from all the streams and their x,y positions"},
+                {"pos\\d+","0x0","posK, 0 <= K < N, where N is the number of streams. Destination x,y positions to merge video streams into."}
+            }};
+        }
+
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(), uri);
+            const ImageDim dim = reader.Get<ImageDim>("size", ImageDim(0,0));
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            std::vector<Point> points;
+            Point p(0,0);
+            for(size_t s=0; s < subvid->Streams().size(); ++s) {
+                const StreamInfo& si = subvid->Streams()[s];
+                p = reader.Get<Point>("pos"+std::to_string(s+1), p);
+                points.push_back(p);
+                p.x += si.Width();
+            }
+
+            return std::unique_ptr<VideoInterface>(new MergeVideo(subvid, points, dim.x, dim.y));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<MergeVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/mjpeg.cpp

@@ -0,0 +1,152 @@
+#include <pangolin/platform.h>
+#include <pangolin/video/drivers/mjpeg.h>
+#include <pangolin/video/video_exception.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/utils/file_utils.h>
+
+namespace pangolin
+{
+
+// this is defined in image_io_jpg.cpp but not in any public headers.
+std::vector<std::streampos> GetMJpegOffsets(std::ifstream& is);
+
+MjpegVideo::MjpegVideo(const std::string& filename)
+{
+    const std::string full_path = PathExpand(filename);
+    if(!FileExists(full_path)) {
+        throw VideoException("No such file, " + full_path);
+    }
+
+    const ImageFileType file_type = FileType(full_path);
+    if(file_type != ImageFileType::ImageFileTypeJpg) {
+        throw VideoException(full_path + " has no jpeg header when attempting to open as mjpeg stream.");
+    }
+
+    bFile.open( full_path.c_str(), std::ios::in | std::ios::binary );
+    if(!bFile.is_open()) {
+        throw VideoException("Unable to open " + full_path);
+    }
+
+    offsets = GetMJpegOffsets(bFile);
+
+    next_image = LoadImage(bFile, ImageFileType::ImageFileTypeJpg);
+    if(!next_image.IsValid()) {
+        throw VideoException("Unable to load first jpeg in mjpeg stream");
+    }
+
+    streams.emplace_back(next_image.fmt, next_image.w, next_image.h, next_image.pitch, nullptr);
+    size_bytes = next_image.SizeBytes();
+}
+
+MjpegVideo::~MjpegVideo()
+{
+
+}
+
+//! Implement VideoInput::Start()
+void MjpegVideo::Start()
+{
+
+}
+
+//! Implement VideoInput::Stop()
+void MjpegVideo::Stop()
+{
+
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t MjpegVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& MjpegVideo::Streams() const
+{
+    return streams;
+}
+
+bool MjpegVideo::LoadNext()
+{
+    if(!next_image.IsValid() && bFile.good()) {
+        try {
+            next_image = LoadImage(bFile, ImageFileType::ImageFileTypeJpg);
+        }  catch (const std::runtime_error&) {
+            return false;
+        }
+    }
+    return next_image.IsValid();
+}
+
+//! Implement VideoInput::GrabNext()
+bool MjpegVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if( LoadNext() ) {
+        memcpy(image, next_image.ptr, size_bytes);
+        next_image.Deallocate();
+        ++next_frame_id;
+        return true;
+    }
+    return false;
+}
+
+//! Implement VideoInput::GrabNewest()
+bool MjpegVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image, wait);
+}
+
+size_t MjpegVideo::GetCurrentFrameId() const
+{
+    return next_frame_id - 1;
+}
+
+size_t MjpegVideo::GetTotalFrames() const
+{
+    return offsets.size();
+}
+
+size_t MjpegVideo::Seek(size_t frameid)
+{
+    if(frameid != next_frame_id) {
+        // Clamp to within range
+        next_frame_id = std::min(frameid, offsets.size()-1);
+        // Clear any eof markers etc
+        bFile.clear();
+        bFile.seekg(offsets[next_frame_id]);
+        // Remove any cached image data
+        next_image.Deallocate();
+    }else{
+        // Do nothing
+    }
+    return next_frame_id;
+}
+
+
+PANGOLIN_REGISTER_FACTORY(MjpegVideo)
+{
+    struct MjpegVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"mjpeg",0}};
+        }
+        const char* Description() const override
+        {
+            return "Load Motion Jpeg video streams";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            return std::unique_ptr<VideoInterface>(new MjpegVideo(uri.url));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<MjpegVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/openni.cpp

@@ -0,0 +1,315 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/openni.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace pangolin
+{
+
+OpenNiVideo::OpenNiVideo(OpenNiSensorType s1, OpenNiSensorType s2, ImageDim dim, int fps)
+{
+    sensor_type[0] = s1;
+    sensor_type[1] = s2;
+
+    XnStatus nRetVal = XN_STATUS_OK;
+    nRetVal = context.Init();
+    if (nRetVal != XN_STATUS_OK) {
+        std::cerr << "context.Init: " << xnGetStatusString(nRetVal) << std::endl;
+    }
+
+    XnMapOutputMode mapMode;
+    mapMode.nXRes = dim.x;
+    mapMode.nYRes = dim.y;
+    mapMode.nFPS = fps;
+
+    sizeBytes = 0;
+
+    bool use_depth = false;
+    bool use_ir = false;
+    bool use_rgb = false;
+    bool depth_to_color = false;
+
+    for(int i=0; i<2; ++i) {
+        PixelFormat fmt;
+
+        // Establish output pixel format for sensor streams
+        switch( sensor_type[i] ) {
+        case OpenNiDepth_1mm_Registered:
+        case OpenNiDepth_1mm:
+        case OpenNiIr:
+        case OpenNiIrProj:
+            fmt = PixelFormatFromString("GRAY16LE");
+            break;
+        case OpenNiIr8bit:
+        case OpenNiIr8bitProj:
+            fmt = PixelFormatFromString("GRAY8");
+            break;
+        case OpenNiRgb:
+            fmt = PixelFormatFromString("RGB24");
+            break;
+        default:
+            continue;
+        }
+
+        switch( sensor_type[i] ) {
+        case OpenNiDepth_1mm_Registered:
+            depth_to_color = true;
+            use_depth = true;
+            break;
+        case OpenNiDepth_1mm:
+            use_depth = true;
+            break;
+        case OpenNiIr:
+        case OpenNiIr8bit:
+            use_ir = true;
+            break;
+        case OpenNiIrProj:
+        case OpenNiIr8bitProj:
+            use_ir = true;
+            use_depth = true;
+            break;
+        case OpenNiRgb:
+            use_rgb = true;
+            break;
+        default:
+            break;
+        }
+
+        const StreamInfo stream(fmt, mapMode.nXRes, mapMode.nYRes, (mapMode.nXRes * fmt.bpp) / 8, (unsigned char*)0 + sizeBytes);
+        sizeBytes += stream.SizeBytes();
+        streams.push_back(stream);
+    }
+
+    if( use_depth ) {
+        nRetVal = depthNode.Create(context);
+        if (nRetVal != XN_STATUS_OK) {
+            throw VideoException( (std::string)"Unable to create DepthNode: " + xnGetStatusString(nRetVal) );
+        }else{
+            nRetVal = depthNode.SetMapOutputMode(mapMode);
+            if (nRetVal != XN_STATUS_OK) {
+                throw VideoException( (std::string)"Invalid DepthNode mode: " + xnGetStatusString(nRetVal) );
+            }
+        }
+    }
+
+    if( use_rgb ) {
+        nRetVal = imageNode.Create(context);
+        if (nRetVal != XN_STATUS_OK) {
+            throw VideoException( (std::string)"Unable to create ImageNode: " + xnGetStatusString(nRetVal) );
+        }else{
+            nRetVal = imageNode.SetMapOutputMode(mapMode);
+            if (nRetVal != XN_STATUS_OK) {
+                throw VideoException( (std::string)"Invalid ImageNode mode: " + xnGetStatusString(nRetVal) );
+            }
+        }
+    }
+
+    if (depth_to_color && use_rgb) {
+        //Registration
+        if( depthNode.IsCapabilitySupported(XN_CAPABILITY_ALTERNATIVE_VIEW_POINT) ) {
+            nRetVal = depthNode.GetAlternativeViewPointCap().SetViewPoint( imageNode  );
+            if (nRetVal != XN_STATUS_OK) {
+                std::cerr << "depthNode.GetAlternativeViewPointCap().SetViewPoint(imageNode): " << xnGetStatusString(nRetVal) << std::endl;
+            }
+        }
+
+        // Frame Sync
+        if (depthNode.IsCapabilitySupported(XN_CAPABILITY_FRAME_SYNC))
+        {
+            if (depthNode.GetFrameSyncCap().CanFrameSyncWith(imageNode))
+            {
+                nRetVal = depthNode.GetFrameSyncCap().FrameSyncWith(imageNode);
+                if (nRetVal != XN_STATUS_OK) {
+                    std::cerr << "depthNode.GetFrameSyncCap().FrameSyncWith(imageNode): " << xnGetStatusString(nRetVal) << std::endl;
+                }
+            }
+        }
+    }
+
+    if( use_ir ) {
+        nRetVal = irNode.Create(context);
+        if (nRetVal != XN_STATUS_OK) {
+            throw VideoException( (std::string)"Unable to create IrNode: " + xnGetStatusString(nRetVal) );
+        }else{
+            nRetVal = irNode.SetMapOutputMode(mapMode);
+            if (nRetVal != XN_STATUS_OK) {
+                throw VideoException( (std::string)"Invalid IrNode mode: " + xnGetStatusString(nRetVal) );
+            }
+        }
+    }
+
+    Start();
+}
+
+OpenNiVideo::~OpenNiVideo()
+{
+    context.Release();
+}
+
+size_t OpenNiVideo::SizeBytes() const
+{
+    return sizeBytes;
+}
+
+const std::vector<StreamInfo>& OpenNiVideo::Streams() const
+{
+    return streams;
+}
+
+void OpenNiVideo::Start()
+{
+    //    XnStatus nRetVal =
+    context.StartGeneratingAll();
+}
+
+void OpenNiVideo::Stop()
+{
+    context.StopGeneratingAll();
+}
+
+bool OpenNiVideo::GrabNext( unsigned char* image, bool /*wait*/ )
+{
+    //    XnStatus nRetVal = context.WaitAndUpdateAll();
+    XnStatus nRetVal = context.WaitAnyUpdateAll();
+    //    nRetVal = context.WaitOneUpdateAll(imageNode);
+
+    if (nRetVal != XN_STATUS_OK) {
+        std::cerr << "Failed updating data: " << xnGetStatusString(nRetVal) << std::endl;
+        return false;
+    }else{
+        unsigned char* out_img = image;
+
+        for(int i=0; i<2; ++i) {
+            switch (sensor_type[i]) {
+            case OpenNiDepth_1mm:
+            case OpenNiDepth_1mm_Registered:
+            {
+                const XnDepthPixel* pDepthMap = depthNode.GetDepthMap();
+                memcpy(out_img,pDepthMap, streams[i].SizeBytes() );
+                break;
+            }
+            case OpenNiIr:
+            case OpenNiIrProj:
+            {
+                const XnIRPixel* pIrMap = irNode.GetIRMap();
+                memcpy(out_img, pIrMap, streams[i].SizeBytes() );
+                break;
+            }
+            case OpenNiIr8bit:
+            case OpenNiIr8bitProj:
+            {
+                const XnIRPixel* pIr16Map = irNode.GetIRMap();
+
+                // rescale from 16-bit (10 effective) to 8-bit
+                xn::IRMetaData meta_data;
+                irNode.GetMetaData(meta_data);
+                int w = meta_data.XRes();
+                int h = meta_data.YRes();
+
+                // Copy to out_img with conversion
+                XnUInt8* pIrMapScaled = (XnUInt8*)out_img;
+                for (int v = 0; v < h; ++v)
+                for (int u = 0; u < w; ++u) {
+                    int val = *pIr16Map >> 2; // 10bit to 8 bit
+                    pIrMapScaled[w * v + u] = val;
+                    pIr16Map++;
+                }
+
+                break;
+            }
+            case OpenNiRgb:
+            {
+                const XnUInt8* pImageMap = imageNode.GetImageMap();
+                memcpy(out_img,pImageMap, streams[i].SizeBytes());
+                break;
+            }
+            default:
+                continue;
+                break;
+            }
+
+            out_img += streams[i].SizeBytes();
+        }
+
+        return true;
+    }
+}
+
+bool OpenNiVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image,wait);
+}
+
+PANGOLIN_REGISTER_FACTORY(OpenNiVideo)
+{
+    struct OpenNiVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"openni1",10}, {"openni",100}, {"oni",100}};
+        }
+        const char* Description() const override
+        {
+            return "OpenNI v1 Driver to access Kinect / Primesense devices.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","30","Frames per second"},
+                {"autoexposure","1","enable (1) or disable (0) RGB autoexposure"},
+                {"img1","depth","Camera stream to use for stream 1 {depth,rgb,ir}"},
+                {"img2","","Camera stream to use for stream 2 {depth,rgb,ir}"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const unsigned int fps = uri.Get<unsigned int>("fps", 30);
+            const bool autoexposure = uri.Get<bool>("autoexposure", true);
+
+            OpenNiSensorType img1 = OpenNiRgb;
+            OpenNiSensorType img2 = OpenNiUnassigned;
+
+            if( uri.Contains("img1") ){
+                img1 = openni_sensor(uri.Get<std::string>("img1", "depth"));
+            }
+
+            if( uri.Contains("img2") ){
+                img2 = openni_sensor(uri.Get<std::string>("img2","rgb"));
+            }
+
+            OpenNiVideo* oniv = new OpenNiVideo(img1, img2, dim, fps);
+            oniv->SetAutoExposure(autoexposure);
+            return std::unique_ptr<VideoInterface>(oniv);
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>( std::make_shared<OpenNiVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/openni2.cpp

@@ -0,0 +1,715 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Richard Newcombe
+ *               2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/drivers/openni2.h>
+
+#include <OniVersion.h>
+#include <PS1080.h>
+
+// OpenNI must be including a horrid windows header
+// which defines these nasty macros.
+#undef max
+#undef min
+
+namespace pangolin
+{
+
+PixelFormat VideoFormatFromOpenNI2(openni::PixelFormat fmt)
+{
+    std::string pvfmt;
+
+    switch (fmt) {
+    case openni::PIXEL_FORMAT_DEPTH_1_MM:   pvfmt = "GRAY16LE"; break;
+    case openni::PIXEL_FORMAT_DEPTH_100_UM: pvfmt = "GRAY16LE"; break;
+    case openni::PIXEL_FORMAT_SHIFT_9_2:    pvfmt = "GRAY16LE"; break; // ?
+    case openni::PIXEL_FORMAT_SHIFT_9_3:    pvfmt = "GRAY16LE"; break; // ?
+    case openni::PIXEL_FORMAT_RGB888:       pvfmt = "RGB24"; break;
+    case openni::PIXEL_FORMAT_GRAY8:        pvfmt = "GRAY8"; break;
+    case openni::PIXEL_FORMAT_GRAY16:       pvfmt = "GRAY16LE"; break;
+    case openni::PIXEL_FORMAT_YUV422:       pvfmt = "YUYV422"; break;
+#if ONI_VERSION_MAJOR >= 2 && ONI_VERSION_MINOR >= 2
+    case openni::PIXEL_FORMAT_YUYV:         pvfmt = "Y400A"; break;
+#endif
+    default:
+        throw VideoException("Unknown OpenNI pixel format");
+        break;
+    }
+
+    return PixelFormatFromString(pvfmt);
+}
+
+void OpenNi2Video::PrintOpenNI2Modes(openni::SensorType sensorType)
+{
+    // Query supported modes for device
+    const openni::Array<openni::VideoMode>& modes =
+            devices[0].getSensorInfo(sensorType)->getSupportedVideoModes();
+
+    switch (sensorType) {
+    case openni::SENSOR_COLOR: pango_print_info("OpenNI Colour Modes:\n"); break;
+    case openni::SENSOR_DEPTH: pango_print_info("OpenNI Depth Modes:\n"); break;
+    case openni::SENSOR_IR:    pango_print_info("OpenNI IR Modes:\n"); break;
+    }
+
+    for(int i = 0; i < modes.getSize(); i++) {
+        std::string sfmt = "PangolinUnknown";
+        try{
+            sfmt = VideoFormatFromOpenNI2(modes[i].getPixelFormat()).format;
+        }catch(const VideoException&){}
+        pango_print_info( "  %dx%d, %d fps, %s\n",
+            modes[i].getResolutionX(), modes[i].getResolutionY(),
+            modes[i].getFps(), sfmt.c_str()
+        );
+    }
+}
+
+openni::VideoMode OpenNi2Video::FindOpenNI2Mode(
+    openni::Device & device,
+    openni::SensorType sensorType,
+    int width, int height,
+    int fps, openni::PixelFormat fmt
+) {
+    // Query supported modes for device
+    const openni::Array<openni::VideoMode>& modes =
+            device.getSensorInfo(sensorType)->getSupportedVideoModes();
+
+    // Select last listed mode which matches parameters
+    int best_mode = -1;
+    for(int i = 0; i < modes.getSize(); i++) {
+        if( (!width || modes[i].getResolutionX() == width) &&
+            (!height || modes[i].getResolutionY() == height) &&
+            (!fps || modes[i].getFps() == fps) &&
+            (!fmt || modes[i].getPixelFormat() == fmt)
+        ) {
+            best_mode = i;
+        }
+    }
+
+    if(best_mode >= 0) {
+        return modes[best_mode];
+    }
+
+    throw pangolin::VideoException("Video mode not supported");
+}
+
+inline openni::SensorType SensorType(const OpenNiSensorType sensor)
+{
+    switch (sensor) {
+    case OpenNiRgb:
+    case OpenNiGrey:
+        return openni::SENSOR_COLOR;
+    case OpenNiDepth_1mm:
+    case OpenNiDepth_100um:
+    case OpenNiDepth_1mm_Registered:
+        return openni::SENSOR_DEPTH;
+    case OpenNiIr:
+    case OpenNiIr8bit:
+    case OpenNiIr24bit:
+    case OpenNiIrProj:
+    case OpenNiIr8bitProj:
+        return openni::SENSOR_IR;
+    default:
+        throw std::invalid_argument("OpenNI: Bad sensor type");
+    }
+}
+
+OpenNi2Video::OpenNi2Video(ImageDim dim, ImageRoi roi, int fps)
+{
+    InitialiseOpenNI();
+
+    openni::Array<openni::DeviceInfo> deviceList;
+    openni::OpenNI::enumerateDevices(&deviceList);
+
+    if (deviceList.getSize() < 1) {
+        throw VideoException("No OpenNI Devices available. Ensure your camera is plugged in.");
+    }
+
+    for(int i = 0 ; i < deviceList.getSize(); i ++) {
+        const char*  device_uri = deviceList[i].getUri();
+        const int dev_id = AddDevice(device_uri);
+        AddStream(OpenNiStreamMode( OpenNiDepth_1mm, dim, roi, fps, dev_id) );
+        AddStream(OpenNiStreamMode( OpenNiRgb, dim, roi, fps, dev_id) );
+    }
+
+    SetupStreamModes();
+}
+
+OpenNi2Video::OpenNi2Video(const std::string& device_uri)
+{
+    InitialiseOpenNI();
+
+    const int dev_id = AddDevice(device_uri);
+    AddStream(OpenNiStreamMode( OpenNiDepth_1mm, ImageDim(), ImageRoi(), 30, dev_id) );
+    AddStream(OpenNiStreamMode( OpenNiRgb,   ImageDim(), ImageRoi(), 30, dev_id) );
+
+    SetupStreamModes();
+}
+
+OpenNi2Video::OpenNi2Video(const std::string& device_uri, std::vector<OpenNiStreamMode> &stream_modes)
+{
+    InitialiseOpenNI();
+
+    AddDevice(device_uri);
+
+    for(size_t i=0; i < stream_modes.size(); ++i) {
+        OpenNiStreamMode& mode = stream_modes[i];
+        AddStream(mode);
+    }
+
+    SetupStreamModes();
+}
+
+OpenNi2Video::OpenNi2Video(std::vector<OpenNiStreamMode>& stream_modes)
+{
+    InitialiseOpenNI();
+
+    openni::Array<openni::DeviceInfo> deviceList;
+    openni::OpenNI::enumerateDevices(&deviceList);
+
+    if (deviceList.getSize() < 1) {
+        throw VideoException("OpenNI2: No devices available. Ensure your camera is plugged in.");
+    }
+
+    for(int i = 0 ; i < deviceList.getSize(); i ++) {
+        const char*  device_uri = deviceList[i].getUri();
+        AddDevice(device_uri);
+    }
+
+    for(size_t i=0; i < stream_modes.size(); ++i) {
+        OpenNiStreamMode& mode = stream_modes[i];
+        AddStream(mode);
+    }
+
+    SetupStreamModes();
+}
+
+void OpenNi2Video::InitialiseOpenNI()
+{
+    // Initialise member variables
+    numDevices = 0;
+    numStreams = 0;
+    current_frame_index = 0;
+    total_frames = std::numeric_limits<size_t>::max();
+
+    openni::Status rc = openni::STATUS_OK;
+
+    rc = openni::OpenNI::initialize();
+    if (rc != openni::STATUS_OK) {
+        throw VideoException( "Unable to initialise OpenNI library", openni::OpenNI::getExtendedError() );
+    }
+}
+
+int OpenNi2Video::AddDevice(const std::string& device_uri)
+{
+    const size_t dev_id = numDevices;
+    openni::Status rc = devices[dev_id].open(device_uri.c_str());
+    if (rc != openni::STATUS_OK) {
+        throw VideoException( "OpenNI2: Couldn't open device.", openni::OpenNI::getExtendedError() );
+    }
+    ++numDevices;
+    return dev_id;
+}
+
+void OpenNi2Video::AddStream(const OpenNiStreamMode& mode)
+{
+    sensor_type[numStreams] = mode;
+    openni::Device& device = devices[mode.device];
+    openni::VideoStream& stream = video_stream[numStreams];
+    openni::Status rc = stream.create(device, SensorType(mode.sensor_type));
+    if (rc != openni::STATUS_OK) {
+        throw VideoException( "OpenNI2: Couldn't create stream.", openni::OpenNI::getExtendedError() );
+    }
+
+    openni::PlaybackControl* control = device.getPlaybackControl();
+    if(control && numStreams==0) {
+        total_frames = std::min(total_frames, (size_t)control->getNumberOfFrames(stream));
+    }
+
+    numStreams++;
+}
+
+void OpenNi2Video::SetupStreamModes()
+{
+    streams_properties = &frame_properties["streams"];
+    *streams_properties = picojson::value(picojson::array_type,false);
+    streams_properties->get<picojson::array>().resize(numStreams);
+
+    use_depth = false;
+    use_ir = false;
+    use_rgb = false;
+    depth_to_color = false;
+    use_ir_and_rgb = false;
+
+    sizeBytes =0;
+    for(size_t i=0; i<numStreams; ++i) {
+        const OpenNiStreamMode& mode = sensor_type[i];
+        openni::SensorType nisensortype;
+        openni::PixelFormat nipixelfmt;
+
+        switch( mode.sensor_type ) {
+        case OpenNiDepth_1mm_Registered:
+            depth_to_color = true;
+            nisensortype = openni::SENSOR_DEPTH;
+            nipixelfmt = openni::PIXEL_FORMAT_DEPTH_1_MM;
+            use_depth = true;
+            break;
+        case OpenNiDepth_1mm:
+            nisensortype = openni::SENSOR_DEPTH;
+            nipixelfmt = openni::PIXEL_FORMAT_DEPTH_1_MM;
+            use_depth = true;
+            break;
+        case OpenNiDepth_100um:
+            nisensortype = openni::SENSOR_DEPTH;
+            nipixelfmt = openni::PIXEL_FORMAT_DEPTH_100_UM;
+            use_depth = true;
+            break;
+        case OpenNiIrProj:
+        case OpenNiIr:
+            nisensortype = openni::SENSOR_IR;
+            nipixelfmt = openni::PIXEL_FORMAT_GRAY16;
+            use_ir = true;
+            break;
+        case OpenNiIr24bit:
+            nisensortype = openni::SENSOR_IR;
+            nipixelfmt = openni::PIXEL_FORMAT_RGB888;
+            use_ir = true;
+            break;
+        case OpenNiIr8bitProj:
+        case OpenNiIr8bit:
+            nisensortype = openni::SENSOR_IR;
+            nipixelfmt = openni::PIXEL_FORMAT_GRAY8;
+            use_ir = true;
+            break;
+        case OpenNiRgb:
+            nisensortype = openni::SENSOR_COLOR;
+            nipixelfmt = openni::PIXEL_FORMAT_RGB888;
+            use_rgb = true;
+            break;
+        case OpenNiGrey:
+            nisensortype = openni::SENSOR_COLOR;
+            nipixelfmt = openni::PIXEL_FORMAT_GRAY8;
+            use_rgb = true;
+            break;
+        case OpenNiUnassigned:
+        default:
+            continue;
+        }
+
+        openni::VideoMode onivmode;
+        try {
+            onivmode = FindOpenNI2Mode(devices[mode.device], nisensortype, mode.dim.x, mode.dim.y, mode.fps, nipixelfmt);
+        }catch(const VideoException& e) {
+            pango_print_error("Unable to find compatible OpenNI Video Mode. Please choose from:\n");
+            PrintOpenNI2Modes(nisensortype);
+            fflush(stdout);
+            throw e;
+        }
+
+        openni::Status rc;
+        if(!devices[mode.device].isFile()){//trying to setVideoMode on a file results in an OpenNI error
+            rc = video_stream[i].setVideoMode(onivmode);
+            if(rc != openni::STATUS_OK)
+                throw VideoException("Couldn't set OpenNI VideoMode", openni::OpenNI::getExtendedError());
+        }
+
+        int outputWidth = onivmode.getResolutionX();
+        int outputHeight = onivmode.getResolutionY();
+
+        if (mode.roi.w && mode.roi.h) {
+            rc = video_stream[i].setCropping(mode.roi.x,mode.roi.y,mode.roi.w,mode.roi.h);
+            if(rc != openni::STATUS_OK)
+                throw VideoException("Couldn't set OpenNI cropping", openni::OpenNI::getExtendedError());
+
+            outputWidth = mode.roi.w;
+            outputHeight = mode.roi.h;
+        }
+
+        const PixelFormat fmt = VideoFormatFromOpenNI2(nipixelfmt);
+        const StreamInfo stream(
+            fmt, outputWidth, outputHeight,
+            (outputWidth * fmt.bpp) / 8,
+            (unsigned char*)0 + sizeBytes
+        );
+
+        sizeBytes += stream.SizeBytes();
+        streams.push_back(stream);
+    }
+
+    SetRegisterDepthToImage(depth_to_color);
+
+    use_ir_and_rgb = use_rgb && use_ir;
+}
+
+void OpenNi2Video::UpdateProperties()
+{
+    picojson::value& jsopenni = device_properties["openni"];
+
+    picojson::value& jsdevices = jsopenni["devices"];
+    jsdevices = picojson::value(picojson::array_type,false);
+    jsdevices.get<picojson::array>().resize(numDevices);
+    for (size_t i=0; i<numDevices; ++i) {
+      picojson::value& jsdevice = jsdevices[i];
+#define SET_PARAM(param_type, param) \
+      { \
+        param_type val; \
+        if(devices[i].getProperty(param, &val) == openni::STATUS_OK) { \
+          jsdevice[#param] = val; \
+        } \
+      }
+      SET_PARAM( unsigned long long, XN_MODULE_PROPERTY_USB_INTERFACE );
+      SET_PARAM( bool,  XN_MODULE_PROPERTY_MIRROR );
+      char serialNumber[1024];
+      devices[i].getProperty(ONI_DEVICE_PROPERTY_SERIAL_NUMBER, &serialNumber);
+      jsdevice["ONI_DEVICE_PROPERTY_SERIAL_NUMBER"] = std::string(serialNumber);
+#undef SET_PARAM
+    }
+
+    picojson::value& stream = jsopenni["streams"];
+    stream = picojson::value(picojson::array_type,false);
+    stream.get<picojson::array>().resize(Streams().size());
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        if(sensor_type[i].sensor_type != OpenNiUnassigned)
+        {
+#define SET_PARAM(param_type, param) \
+            {\
+                param_type val; \
+                if(video_stream[i].getProperty(param, &val) == openni::STATUS_OK) { \
+                    jsstream[#param] = val; \
+                } \
+            }
+
+            picojson::value& jsstream = stream[i];
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_INPUT_FORMAT );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_CROPPING_MODE );
+
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_CLOSE_RANGE );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_WHITE_BALANCE_ENABLED );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_GAIN );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_HOLE_FILTER );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_REGISTRATION_TYPE );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_CONST_SHIFT );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_PIXEL_SIZE_FACTOR );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_MAX_SHIFT );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_PARAM_COEFF );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_SHIFT_SCALE );
+            SET_PARAM( unsigned long long, XN_STREAM_PROPERTY_ZERO_PLANE_DISTANCE );
+            SET_PARAM( double, XN_STREAM_PROPERTY_ZERO_PLANE_PIXEL_SIZE );
+            SET_PARAM( double, XN_STREAM_PROPERTY_EMITTER_DCMOS_DISTANCE );
+            SET_PARAM( double, XN_STREAM_PROPERTY_DCMOS_RCMOS_DISTANCE );
+#undef SET_PARAM
+        }
+    }
+}
+
+void OpenNi2Video::SetMirroring(bool enable)
+{
+    // Set this property on all streams. It doesn't matter if it fails.
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        video_stream[i].setMirroringEnabled(enable);
+    }
+}
+
+void OpenNi2Video::SetAutoExposure(bool enable)
+{
+    // Set this property on all streams exposing CameraSettings
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        openni::CameraSettings* cam = video_stream[i].getCameraSettings();
+        if(cam) cam->setAutoExposureEnabled(enable);
+    }
+}
+
+void OpenNi2Video::SetAutoWhiteBalance(bool enable)
+{
+    // Set this property on all streams exposing CameraSettings
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        openni::CameraSettings* cam = video_stream[i].getCameraSettings();
+        if(cam) cam->setAutoWhiteBalanceEnabled(enable);
+    }
+}
+
+void OpenNi2Video::SetDepthCloseRange(bool enable)
+{
+    // Set this property on all streams. It doesn't matter if it fails.
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        video_stream[i].setProperty(XN_STREAM_PROPERTY_CLOSE_RANGE, enable);
+    }
+}
+
+void OpenNi2Video::SetDepthHoleFilter(bool enable)
+{
+    // Set this property on all streams. It doesn't matter if it fails.
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        video_stream[i].setProperty(XN_STREAM_PROPERTY_HOLE_FILTER, enable);
+        video_stream[i].setProperty(XN_STREAM_PROPERTY_GAIN,50);
+    }
+}
+
+void OpenNi2Video::SetDepthColorSyncEnabled(bool enable)
+{
+    for(size_t i = 0 ; i < numDevices; i++) {
+        devices[i].setDepthColorSyncEnabled(enable);
+    }
+}
+
+void OpenNi2Video::SetFastCrop(bool enable)
+{
+    const uint32_t pango_XN_STREAM_PROPERTY_FAST_ZOOM_CROP = 0x1080F009;
+    for (unsigned int i = 0; i < Streams().size(); ++i) {
+        video_stream[i].setProperty(pango_XN_STREAM_PROPERTY_FAST_ZOOM_CROP, enable);
+        video_stream[i].setProperty(XN_STREAM_PROPERTY_CROPPING_MODE, enable ? XN_CROPPING_MODE_INCREASED_FPS : XN_CROPPING_MODE_NORMAL);
+    }
+}
+
+void OpenNi2Video::SetRegisterDepthToImage(bool enable)
+{
+    if(enable) {
+        for(size_t i = 0 ; i < numDevices; i++) {
+            devices[i].setImageRegistrationMode(openni::IMAGE_REGISTRATION_DEPTH_TO_COLOR);
+        }
+    }else{
+        for(size_t i = 0 ; i < numDevices ; i++) {
+            devices[i].setImageRegistrationMode(openni::IMAGE_REGISTRATION_OFF);
+        }
+    }
+}
+
+void OpenNi2Video::SetPlaybackSpeed(float speed)
+{
+    for(size_t i = 0 ; i < numDevices; i++) {
+        openni::PlaybackControl* control = devices[i].getPlaybackControl();
+        if(control) control->setSpeed(speed);
+    }
+}
+
+void OpenNi2Video::SetPlaybackRepeat(bool enabled)
+{
+    for(size_t i = 0 ; i < numDevices; i++) {
+        openni::PlaybackControl* control = devices[i].getPlaybackControl();
+        if(control) control->setRepeatEnabled(enabled);
+    }
+}
+
+OpenNi2Video::~OpenNi2Video()
+{
+    Stop();
+
+    for(size_t i=0; i<numStreams; ++i) {
+        if( video_stream[i].isValid()) {
+            video_stream[i].destroy();
+        }
+    }
+
+    openni::OpenNI::shutdown();
+}
+
+size_t OpenNi2Video::SizeBytes() const
+{
+    return sizeBytes;
+}
+
+const std::vector<StreamInfo>& OpenNi2Video::Streams() const
+{
+    return streams;
+}
+
+void OpenNi2Video::Start()
+{
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        video_stream[i].start();
+    }
+}
+
+void OpenNi2Video::Stop()
+{
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        video_stream[i].stop();
+    }
+}
+
+openni::VideoStream * OpenNi2Video::GetVideoStream(int stream){
+    if(video_stream[stream].isValid()) {
+        return &video_stream[stream];
+    }else{
+        pango_print_error("Error getting stream: %d \n%s",stream,  openni::OpenNI::getExtendedError() );
+        return NULL;
+    }
+}
+
+bool OpenNi2Video::GrabNext( unsigned char* image, bool /*wait*/ )
+{
+    unsigned char* out_img = image;
+
+    openni::Status rc = openni::STATUS_OK;
+
+    for(unsigned int i=0; i<Streams().size(); ++i) {
+        if(sensor_type[i].sensor_type == OpenNiUnassigned) {
+            rc = openni::STATUS_OK;
+            continue;
+        }
+
+        if(!video_stream[i].isValid()) {
+            rc = openni::STATUS_NO_DEVICE;
+            continue;
+        }
+
+        if(use_ir_and_rgb) video_stream[i].start();
+
+        rc = video_stream[i].readFrame(&video_frame[i]);
+        video_frame[0].getFrameIndex();
+        if(rc != openni::STATUS_OK) {
+            pango_print_error("Error reading frame:\n%s", openni::OpenNI::getExtendedError() );
+        }
+
+        const bool toGreyscale = false;
+        if(toGreyscale) {
+            const int w = streams[i].Width();
+            const int h = streams[i].Height();
+
+            openni::RGB888Pixel* pColour = (openni::RGB888Pixel*)video_frame[i].getData();
+            for(int i = 0 ; i  < w*h;i++){
+                openni::RGB888Pixel rgb = pColour[i];
+                int grey = ((int)(rgb.r&0xFF) +  (int)(rgb.g&0xFF) + (int)(rgb.b&0xFF))/3;
+                grey = std::min(255,std::max(0,grey));
+                out_img[i] = grey;
+            }
+        }else{
+            memcpy(out_img, video_frame[i].getData(), streams[i].SizeBytes());
+        }
+
+        // update frame properties
+        (*streams_properties)[i]["devtime_us"] = video_frame[i].getTimestamp();
+
+        if(use_ir_and_rgb) video_stream[i].stop();
+
+        out_img += streams[i].SizeBytes();
+    }
+
+    current_frame_index = video_frame[0].getFrameIndex();
+
+    return rc == openni::STATUS_OK;
+}
+
+bool OpenNi2Video::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image,wait);
+}
+
+size_t OpenNi2Video::GetCurrentFrameId() const
+{
+    return current_frame_index;
+}
+
+size_t OpenNi2Video::GetTotalFrames() const
+{
+    return total_frames;
+}
+
+size_t OpenNi2Video::Seek(size_t frameid)
+{
+    openni::PlaybackControl* control = devices[0].getPlaybackControl();
+    if(control) {
+        control->seek(video_stream[0], frameid);
+        return frameid;
+    }else{
+        return -1;
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(OpenNi2Video)
+{
+    struct OpenNI2VideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"openni2",10}, {"openni",10}, {"oni",10}};
+        }
+        const char* Description() const override
+        {
+            return "OpenNI v2 Driver to access Kinect / Primesense devices.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","30","Framerate"},
+                {"roi","0+0+0x0","Region of interest"},
+                {"realtime","","If playback rate should be slowed to real-time speed."},
+                {"img\\d+", "","Device stream for nth image. Choose from [gray,rgb,ir,depth1mm,depth100um,depth_reg,ir8,ir24,ir+,ir8+]"},
+                {"closerange","false","Use close-range mode (lower projector intensity)"},
+                {"holefilter","false","Enable hole filter"},
+                {"fastcrop","false","?"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const bool realtime = uri.Contains("realtime");
+            const ImageDim default_dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const ImageRoi default_roi = uri.Get<ImageRoi>("roi", ImageRoi(0,0,0,0));
+            const unsigned int default_fps = uri.Get<unsigned int>("fps", 30);
+
+            std::vector<OpenNiStreamMode> stream_modes;
+
+            int num_streams = 0;
+            std::string simg= "img1";
+            while(uri.Contains(simg)) {
+                OpenNiStreamMode stream = uri.Get<OpenNiStreamMode>(simg, OpenNiStreamMode(OpenNiRgb,default_dim,default_roi,default_fps,0));
+                stream_modes.push_back(stream);
+                ++num_streams;
+                simg = "img" + ToString(num_streams+1);
+            }
+
+            OpenNi2Video* nivid;
+            if(!uri.url.empty()) {
+                nivid = new OpenNi2Video(pangolin::PathExpand(uri.url));
+            }else if(stream_modes.size()) {
+                nivid = new OpenNi2Video(stream_modes);
+            }else{
+                nivid = new OpenNi2Video(default_dim, default_roi, default_fps);
+            }
+
+            nivid->SetDepthCloseRange( uri.Get<bool>("closerange",false) );
+            nivid->SetDepthHoleFilter( uri.Get<bool>("holefilter",false) );
+            nivid->SetDepthColorSyncEnabled( uri.Get<bool>("coloursync",false) );
+            nivid->SetFastCrop( uri.Get<bool>("fastcrop",false) );
+            nivid->SetPlaybackSpeed(realtime ? 1.0f : -1.0f);
+            nivid->SetAutoExposure(true);
+            nivid->SetAutoWhiteBalance(true);
+            nivid->SetMirroring(false);
+
+            nivid->UpdateProperties();
+
+            nivid->Start();
+
+            return std::unique_ptr<VideoInterface>(nivid);
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(
+        std::make_shared<OpenNI2VideoFactory>()
+    );
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/pack.cpp

@@ -0,0 +1,277 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/pack.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+#ifdef DEBUGUNPACK
+  #include <pangolin/utils/timer.h>
+  #define TSTART() pangolin::basetime start,last,now; start = pangolin::TimeNow(); last = start;
+  #define TGRABANDPRINT(...)  now = pangolin::TimeNow(); fprintf(stderr,"UNPACK: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr, " %fms.\n",1000*pangolin::TimeDiff_s(last, now)); last = now;
+  #define DBGPRINT(...) fprintf(stderr,"UNPACK: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr,"\n");
+#else
+  #define TSTART()
+  #define TGRABANDPRINT(...)
+  #define DBGPRINT(...)
+#endif
+
+namespace pangolin
+{
+
+PackVideo::PackVideo(std::unique_ptr<VideoInterface> &src_, PixelFormat out_fmt)
+    : src(std::move(src_)), size_bytes(0), buffer(0)
+{
+    if( !src || out_fmt.channels != 1) {
+        throw VideoException("PackVideo: Only supports single channel input.");
+    }
+
+    videoin.push_back(src.get());
+
+    for(size_t s=0; s< src->Streams().size(); ++s) {
+        const size_t w = src->Streams()[s].Width();
+        const size_t h = src->Streams()[s].Height();
+
+        // Check compatibility of formats
+        const PixelFormat in_fmt = src->Streams()[s].PixFormat();
+        if(in_fmt.channels > 1 || in_fmt.bpp > 16) {
+            throw VideoException("PackVideo: Only supports one channel input.");
+        }
+
+        // round up to ensure enough bytes for packing
+        const size_t pitch = (w*out_fmt.bpp)/ 8 + ((w*out_fmt.bpp) % 8 > 0? 1 : 0);
+        streams.push_back(pangolin::StreamInfo( out_fmt, w, h, pitch, reinterpret_cast<uint8_t*>(size_bytes) ));
+        size_bytes += h*pitch;
+    }
+
+    buffer = new unsigned char[src->SizeBytes()];
+}
+
+PackVideo::~PackVideo()
+{
+    delete[] buffer;
+}
+
+//! Implement VideoInput::Start()
+void PackVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+//! Implement VideoInput::Stop()
+void PackVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t PackVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& PackVideo::Streams() const
+{
+    return streams;
+}
+
+template<typename T>
+void ConvertTo8bit(
+    Image<unsigned char>& out,
+    const Image<unsigned char>& in
+) {
+    for(size_t r=0; r<out.h; ++r) {
+        T* pout = (T*)(out.ptr + r*out.pitch);
+        uint8_t* pin = in.ptr + r*in.pitch;
+        const uint8_t* pin_end = in.ptr + (r+1)*in.pitch;
+        while(pin != pin_end) {
+            *(pout++) = *(pin++);
+        }
+    }
+}
+
+template<typename T>
+void ConvertTo10bit(
+    Image<unsigned char>& out,
+    const Image<unsigned char>& in
+) {
+    for(size_t r=0; r<out.h; ++r) {
+        uint8_t* pout = out.ptr + r*out.pitch;
+        T* pin = (T*)(in.ptr + r*in.pitch);
+        const T* pin_end = (T*)(in.ptr + (r+1)*in.pitch);
+        while(pin != pin_end) {
+            uint64_t val = (*(pin++) & 0x00000003FF);
+            val |= uint64_t(*(pin++) & 0x00000003FF) << 10;
+            val |= uint64_t(*(pin++) & 0x00000003FF) << 20;
+            val |= uint64_t(*(pin++) & 0x00000003FF) << 30;
+            *(pout++) = uint8_t( val & 0x00000000FF);
+            *(pout++) = uint8_t((val & 0x000000FF00) >> 8);
+            *(pout++) = uint8_t((val & 0x0000FF0000) >> 16);
+            *(pout++) = uint8_t((val & 0x00FF000000) >> 24);
+            *(pout++) = uint8_t((val & 0xFF00000000) >> 32);
+        }
+    }
+}
+
+template<typename T>
+void ConvertTo12bit(
+    Image<unsigned char>& out,
+    const Image<unsigned char>& in
+) {
+    for(size_t r=0; r<out.h; ++r) {
+        uint8_t* pout = out.ptr + r*out.pitch;
+        T* pin = (T*)(in.ptr + r*in.pitch);
+        const T* pin_end = (T*)(in.ptr + (r+1)*in.pitch);
+        while(pin != pin_end) {
+            uint32_t val = (*(pin++) & 0x00000FFF);
+            val |= uint32_t(*(pin++) & 0x00000FFF) << 12;
+            *(pout++) = uint8_t( val & 0x000000FF);
+            *(pout++) = uint8_t((val & 0x0000FF00) >> 8);
+            *(pout++) = uint8_t((val & 0x00FF0000) >> 16);
+        }
+    }
+}
+
+void PackVideo::Process(unsigned char* image, const unsigned char* buffer)
+{
+    TSTART()
+    for(size_t s=0; s<streams.size(); ++s) {
+        const Image<unsigned char> img_in  = videoin[0]->Streams()[s].StreamImage(buffer);
+        Image<unsigned char> img_out = Streams()[s].StreamImage(image);
+
+        const int bits_out = Streams()[s].PixFormat().bpp;
+
+        if(videoin[0]->Streams()[s].PixFormat().format == "GRAY16LE") {
+            if(bits_out == 8) {
+                ConvertTo8bit<uint16_t>(img_out, img_in);
+            }else if( bits_out == 10) {
+                ConvertTo10bit<uint16_t>(img_out, img_in);
+            }else if( bits_out == 12){
+                ConvertTo12bit<uint16_t>(img_out, img_in);
+            }else{
+                throw pangolin::VideoException("Unsupported bitdepths.");
+            }
+        }else{
+                throw pangolin::VideoException("Unsupported input pix format.");
+        }
+    }
+    TGRABANDPRINT("Packing took ")
+}
+
+//! Implement VideoInput::GrabNext()
+bool PackVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNext(buffer,wait)) {
+        Process(image,buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool PackVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNewest(buffer,wait)) {
+        Process(image,buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& PackVideo::InputStreams()
+{
+    return videoin;
+}
+
+unsigned int PackVideo::AvailableFrames() const
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Pack: child interface is not buffer aware.");
+        return 0;
+    }
+    else
+    {
+        return vpi->AvailableFrames();
+    }
+}
+
+bool PackVideo::DropNFrames(uint32_t n)
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Pack: child interface is not buffer aware.");
+        return false;
+    }
+    else
+    {
+        return vpi->DropNFrames(n);
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(PackVideo)
+{
+    struct PackVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"pack",10}};
+        }
+        const char* Description() const override
+        {
+            return "Packs a video from a given format.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","GRAY16LE","Pixel format of the video to unpack. See help for pixel formats for all possible values."}
+            }};
+        }
+
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(),uri);
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            const std::string fmt = reader.Get<std::string>("fmt");
+            return std::unique_ptr<VideoInterface>(
+                new PackVideo(subvid, PixelFormatFromString(fmt) )
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<PackVideoFactory>());
+}
+
+}
+
+#undef TSTART
+#undef TGRABANDPRINT
+#undef DBGPRINT

third-party/DPVO/Pangolin/components/pango_video/src/drivers/pango.cpp

@@ -0,0 +1,255 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/log/playback_session.h>
+#include <pangolin/utils/file_extension.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/signal_slot.h>
+#include <pangolin/video/drivers/pango.h>
+
+#include <functional>
+
+namespace pangolin
+{
+
+const std::string pango_video_type = "raw_video";
+
+PangoVideo::PangoVideo(const std::string& filename, std::shared_ptr<PlaybackSession> playback_session)
+    : _filename(filename),
+      _playback_session(playback_session),
+      _reader(_playback_session->Open(filename)),
+      _event_promise(_playback_session->Time()),
+      _src_id(FindPacketStreamSource()),
+      _source(nullptr)
+{
+    PANGO_ENSURE(_src_id != -1, "No appropriate video streams found in log.");
+
+    _source = &_reader->Sources()[_src_id];
+    SetupStreams(*_source);
+
+    // Make sure we time-seek with other playback devices
+    session_seek = _playback_session->Time().OnSeek.connect(
+        [&](SyncTime::TimePoint t){
+            _event_promise.Cancel();
+            _reader->Seek(_src_id, t);
+            _event_promise.WaitAndRenew(_source->NextPacketTime());
+        }
+    );
+
+    _event_promise.WaitAndRenew(_source->NextPacketTime());
+}
+
+PangoVideo::~PangoVideo()
+{
+}
+
+size_t PangoVideo::SizeBytes() const
+{
+    return _size_bytes;
+}
+
+const std::vector<StreamInfo>& PangoVideo::Streams() const
+{
+    return _streams;
+}
+
+void PangoVideo::Start()
+{
+
+}
+
+void PangoVideo::Stop()
+{
+
+}
+
+bool PangoVideo::GrabNext(unsigned char* image, bool /*wait*/)
+{
+    try
+    {
+        Packet fi = _reader->NextFrame(_src_id);
+        _frame_properties = fi.meta;
+
+        if(_fixed_size) {
+            fi.Stream().read(reinterpret_cast<char*>(image), _size_bytes);
+        }else{
+            for(size_t s=0; s < _streams.size(); ++s) {
+                StreamInfo& si = _streams[s];
+                pangolin::Image<unsigned char> dst = si.StreamImage(image);
+
+                if(stream_decoder[s]) {
+                    pangolin::TypedImage img = stream_decoder[s](fi.Stream());
+                    PANGO_ENSURE(img.IsValid());
+
+                    // TODO: We can avoid this copy by decoding directly into img
+                    for(size_t row =0; row < dst.h; ++row) {
+                        std::memcpy(dst.RowPtr(row), img.RowPtr(row), si.RowBytes());
+                    }
+                }else{
+                    for(size_t row =0; row < dst.h; ++row) {
+                        fi.Stream().read((char*)dst.RowPtr(row), si.RowBytes());
+                    }
+                }
+            }
+        }
+
+        _event_promise.WaitAndRenew(_source->NextPacketTime());
+        return true;
+    }
+    catch(...)
+    {
+        _frame_properties = picojson::value();
+        return false;
+    }
+}
+
+bool PangoVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image, wait);
+}
+
+size_t PangoVideo::GetCurrentFrameId() const
+{
+    return (int)(_reader->Sources()[_src_id].next_packet_id) - 1;
+}
+
+size_t PangoVideo::GetTotalFrames() const
+{
+    return _source->index.size();
+}
+
+size_t PangoVideo::Seek(size_t next_frame_id)
+{
+    // Get time for seek
+    if(next_frame_id < _source->index.size()) {
+        const int64_t capture_time = _source->index[next_frame_id].capture_time;
+        _playback_session->Time().Seek(SyncTime::TimePoint(std::chrono::microseconds(capture_time)));
+        return next_frame_id;
+    }else{
+        return _source->next_packet_id;
+    }
+}
+
+std::string PangoVideo::GetSourceUri()
+{
+    return _source_uri;
+}
+
+int PangoVideo::FindPacketStreamSource()
+{
+    for(const auto& src : _reader->Sources())
+    {
+        if (!src.driver.compare(pango_video_type))
+        {
+            return static_cast<int>(src.id);
+        }
+    }
+
+    return -1;
+}
+
+void PangoVideo::SetupStreams(const PacketStreamSource& src)
+{
+    // Read sources header
+    _fixed_size = src.data_size_bytes != 0;
+    _size_bytes = src.data_size_bytes;
+    _source_uri = src.uri;
+
+    _device_properties = src.info["device"];
+    const picojson::value& json_streams = src.info["streams"];
+    const size_t num_streams = json_streams.size();
+
+    for (size_t i = 0; i < num_streams; ++i)
+    {
+        const picojson::value& json_stream = json_streams[i];
+
+        std::string encoding = json_stream["encoding"].get<std::string>();
+
+        // Check if the stream is compressed
+        if(json_stream.contains("decoded")) {
+            const std::string compressed_encoding = encoding;
+            encoding = json_stream["decoded"].get<std::string>();
+            const PixelFormat decoded_fmt = PixelFormatFromString(encoding);
+            stream_decoder.push_back(StreamEncoderFactory::I().GetDecoder(compressed_encoding, decoded_fmt));
+        }else{
+            stream_decoder.push_back(nullptr);
+        }
+
+        PixelFormat fmt = PixelFormatFromString(encoding);
+
+        fmt.channel_bit_depth = json_stream.get_value<int64_t>("channel_bit_depth", 0);
+
+        StreamInfo si(
+                fmt,
+                json_stream["width"].get<int64_t>(),
+                json_stream["height"].get<int64_t>(),
+                json_stream["pitch"].get<int64_t>(),
+                reinterpret_cast<unsigned char*>(json_stream["offset"].get<int64_t>())
+                        );
+
+        if(!_fixed_size) {
+            _size_bytes += si.SizeBytes();
+        }
+
+        _streams.push_back(si);
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(PangoVideo)
+{
+    struct PangoVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"pango",0}, {"file",5}};
+        }
+        const char* Description() const override
+        {
+            return "Plays Pango video container format.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"OrderedPlayback","false","Whether the playback respects the order of every data as they were recorded. Important for simulated playback."}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const std::string path = PathExpand(uri.url);
+
+            ParamReader reader(Params(),uri);
+
+            if( !uri.scheme.compare("pango") || FileType(uri.url) == ImageFileTypePango ) {
+                return std::unique_ptr<VideoInterface>(new PangoVideo(path.c_str(), PlaybackSession::ChooseFromParams(reader)));
+            }
+            return std::unique_ptr<VideoInterface>();
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<PangoVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/pango_video_output.cpp

@@ -0,0 +1,319 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/memstreambuf.h>
+#include <pangolin/utils/picojson.h>
+#include <pangolin/utils/sigstate.h>
+#include <pangolin/utils/timer.h>
+#include <pangolin/video/drivers/pango_video_output.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video_interface.h>
+#include <set>
+#include <future>
+
+#ifndef _WIN_
+#  include <unistd.h>
+#endif
+
+namespace pangolin
+{
+
+const std::string pango_video_type = "raw_video";
+
+void SigPipeHandler(int sig)
+{
+    SigState::I().sig_callbacks.at(sig).value = true;
+}
+
+PangoVideoOutput::PangoVideoOutput(const std::string& filename, size_t buffer_size_bytes, const std::map<size_t, std::string> &stream_encoder_uris)
+    : filename(filename),
+      packetstream_buffer_size_bytes(buffer_size_bytes),
+      packetstreamsrcid(-1),
+      total_frame_size(0),
+      is_pipe(pangolin::IsPipe(filename)),
+      fixed_size(true),
+      stream_encoder_uris(stream_encoder_uris)
+{
+    if(!is_pipe)
+    {
+        packetstream.Open(filename, packetstream_buffer_size_bytes);
+    }
+    else
+    {
+        RegisterNewSigCallback(&SigPipeHandler, (void*)this, SIGPIPE);
+    }
+
+    // Instantiate encoders
+}
+
+PangoVideoOutput::~PangoVideoOutput()
+{
+}
+
+const std::vector<StreamInfo>& PangoVideoOutput::Streams() const
+{
+    return streams;
+}
+
+bool PangoVideoOutput::IsPipe() const
+{
+    return is_pipe;
+}
+
+void PangoVideoOutput::SetStreams(const std::vector<StreamInfo>& st, const std::string& uri, const picojson::value& properties)
+{
+    std::set<unsigned char*> unique_ptrs;
+    for (size_t i = 0; i < st.size(); ++i)
+    {
+    unique_ptrs.insert(st[i].Offset());
+    }
+
+    if (unique_ptrs.size() < st.size())
+    throw std::invalid_argument("Each image must have unique offset into buffer.");
+
+    if (packetstreamsrcid == -1)
+    {
+        input_uri = uri;
+        streams = st;
+        device_properties = properties;
+
+        picojson::value json_header(picojson::object_type, false);
+        picojson::value& json_streams = json_header["streams"];
+        json_header["device"] = device_properties;
+
+        stream_encoders.resize(streams.size());
+
+        fixed_size = true;
+
+        total_frame_size = 0;
+        for (unsigned int i = 0; i < streams.size(); ++i)
+        {
+            StreamInfo& si = streams[i];
+            total_frame_size = std::max(total_frame_size, (size_t) si.Offset() + si.SizeBytes());
+
+            picojson::value& json_stream = json_streams.push_back();
+
+            std::string encoder_name = si.PixFormat().format;
+            if(stream_encoder_uris.find(i) != stream_encoder_uris.end() && !stream_encoder_uris[i].empty() ) {
+                // instantiate encoder and write it's name to the stream properties
+                json_stream["decoded"] = si.PixFormat().format;
+                encoder_name = stream_encoder_uris[i];
+                stream_encoders[i] = StreamEncoderFactory::I().GetEncoder(encoder_name, si.PixFormat());
+                fixed_size = false;
+            }
+
+            json_stream["channel_bit_depth"] = si.PixFormat().channel_bit_depth;
+            json_stream["encoding"] = encoder_name;
+            json_stream["width"] = si.Width();
+            json_stream["height"] = si.Height();
+            json_stream["pitch"] = si.Pitch();
+            json_stream["offset"] = (size_t) si.Offset();
+        }
+
+        PacketStreamSource pss;
+        pss.driver = pango_video_type;
+        pss.uri = input_uri;
+        pss.info = json_header;
+        pss.data_size_bytes = fixed_size ? total_frame_size : 0;
+        pss.data_definitions = "struct Frame{ uint8 stream_data[" + pangolin::Convert<std::string, size_t>::Do(total_frame_size) + "];};";
+
+        packetstreamsrcid = (int)packetstream.AddSource(pss);
+    } else {
+        throw std::runtime_error("Unable to add new streams");
+    }
+}
+
+int PangoVideoOutput::WriteStreams(const unsigned char* data, const picojson::value& frame_properties)
+{
+    const int64_t host_reception_time_us = frame_properties.get_value(PANGO_HOST_RECEPTION_TIME_US, Time_us(TimeNow()));
+
+#ifndef _WIN_
+    if (is_pipe)
+    {
+        // If there is a reader waiting on the other side of the pipe, open
+        // a file descriptor to the file and close it only after the file
+        // has been opened by the PacketStreamWriter. This avoids the reader
+        // from seeing EOF on its next read because all file descriptors on
+        // the write side have been closed.
+        //
+        // When the stream is already open but the reader has disappeared,
+        // opening a file descriptor will fail and errno will be ENXIO.
+        int fd = WritablePipeFileDescriptor(filename);
+
+        if (!packetstream.IsOpen())
+        {
+            if (fd != -1)
+            {
+                packetstream.Open(filename, packetstream_buffer_size_bytes);
+                close(fd);
+            }
+        }
+        else
+        {
+            if (fd != -1)
+            {
+                // There's a reader on the other side of the pipe.
+                close(fd);
+            }
+            else
+            {
+                if (errno == ENXIO)
+                {
+                    packetstream.ForceClose();
+                    SigState::I().sig_callbacks.at(SIGPIPE).value = false;
+
+                    // This should be unnecessary since per the man page,
+                    // data should be dropped from the buffer upon closing the
+                    // writable file descriptors.
+                    pangolin::FlushPipe(filename);
+                }
+            }
+        }
+
+        if (!packetstream.IsOpen())
+            return 0;
+    }
+#endif
+
+    if(!fixed_size) {
+        // TODO: Make this more efficient (without so many allocs and memcpy's)
+
+        std::vector<memstreambuf> encoded_stream_data;
+
+        // Create buffers for compressed data: the first will be reused for all the data later
+        encoded_stream_data.emplace_back(total_frame_size);
+        for(size_t i=1; i < streams.size(); ++i) {
+            encoded_stream_data.emplace_back(streams[i].SizeBytes());
+        }
+
+        // lambda encodes frame data i to encoded_stream_data[i]
+        auto encode_stream = [&](int i){
+            encoded_stream_data[i].clear();
+            std::ostream encode_stream(&encoded_stream_data[i]);
+
+            const StreamInfo& si = streams[i];
+            const Image<unsigned char> stream_image = si.StreamImage(data);
+
+            if(stream_encoders[i]) {
+                // Encode to buffer
+                stream_encoders[i](encode_stream, stream_image);
+            }else{
+                if(stream_image.IsContiguous()) {
+                    encode_stream.write((char*)stream_image.ptr, streams[i].SizeBytes());
+                }else{
+                    for(size_t row=0; row < stream_image.h; ++row) {
+                        encode_stream.write((char*)stream_image.RowPtr(row), si.RowBytes());
+                    }
+                }
+            }
+            return true;
+        };
+
+        // Compress each stream (>0 in another thread)
+        std::vector<std::future<bool>> encode_finished;
+        for(size_t i=1; i < streams.size(); ++i) {
+            encode_finished.emplace_back(std::async(std::launch::async, [&,i](){
+                return encode_stream(i);
+            }));
+        }
+        // Encode stream 0 in this thread
+        encode_stream(0);
+
+        // Reuse our first compression stream for the rest of the data too.
+        std::vector<uint8_t>& encoded = encoded_stream_data[0].buffer;
+
+        // Wait on all threads to finish and copy into data packet
+        for(size_t i=1; i < streams.size(); ++i) {
+            encode_finished[i-1].get();
+            encoded.insert(encoded.end(), encoded_stream_data[i].buffer.begin(), encoded_stream_data[i].buffer.end());
+        }
+
+        packetstream.WriteSourcePacket(packetstreamsrcid, reinterpret_cast<const char*>(encoded.data()), host_reception_time_us, encoded.size(), frame_properties);
+    }else{
+        packetstream.WriteSourcePacket(packetstreamsrcid, reinterpret_cast<const char*>(data), host_reception_time_us, total_frame_size, frame_properties);
+    }
+
+    return 0;
+}
+
+PANGOLIN_REGISTER_FACTORY(PangoVideoOutput)
+{
+    struct PangoVideoFactory final : public TypedFactoryInterface<VideoOutputInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"pango",10}, {"file",10}};
+        }
+        const char* Description() const override
+        {
+            return "Output to a Pango video container.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"buffer_size_mb","100","Buffer size in MB"},
+                {"unique_filename","","This is flag to create a unique file name in the case of file already exists."},
+                {"encoder(\\d+)?"," ","encoder or encoderN, 1 <= N <= 100. The default values of encoderN are set to encoder"}
+            }};
+        }
+        std::unique_ptr<VideoOutputInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(), uri);
+
+            const size_t mb = 1024*1024;
+            const size_t buffer_size_bytes = reader.Get<size_t>("buffer_size_mb") * mb;
+            std::string filename = uri.url;
+
+            if(reader.Contains("unique_filename")) {
+                filename = MakeUniqueFilename(filename);
+            }
+
+            // Default encoder
+            std::string default_encoder = "";
+
+            if(reader.Contains("encoder")) {
+                default_encoder = reader.Get<std::string>("encoder","");
+            }
+
+            // Encoders for each stream
+            std::map<size_t, std::string> stream_encoder_uris;
+            for(size_t i=0; i<100; ++i)
+            {
+                const std::string encoder_key = pangolin::FormatString("encoder%",i+1);
+                stream_encoder_uris[i] = reader.Get<std::string>(encoder_key, default_encoder);
+            }
+
+            return std::unique_ptr<VideoOutputInterface>(
+                new PangoVideoOutput(filename, buffer_size_bytes, stream_encoder_uris)
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoOutputInterface>(std::make_shared<PangoVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/pleora.cpp

@@ -0,0 +1,756 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/pleora.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <thread>
+
+#ifdef DEBUGPLEORA
+  #include <pangolin/utils/timer.h>
+  #define TSTART() pangolin::basetime start,last,now; start = pangolin::TimeNow(); last = start;
+  #define TGRABANDPRINT(...)  now = pangolin::TimeNow(); fprintf(stderr,"  PLEORA: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr, " %fms.\n",1000*pangolin::TimeDiff_s(last, now)); last = now;
+  #define DBGPRINT(...) fprintf(stderr,"  PLEORA: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr,"\n");
+#else
+  #define TSTART()
+  #define TGRABANDPRINT(...)
+  #define DBGPRINT(...)
+#endif
+
+namespace pangolin
+{
+
+inline void ThrowOnFailure(const PvResult& res)
+{
+    if(res.IsFailure()) {
+        throw std::runtime_error("Failure: " + std::string(res.GetCodeString().GetAscii()) );
+    }
+}
+
+template<typename T>
+struct PleoraParamTraits;
+
+template<> struct PleoraParamTraits<bool> {
+    typedef PvGenBoolean PvType;
+};
+template<> struct PleoraParamTraits<int64_t> {
+    typedef PvGenInteger PvType;
+};
+template<> struct PleoraParamTraits<float> {
+    typedef PvGenFloat PvType;
+};
+template<> struct PleoraParamTraits<std::string> {
+    typedef PvGenString PvType;
+};
+
+template<typename T>
+T GetParam(PvGenParameterArray* params, const char* name)
+{
+    typedef typename PleoraParamTraits<T>::PvType PvType;
+    PvType* param = dynamic_cast<PvType*>( params->Get(name) );
+    if(!param) {
+        throw std::runtime_error("Incorrect type");
+    }
+    T ret;
+    PvResult res = param->GetValue(ret);
+    if(res.IsFailure()) {
+        throw std::runtime_error("Cannot get value: " + std::string(res.GetCodeString().GetAscii()) );
+    }
+    return ret;
+}
+
+template<typename T>
+bool SetParam(PvGenParameterArray* params, const char* name, T val)
+{
+    typedef typename PleoraParamTraits<T>::PvType PvType;
+    PvType* param = dynamic_cast<PvType*>( params->Get(name) );
+    if(!param) {
+        throw std::runtime_error("Unable to get parameter handle: " + std::string(name) );
+    }
+
+    if(!param->IsWritable()) {
+        throw std::runtime_error("Cannot set value for " + std::string(name) );
+    }
+
+    PvResult res = param->SetValue(val);
+    if(res.IsFailure()) {
+        throw std::runtime_error("Cannot set value: " + std::string(res.GetCodeString().GetAscii()) );
+    }
+    return true;
+}
+
+inline const PvDeviceInfo* SelectDevice( PvSystem& aSystem, const char* model_name = 0, const char* serial_num = 0, size_t index = 0 )
+{
+    aSystem.Find();
+
+    // Enumerate all devices, select first that matches criteria
+    size_t matches = 0;
+    for ( uint32_t i = 0; i < aSystem.GetInterfaceCount(); i++ ) {
+        const PvInterface *lInterface = dynamic_cast<const PvInterface *>( aSystem.GetInterface( i ) );
+        if ( lInterface ) {
+            for ( uint32_t j = 0; j < lInterface->GetDeviceCount(); j++ ) {
+                const PvDeviceInfo *lDI = dynamic_cast<const PvDeviceInfo *>( lInterface->GetDeviceInfo( j ) );
+                if ( lDI && lDI->IsConfigurationValid() ) {
+                    if( model_name && strcmp(lDI->GetModelName().GetAscii(), model_name) )
+                        continue;
+                    if( serial_num && strcmp(lDI->GetSerialNumber().GetAscii(), serial_num) )
+                        continue;
+                    if(matches == index) {
+                        return lDI;
+                    }
+                    ++matches;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+PixelFormat PleoraFormat(const PvGenEnum* pfmt)
+{
+    std::string spfmt = pfmt->ToString().GetAscii();
+    if( !spfmt.compare("Mono8") ) {
+        return PixelFormatFromString("GRAY8");
+    } else if( !spfmt.compare("Mono10p") ) {
+        return PixelFormatFromString("GRAY10");
+    } else if( !spfmt.compare("Mono12p") ) {
+        return PixelFormatFromString("GRAY12");
+    } else if( !spfmt.compare("Mono10") || !spfmt.compare("Mono12")) {
+        return PixelFormatFromString("GRAY16LE");
+    } else if( !spfmt.compare("RGB8") ) {
+        return PixelFormatFromString("RGB24");
+    } else if( !spfmt.compare("BGR8") ) {
+        return PixelFormatFromString("BGR24");
+    } else if( !spfmt.compare("BayerBG8") ) {
+        return PixelFormatFromString("GRAY8");
+    } else if( !spfmt.compare("BayerBG12") ) {
+        return PixelFormatFromString("GRAY16LE");
+    } else {
+        throw VideoException("Unknown Pleora pixel format", spfmt);
+    }
+}
+
+PleoraVideo::PleoraVideo(const Params& p): size_bytes(0), lPvSystem(0), lDevice(0), lStream(0), lDeviceParams(0), lStart(0), lStop(0),
+    lTemperatureCelcius(0), getTemp(false), lStreamParams(0), validGrabbedBuffers(0)
+{
+    std::string sn;
+    std::string mn;
+    int index = 0;
+    size_t buffer_count = PleoraVideo::DEFAULT_BUFFER_COUNT;
+    Params device_params;
+
+    for(Params::ParamMap::const_iterator it = p.params.begin(); it != p.params.end(); it++) {
+        if(it->first == "model"){
+            mn = it->second;
+        } else if(it->first == "sn"){
+            sn = it->second;
+        } else if(it->first == "idx"){
+            index = p.Get<int>("idx", 0);
+        } else if(it->first == "size") {
+            const ImageDim dim = p.Get<ImageDim>("size", ImageDim(0,0) );
+            device_params.Set("Width"  , dim.x);
+            device_params.Set("Height" , dim.y);
+        } else if(it->first == "pos") {
+            const ImageDim pos = p.Get<ImageDim>("pos", ImageDim(0,0) );
+            device_params.Set("OffsetX"  , pos.x);
+            device_params.Set("OffsetY" , pos.y);
+        } else if(it->first == "roi") {
+            const ImageRoi roi = p.Get<ImageRoi>("roi", ImageRoi(0,0,0,0) );
+            device_params.Set("Width"  , roi.w);
+            device_params.Set("Height" , roi.h);
+            device_params.Set("OffsetX", roi.x);
+            device_params.Set("OffsetY", roi.y);
+        } else {
+            device_params.Set(it->first, it->second);
+        }
+    }
+
+    InitDevice(mn.empty() ? 0 : mn.c_str(), sn.empty() ? 0 : sn.c_str(), index);
+    SetDeviceParams(device_params);
+    InitStream();
+
+    InitPangoStreams();
+    InitPangoDeviceProperties();
+    InitBuffers(buffer_count);
+}
+
+PleoraVideo::~PleoraVideo()
+{
+    Stop();
+    DeinitBuffers();
+    DeinitStream();
+    DeinitDevice();
+}
+
+std::string PleoraVideo::GetParameter(const std::string& name) {
+    PvGenParameter* par = lDeviceParams->Get(PvString(name.c_str()));
+    if(par) {
+        PvString ret = par->ToString();
+        return std::string(ret.GetAscii());
+    } else {
+        pango_print_error("Parameter %s not recognized\n", name.c_str());
+        return "";
+    }
+}
+
+void PleoraVideo::SetParameter(const std::string& name, const std::string& value) {
+    PvGenParameter* par = lDeviceParams->Get(PvString(name.c_str()));
+    if(par) {
+        PvResult r = par->FromString(PvString(value.c_str()));
+        if(!r.IsOK()){
+            pango_print_error("Error setting parameter %s to:%s Reason:%s\n", name.c_str(), value.c_str(), r.GetDescription().GetAscii());
+        } else {
+            pango_print_info("Setting parameter %s to:%s\n", name.c_str(), value.c_str());
+        }
+    } else {
+        pango_print_error("Parameter %s not recognized\n", name.c_str());
+    }
+}
+
+void PleoraVideo::InitDevice(
+        const char* model_name, const char* serial_num, size_t index
+) {
+    lPvSystem = new PvSystem();
+    if ( !lPvSystem ) {
+        throw pangolin::VideoException("Pleora: Unable to create PvSystem");
+    }
+
+    lDeviceInfo = SelectDevice(*lPvSystem, model_name, serial_num, index);
+    if ( !lDeviceInfo ) {
+        delete lPvSystem;
+        throw pangolin::VideoException("Pleora: Unable to select device");
+    }
+
+    PvResult lResult;
+    lDevice = PvDevice::CreateAndConnect( lDeviceInfo, &lResult );
+    if ( !lDevice ) {
+        delete lPvSystem;
+        throw pangolin::VideoException("Pleora: Unable to connect to device", lResult.GetDescription().GetAscii() );
+    }
+
+    lDeviceParams = lDevice->GetParameters();
+}
+
+
+void PleoraVideo::DeinitDevice()
+{
+    if(lDevice) {
+        lDevice->Disconnect();
+        PvDevice::Free( lDevice );
+        lDevice = 0;
+    }
+
+    delete lPvSystem;
+    lPvSystem = 0;
+}
+
+void PleoraVideo::InitStream()
+{
+    // Setup Stream
+    PvResult lResult;
+    lStream = PvStream::CreateAndOpen( lDeviceInfo->GetConnectionID(), &lResult );
+    if ( !lStream ) {
+        DeinitDevice();
+        throw pangolin::VideoException("Pleora: Unable to open stream", lResult.GetDescription().GetAscii() );
+    }
+    lStreamParams = lStream->GetParameters();
+}
+
+void PleoraVideo::DeinitStream()
+{
+    if(lStream) {
+        lStream->Close();
+        PvStream::Free( lStream );
+        lStream = 0;
+    }
+}
+
+void PleoraVideo::SetDeviceParams(Params& p) {
+
+    lStart = dynamic_cast<PvGenCommand*>( lDeviceParams->Get( "AcquisitionStart" ) );
+    lStop = dynamic_cast<PvGenCommand*>( lDeviceParams->Get( "AcquisitionStop" ) );
+
+    for(Params::ParamMap::iterator it = p.params.begin(); it != p.params.end(); it++) {
+        if(it->first == "get_temperature"){
+            getTemp = p.Get<bool>("get_temperature",false);
+        } else {
+            if (it->second == "Execute") {
+              // This is a command, deal with it accordingly.
+              PvGenCommand* cmd = dynamic_cast<PvGenCommand*>(lDeviceParams->Get(it->first.c_str()));
+              if(cmd) {
+                  PvResult r = cmd->Execute();
+                  if(!r.IsOK()){
+                      pango_print_error("Error executing command %s Reason:%s\n", it->first.c_str(), r.GetDescription().GetAscii());
+                  } else {
+                      pango_print_info("Executed Command %s\n", it->first.c_str());
+                  }
+                  bool done;
+                  int attempts = 20;
+                  do {
+                      cmd->IsDone(done);
+                      std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+                      attempts--;
+                  } while(!done && (attempts > 0));
+                  if(attempts == 0) {
+                      pango_print_error("Timeout while waiting for command %s done\n", it->first.c_str());
+                  }
+              } else {
+                  pango_print_error("Command %s not recognized\n", it->first.c_str());
+              }
+            } else {
+                try {
+                    PvGenParameter* par = lDeviceParams->Get(PvString(it->first.c_str()));
+                    if(par) {
+                        PvResult r = par->FromString(PvString(it->second.c_str()));
+                        if(!r.IsOK()){
+                            pango_print_error("Error setting parameter %s to:%s Reason:%s\n", it->first.c_str(), it->second.c_str(), r.GetDescription().GetAscii());
+                        } else {
+                            pango_print_info("Setting parameter %s to:%s\n", it->first.c_str(), it->second.c_str());
+                        }
+                    } else {
+                        pango_print_error("Parameter %s not recognized\n", it->first.c_str());
+                    }
+                } catch(std::runtime_error e) {
+                    pango_print_error("Set parameter %s: %s\n", it->first.c_str(), e.what());
+                }
+            }
+        }
+    }
+
+    // Get Handles to properties we'll be using.
+    lAnalogGain = lDeviceParams->GetInteger("AnalogGain");
+    lGamma = lDeviceParams->GetFloat("Gamma");
+    lAnalogBlackLevel = lDeviceParams->GetInteger("AnalogBlackLevel");
+    lExposure = lDeviceParams->GetFloat("ExposureTime");
+    lAquisitionMode = lDeviceParams->GetEnum("AcquisitionMode");
+    lTriggerSource = lDeviceParams->GetEnum("TriggerSource");
+    lTriggerMode = lDeviceParams->GetEnum("TriggerMode");
+
+    if(getTemp) {
+        lTemperatureCelcius = lDeviceParams->GetFloat("DeviceTemperatureCelsius");
+        pango_print_warn("Warning: get_temperature might add a blocking call taking several ms to each frame read.");
+    }
+
+}
+
+void PleoraVideo::InitBuffers(size_t buffer_count)
+{
+    // Reading payload size from device
+    const uint32_t lSize = lDevice->GetPayloadSize();
+
+    // Use buffer_count or the maximum number of buffers, whichever is smaller
+    const uint32_t lBufferCount = ( lStream->GetQueuedBufferMaximum() < buffer_count ) ?
+        lStream->GetQueuedBufferMaximum() :
+        buffer_count;
+
+    // Allocate buffers and queue
+    for( uint32_t i = 0; i < lBufferCount; i++ ) {
+        PvBuffer *lBuffer = new PvBuffer;
+        lBuffer->Alloc( static_cast<uint32_t>( lSize ) );
+        lBufferList.push_back( lBuffer );
+    }
+}
+
+void PleoraVideo::DeinitBuffers()
+{
+    // Free buffers
+    for( BufferList::iterator lIt = lBufferList.begin(); lIt != lBufferList.end(); lIt++ ) {
+        delete *lIt;
+    }
+    lBufferList.clear();
+}
+
+void PleoraVideo::InitPangoStreams()
+{
+    // Get actual width, height and payload size
+    const int w = DeviceParam<int64_t>("Width");
+    const int h = DeviceParam<int64_t>("Height");
+    const uint32_t lSize = lDevice->GetPayloadSize();
+
+    // Setup pangolin for stream
+    PvGenEnum* lpixfmt = dynamic_cast<PvGenEnum*>( lDeviceParams->Get("PixelFormat") );
+    const PixelFormat fmt = PleoraFormat(lpixfmt);
+    streams.push_back(StreamInfo(fmt, w, h, (w*fmt.bpp)/8));
+    size_bytes = lSize;
+}
+
+void PleoraVideo::InitPangoDeviceProperties()
+{
+    // Store camera details in device properties
+    device_properties["SerialNumber"] = std::string(lDeviceInfo->GetSerialNumber().GetAscii());
+    device_properties["VendorName"] = std::string(lDeviceInfo->GetVendorName().GetAscii());
+    device_properties["ModelName"] = std::string(lDeviceInfo->GetModelName().GetAscii());
+    device_properties["ManufacturerInfo"] = std::string(lDeviceInfo->GetManufacturerInfo().GetAscii());
+    device_properties["Version"] = std::string(lDeviceInfo->GetVersion().GetAscii());
+    device_properties["DisplayID"] = std::string(lDeviceInfo->GetDisplayID().GetAscii());
+    device_properties["UniqueID"] = std::string(lDeviceInfo->GetUniqueID().GetAscii());
+    device_properties["ConnectionID"] = std::string(lDeviceInfo->GetConnectionID().GetAscii());
+
+    picojson::value props(picojson::object_type, true);
+    for(size_t i=0; i < lDeviceParams->GetCount(); ++i) {
+        PvGenParameter* p = (*lDeviceParams)[i];
+        if(p->IsReadable()) {
+            props[p->GetName().GetAscii()] = p->ToString().GetAscii();
+        }
+    }
+
+    device_properties["properties"] = props;
+}
+
+unsigned int PleoraVideo::AvailableFrames() const
+{
+    return validGrabbedBuffers;
+}
+
+bool PleoraVideo::DropNFrames(uint32_t n)
+{
+    if(n > validGrabbedBuffers) return false;
+
+    while(n > 0) {
+       lStream->QueueBuffer(lGrabbedBuffList.front().buff);
+       lGrabbedBuffList.pop_front();
+       --validGrabbedBuffers;
+       --n;
+       DBGPRINT("DropNFrames: removed 1 frame from the list and requeued it.")
+    }
+
+    return true;
+}
+
+void PleoraVideo::Start()
+{
+    if(lStream->GetQueuedBufferCount() == 0) {
+        // Queue all buffers in the stream
+        for( BufferList::iterator lIt = lBufferList.begin(); lIt != lBufferList.end(); lIt++ ) {
+            lStream->QueueBuffer( *lIt );
+        }
+        lDevice->StreamEnable();
+        lStart->Execute();
+    } else {
+//        // It isn't an error to repeatedly start
+//        pango_print_warn("PleoraVideo: Already started.\n");
+    }
+}
+
+void PleoraVideo::Stop()
+{
+    // stop grab thread
+    if(lStream->GetQueuedBufferCount() > 0) {
+        lStop->Execute();
+        lDevice->StreamDisable();
+
+        // Abort all buffers from the stream and dequeue
+        lStream->AbortQueuedBuffers();
+        while ( lStream->GetQueuedBufferCount() > 0 ) {
+            PvBuffer *lBuffer = NULL;
+            PvResult lOperationResult;
+            lStream->RetrieveBuffer( &lBuffer, &lOperationResult );
+        }
+    } else {
+//        // It isn't an error to repeatedly stop
+//        pango_print_warn("PleoraVideo: Already stopped.\n");
+    }
+}
+
+size_t PleoraVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+const std::vector<StreamInfo>& PleoraVideo::Streams() const
+{
+    return streams;
+}
+
+bool PleoraVideo::ParseBuffer(PvBuffer* lBuffer,  unsigned char* image)
+{
+  TSTART()
+  if ( lBuffer->GetPayloadType() == PvPayloadTypeImage ) {
+      PvImage *lImage = lBuffer->GetImage();
+      TGRABANDPRINT("GetImage took ")
+      std::memcpy(image, lImage->GetDataPointer(), size_bytes);
+      TGRABANDPRINT("memcpy took ")
+      // Required frame properties
+      frame_properties[PANGO_CAPTURE_TIME_US] = picojson::value(lBuffer->GetTimestamp());
+      frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(lBuffer->GetReceptionTime());
+      TGRABANDPRINT("Frame properties took ")
+
+      // Optional frame properties
+      if(lTemperatureCelcius != 0) {
+          double val;
+          PvResult lResult = lTemperatureCelcius->GetValue(val);
+          if(lResult.IsSuccess()) {
+              frame_properties[PANGO_SENSOR_TEMPERATURE_C] = picojson::value(val);
+          } else {
+              pango_print_error("DeviceTemperatureCelsius %f fail\n", val);
+          }
+      }
+      TGRABANDPRINT("GetTemperature took ")
+      return true;
+  } else {
+      return false;
+  }
+
+}
+
+bool PleoraVideo::GrabNext( unsigned char* image, bool wait)
+{
+    const uint32_t timeout = wait ? 1000 : 0;
+    bool good = false;
+    TSTART()
+    DBGPRINT("GrabNext no thread:")
+
+    RetriveAllAvailableBuffers((validGrabbedBuffers==0) ? timeout : 0);
+    TGRABANDPRINT("Retriving all available buffers (valid frames in queue=%d, queue size=%ld) took ",validGrabbedBuffers ,lGrabbedBuffList.size())
+
+    if(validGrabbedBuffers == 0) return false;
+
+    // Retrieve next buffer from list and parse it
+    GrabbedBufferList::iterator front = lGrabbedBuffList.begin();
+    if ( front->res.IsOK() ) {
+        good = ParseBuffer(front->buff, image);
+    }
+    TGRABANDPRINT("Parsing buffer took ")
+
+    lStream->QueueBuffer(front->buff);
+    TGRABANDPRINT("\tPLEORA:QueueBuffer: ")
+
+    // Remove used buffer from list.
+    lGrabbedBuffList.pop_front();
+    --validGrabbedBuffers;
+
+    return good;
+}
+
+
+bool PleoraVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    const uint32_t timeout = wait ? 0xFFFFFFFF : 0;
+    bool good = false;
+
+    TSTART()
+    DBGPRINT("GrabNewest no thread:")
+    RetriveAllAvailableBuffers((validGrabbedBuffers==0) ? timeout : 0);
+    TGRABANDPRINT("Retriving all available buffers (valid frames in queue=%d, queue size=%ld) took ",validGrabbedBuffers ,lGrabbedBuffList.size())
+
+    if(validGrabbedBuffers == 0) {
+        DBGPRINT("No valid buffers, returning.")
+        return false;
+    }
+    if(validGrabbedBuffers > 1) DropNFrames(validGrabbedBuffers-1);
+    TGRABANDPRINT("Dropping %d frames took ", (validGrabbedBuffers-1))
+
+    // Retrieve next buffer from list and parse it
+    GrabbedBufferList::iterator front = lGrabbedBuffList.begin();
+    if ( front->res.IsOK() ) {
+        good = ParseBuffer(front->buff, image);
+    }
+    TGRABANDPRINT("Parsing buffer took ")
+
+    lStream->QueueBuffer(front->buff);
+    TGRABANDPRINT("Requeueing buffer took ")
+
+    // Remove used buffer from list.
+    lGrabbedBuffList.pop_front();
+    --validGrabbedBuffers;
+
+    return good;
+}
+
+void PleoraVideo::RetriveAllAvailableBuffers(uint32_t timeout){
+    PvBuffer *lBuffer = NULL;
+    PvResult lOperationResult;
+    PvResult lResult;
+    TSTART()
+    do {
+        lResult = lStream->RetrieveBuffer( &lBuffer, &lOperationResult, timeout);
+        if ( !lResult.IsOK() ) {
+            if(lResult && !(lResult.GetCode() == PvResult::Code::TIMEOUT)) {
+                pango_print_warn("Pleora error: %s,\n'%s'\n", lResult.GetCodeString().GetAscii(), lResult.GetDescription().GetAscii() );
+            }
+            return;
+        } else if( !lOperationResult.IsOK() ) {
+            pango_print_warn("Pleora error %s,\n'%s'\n", lOperationResult.GetCodeString().GetAscii(), lResult.GetDescription().GetAscii() );
+            lStream->QueueBuffer( lBuffer );
+            return;
+        }
+        lGrabbedBuffList.push_back(GrabbedBuffer(lBuffer,lOperationResult,true));
+        ++validGrabbedBuffers;
+        TGRABANDPRINT("Attempt retrieving buffer (timeout=%d validbuffer=%d) took ", timeout, validGrabbedBuffers)
+        timeout = 0;
+    } while (lResult.IsOK());
+}
+
+int64_t PleoraVideo::GetGain()
+{
+    int64_t val;
+    if(lAnalogGain) {
+        ThrowOnFailure( lAnalogGain->GetValue(val) );
+    }
+    return val;
+}
+
+void PleoraVideo::SetGain(int64_t val)
+{
+    if(val >= 0 && lAnalogGain && lAnalogGain->IsWritable()) {
+        ThrowOnFailure( lAnalogGain->SetValue(val) );
+        frame_properties[PANGO_ANALOG_GAIN] = picojson::value(val);
+    }
+}
+
+int64_t PleoraVideo::GetAnalogBlackLevel()
+{
+    int64_t val;
+    if(lAnalogBlackLevel) {
+        ThrowOnFailure( lAnalogBlackLevel->GetValue(val) );
+    }
+    return val;
+}
+
+void PleoraVideo::SetAnalogBlackLevel(int64_t val)
+{
+    if(val >= 0 && lAnalogBlackLevel&& lAnalogBlackLevel->IsWritable()) {
+        ThrowOnFailure( lAnalogBlackLevel->SetValue(val) );
+        frame_properties[PANGO_ANALOG_BLACK_LEVEL] = picojson::value(val);
+    }
+}
+
+double PleoraVideo::GetExposure()
+{
+    double val;
+    if( lExposure ) {
+        ThrowOnFailure( lExposure->GetValue(val));
+    }
+    return val;
+}
+
+void PleoraVideo::SetExposure(double val)
+{
+    if(val > 0 && lExposure && lExposure->IsWritable() ) {
+        ThrowOnFailure( lExposure->SetValue(val) );
+        frame_properties[PANGO_EXPOSURE_US] = picojson::value(val);
+    }
+}
+
+
+double PleoraVideo::GetGamma()
+{
+    double val;
+    if(lGamma) {
+        ThrowOnFailure(lGamma->GetValue(val));
+    }
+    return val;
+}
+
+void PleoraVideo::SetGamma(double val)
+{
+    if(val > 0 && lGamma && lGamma->IsWritable() ) {
+        ThrowOnFailure( lGamma->SetValue(val) );
+        frame_properties[PANGO_GAMMA] = picojson::value(val);
+    }
+}
+
+//use 0,0,1 for line0 hardware trigger.
+//use 2,252,0 for software continuous
+void PleoraVideo::SetupTrigger(bool triggerActive, int64_t triggerSource, int64_t acquisitionMode)
+{
+    if(lAquisitionMode && lTriggerSource && lTriggerMode &&
+        lAquisitionMode->IsWritable() && lTriggerSource->IsWritable() && lTriggerMode->IsWritable() ) {
+        // Check input is valid.
+        const PvGenEnumEntry* entry_src;
+        const PvGenEnumEntry* entry_acq;
+        lTriggerSource->GetEntryByValue(triggerSource, &entry_src);
+        lAquisitionMode->GetEntryByValue(acquisitionMode, &entry_acq);
+
+        if(entry_src && entry_acq) {
+            ThrowOnFailure(lTriggerMode->SetValue(triggerActive ? 1 : 0));
+            if(triggerActive) {
+                pango_print_debug("Pleora: external trigger active\n");
+                ThrowOnFailure(lTriggerSource->SetValue(triggerSource));
+                ThrowOnFailure(lAquisitionMode->SetValue(acquisitionMode));
+            }
+        }else{
+            pango_print_error("Bad values for trigger options.");
+        }
+    }
+}
+
+template<typename T>
+T PleoraVideo::DeviceParam(const char* name)
+{
+    return GetParam<T>(lDeviceParams, name);
+}
+
+template<typename T>
+bool PleoraVideo::SetDeviceParam(const char* name, T val)
+{
+    return SetParam<T>(lDeviceParams, name, val);
+}
+
+template<typename T>
+T PleoraVideo::StreamParam(const char* name)
+{
+    return GetParam<T>(lStreamParams, name);
+}
+
+template<typename T>
+bool PleoraVideo::SetStreamParam(const char* name, T val)
+{
+    return SetParam<T>(lStreamParams, name, val);
+}
+
+PANGOLIN_REGISTER_FACTORY(PleoraVideo)
+{
+    struct PleoraVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"pleora",10}, {"u3v",10}};
+        }
+        const char* Description() const override
+        {
+            return "Uses Pleora EBusSDK to open u3v camera.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"*","Enumerates arguments dynamically from camera. Use native u3v properties."}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            return std::unique_ptr<VideoInterface>(new PleoraVideo(uri));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<PleoraVideoFactory>());
+}
+
+}
+
+#undef TSTART
+#undef TGRABANDPRINT
+#undef DBGPRINT

third-party/DPVO/Pangolin/components/pango_video/src/drivers/realsense.cpp

@@ -0,0 +1,115 @@
+#include <librealsense/rs.hpp>
+#include <pangolin/video/drivers/realsense.h>
+#include <pangolin/factory/factory_registry.h>
+
+namespace pangolin {
+
+RealSenseVideo::RealSenseVideo(ImageDim dim, int fps) 
+  : dim_(dim), fps_(fps) {
+  ctx_ = new rs::context();
+  sizeBytes = 0;
+  for (int32_t i=0; i<ctx_->get_device_count(); ++i) {
+    devs_.push_back(ctx_->get_device(i));
+
+    devs_[i]->enable_stream(rs::stream::depth, dim_.x, dim_.y, rs::format::z16, fps_);
+    StreamInfo streamD(PixelFormatFromString("GRAY16LE"), dim_.x, dim_.y, dim_.x*2, 0);
+    streams.push_back(streamD);
+
+    sizeBytes += streamD.SizeBytes();
+    devs_[i]->enable_stream(rs::stream::color, dim_.x, dim_.y, rs::format::rgb8, fps_);
+    StreamInfo streamRGB(PixelFormatFromString("RGB24"), dim_.x, dim_.y, dim_.x*3, (uint8_t*)0+sizeBytes);
+    streams.push_back(streamRGB);
+    sizeBytes += streamRGB.SizeBytes();
+
+    devs_[i]->start();
+  }
+  total_frames = std::numeric_limits<int>::max();
+}
+
+RealSenseVideo::~RealSenseVideo() {
+  delete ctx_;
+}
+
+void RealSenseVideo::Start() {
+  for (int32_t i=0; i<ctx_->get_device_count(); ++i) {
+    devs_[i]->stop();
+    devs_[i]->start();
+  }
+  current_frame_index = 0;
+}
+
+void RealSenseVideo::Stop() {
+  for (int32_t i=0; i<ctx_->get_device_count(); ++i) {
+    devs_[i]->stop();
+  }
+}
+
+size_t RealSenseVideo::SizeBytes() const {
+  return sizeBytes;
+}
+
+const std::vector<StreamInfo>& RealSenseVideo::Streams() const {
+  return streams;
+}
+
+bool RealSenseVideo::GrabNext(unsigned char* image, bool wait) {
+
+  unsigned char* out_img = image;
+  for (int32_t i=0; i<ctx_->get_device_count(); ++i) {
+    if (wait) {
+      devs_[i]->wait_for_frames();
+    }
+    memcpy(out_img, devs_[i]->get_frame_data(rs::stream::depth), streams[i*2].SizeBytes());
+    out_img += streams[i*2].SizeBytes();
+    memcpy(out_img, devs_[i]->get_frame_data(rs::stream::color), streams[i*2+1].SizeBytes());
+    out_img += streams[i*2+1].SizeBytes();
+  }
+  return true;
+}
+
+bool RealSenseVideo::GrabNewest(unsigned char* image, bool wait) {
+  return GrabNext(image, wait);
+}
+
+size_t RealSenseVideo::GetCurrentFrameId() const {
+  return current_frame_index;
+}
+
+size_t RealSenseVideo::GetTotalFrames() const {
+  return total_frames;
+}
+
+size_t RealSenseVideo::Seek(size_t frameid) {
+  // TODO
+  return -1;
+}
+
+PANGOLIN_REGISTER_FACTORY(RealSenseVideo)
+{
+    struct RealSenseVideoFactory : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"realsense1",10}, {"realsense",20}};
+        }
+        const char* Description() const override
+        {
+            return "Stream from RealSense devices.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","30","Frames per second"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const unsigned int fps = uri.Get<unsigned int>("fps", 30);
+            return std::unique_ptr<VideoInterface>( new RealSenseVideo(dim, fps) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<RealSenseVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/realsense2.cpp

@@ -0,0 +1,129 @@
+#include <librealsense2/rs.hpp>
+#include <pangolin/video/drivers/realsense2.h>
+#include <pangolin/factory/factory_registry.h>
+
+namespace pangolin {
+
+RealSense2Video::RealSense2Video(ImageDim dim, int fps)
+    : dim_(dim), fps_(fps) {
+
+    sizeBytes = 0;
+
+    // Create RealSense pipeline, encapsulating the actual device and sensors
+    pipe = new rs2::pipeline();
+
+    //Configure the pipeline
+    cfg = new rs2::config();
+
+    {   //config depth
+        cfg->enable_stream(RS2_STREAM_DEPTH, dim_.x, dim_.y, RS2_FORMAT_Z16, fps_);
+        StreamInfo streamD(PixelFormatFromString("GRAY16LE"), dim_.x, dim_.y, dim_.x*2, 0);
+        streams.push_back(streamD);
+        sizeBytes += streamD.SizeBytes();
+    }
+
+    {   //config color
+        cfg->enable_stream(RS2_STREAM_COLOR, dim_.x, dim_.y, RS2_FORMAT_RGB8, fps_);
+        StreamInfo streamRGB(PixelFormatFromString("RGB24"), dim_.x, dim_.y, dim_.x*3, reinterpret_cast<uint8_t*>(sizeBytes));
+        streams.push_back(streamRGB);
+        sizeBytes += streamRGB.SizeBytes();
+    }
+
+    // Start streaming with default recommended configuration
+    pipe->start(*cfg);
+    rs2::pipeline_profile profile = pipe->get_active_profile();
+    auto sensor = profile.get_device().first<rs2::depth_sensor>();
+    auto scale = sensor.get_depth_scale();
+    std::cout << "Depth scale is: " << scale << std::endl;
+
+    total_frames = std::numeric_limits<int>::max();
+}
+
+RealSense2Video::~RealSense2Video() {
+    delete pipe;
+    pipe = nullptr;
+
+    delete cfg;
+    cfg = nullptr;
+}
+
+void RealSense2Video::Start() {
+    pipe->start(*cfg);
+    current_frame_index = 0;
+}
+
+void RealSense2Video::Stop() {
+    pipe->stop();
+}
+
+size_t RealSense2Video::SizeBytes() const {
+    return sizeBytes;
+}
+
+const std::vector<StreamInfo>& RealSense2Video::Streams() const {
+    return streams;
+}
+
+bool RealSense2Video::GrabNext(unsigned char* image, bool /*wait*/) {
+
+    unsigned char* out_img = image;
+
+    rs2::frameset data = pipe->wait_for_frames(); // Wait for next set of frames from the camera
+    rs2::frame depth = data.get_depth_frame(); // Get the depth data
+    rs2::frame color = data.get_color_frame(); // Get the color data
+
+    memcpy(out_img, depth.get_data(), streams[0].SizeBytes());
+    out_img += streams[0].SizeBytes();
+
+    memcpy(out_img, color.get_data(), streams[1].SizeBytes());
+    out_img += streams[1].SizeBytes();
+
+    return true;
+}
+
+bool RealSense2Video::GrabNewest(unsigned char* image, bool wait) {
+    return GrabNext(image, wait);
+}
+
+size_t RealSense2Video::GetCurrentFrameId() const {
+    return current_frame_index;
+}
+
+size_t RealSense2Video::GetTotalFrames() const {
+    return total_frames;
+}
+
+size_t RealSense2Video::Seek(size_t /*frameid*/) {
+    // TODO
+    return -1;
+}
+
+PANGOLIN_REGISTER_FACTORY(RealSense2Video)
+{
+    struct RealSense2VideoFactory : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"realsense2",10}, {"realsense",10}};
+        }
+        const char* Description() const override
+        {
+            return "Stream from RealSense devices.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","30","Frames per second"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const unsigned int fps = uri.Get<unsigned int>("fps", 30);
+            return std::unique_ptr<VideoInterface>( new RealSense2Video(dim, fps) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<RealSense2VideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/shared_memory.cpp

@@ -0,0 +1,114 @@
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/drivers/shared_memory.h>
+#include <pangolin/video/iostream_operators.h>
+
+using namespace std;
+
+namespace pangolin
+{
+
+SharedMemoryVideo::SharedMemoryVideo(size_t w, size_t h, std::string pix_fmt,
+    const std::shared_ptr<SharedMemoryBufferInterface>& shared_memory,
+    const std::shared_ptr<ConditionVariableInterface>& buffer_full) :
+    _fmt(PixelFormatFromString(pix_fmt)),
+    _frame_size(w*h*_fmt.bpp/8),
+    _shared_memory(shared_memory),
+    _buffer_full(buffer_full)
+{
+    const size_t pitch = w * _fmt.bpp/8;
+    const StreamInfo stream(_fmt, w, h, pitch, 0);
+    _streams.push_back(stream);
+}
+
+SharedMemoryVideo::~SharedMemoryVideo()
+{
+}
+
+void SharedMemoryVideo::Start()
+{
+}
+
+void SharedMemoryVideo::Stop()
+{
+}
+
+size_t SharedMemoryVideo::SizeBytes() const
+{
+    return _frame_size;
+}
+
+const std::vector<StreamInfo>& SharedMemoryVideo::Streams() const
+{
+    return _streams;
+}
+
+bool SharedMemoryVideo::GrabNext(unsigned char* image, bool wait)
+{
+    // If a condition variable exists, try waiting on it.
+    if(_buffer_full) {
+        timespec ts;
+        clock_gettime(CLOCK_REALTIME, &ts);
+
+        if (wait) {
+            _buffer_full->wait();
+        } else if (!_buffer_full->wait(ts)) {
+            return false;
+        }
+    }
+
+    // Read the buffer.
+    _shared_memory->lock();
+    memcpy(image, _shared_memory->ptr(), _frame_size);
+    _shared_memory->unlock();
+
+    return true;
+}
+
+bool SharedMemoryVideo::GrabNewest(unsigned char* image, bool wait)
+{
+    return GrabNext(image,wait);
+}
+
+PANGOLIN_REGISTER_FACTORY(SharedMemoryVideo)
+{
+    struct SharedMemoryVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"shmem",10}};
+        }
+        const char* Description() const override
+        {
+            return "Stream from posix shared memory";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","RGB24","Pixel format: see pixel format help for all possible values"},
+                {"size","640x480","Image dimension"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(0, 0));
+            const std::string sfmt = uri.Get<std::string>("fmt", "GRAY8");
+            const PixelFormat fmt = PixelFormatFromString(sfmt);
+            const std::string shmem_name = std::string("/") + uri.url;
+            std::shared_ptr<SharedMemoryBufferInterface> shmem_buffer =
+                open_named_shared_memory_buffer(shmem_name, true);
+            if (dim.x == 0 || dim.y == 0 || !shmem_buffer) {
+                throw VideoException("invalid shared memory parameters");
+            }
+
+            const std::string cond_name = shmem_name + "_cond";
+            std::shared_ptr<ConditionVariableInterface> buffer_full =
+                open_named_condition_variable(cond_name);
+
+            return std::unique_ptr<VideoInterface>(
+                new SharedMemoryVideo(dim.x, dim.y, fmt, shmem_buffer,buffer_full)
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<SharedMemoryVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/shift.cpp

@@ -0,0 +1,253 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/shift.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+namespace pangolin
+{
+
+ShiftVideo::ShiftVideo(std::unique_ptr<VideoInterface>& src_,
+                       const std::map<size_t, int>& shift_right_bits,
+                       const std::map<size_t, uint32_t>& masks)
+    : src(std::move(src_)), size_bytes(0), shift_right_bits(shift_right_bits), masks(masks)
+{
+    if(!src) {
+        throw VideoException("ShiftVideo: VideoInterface in must not be null");
+    }
+
+    videoin.push_back(src.get());
+
+    formats_supported.insert("GRAY16LE");
+    formats_supported.insert("RGB48");
+    formats_supported.insert("BGR48");
+    formats_supported.insert("RGBA64");
+    formats_supported.insert("BGRA64");
+
+    for(size_t s=0; s< src->Streams().size(); ++s) {
+        const size_t w = src->Streams()[s].Width();
+        const size_t h = src->Streams()[s].Height();
+
+        auto i = shift_right_bits.find(s);
+
+        if(i != shift_right_bits.end() && i->second != 0)
+        {
+            if(formats_supported.count(src->Streams()[s].PixFormat().format) == 0)
+            {
+                throw VideoException("ShiftVideo: input format is not compatible for shifting.");
+            }
+
+            PixelFormat out_fmt;
+
+            if(src->Streams()[s].PixFormat().format == "GRAY16LE")
+            {
+                out_fmt = PixelFormatFromString("GRAY8");
+            }
+            else if(src->Streams()[s].PixFormat().format == "RGB48")
+            {
+                out_fmt = PixelFormatFromString("RGB24");
+            }
+            else if(src->Streams()[s].PixFormat().format == "BGR48")
+            {
+                out_fmt = PixelFormatFromString("BGR24");
+            }
+            else if(src->Streams()[s].PixFormat().format == "RGBA64")
+            {
+                out_fmt = PixelFormatFromString("RGBA32");
+            }
+            else if(src->Streams()[s].PixFormat().format == "BGRA64")
+            {
+                out_fmt = PixelFormatFromString("BGRA32");
+            }
+
+            streams.push_back(pangolin::StreamInfo(out_fmt, w, h, w*out_fmt.bpp / 8, reinterpret_cast<uint8_t*>(size_bytes) ));
+        }
+        else
+        {
+            streams.push_back(pangolin::StreamInfo(src->Streams()[s].PixFormat(), w, h, w*src->Streams()[s].PixFormat().bpp / 8, reinterpret_cast<uint8_t*>(size_bytes) ));
+        }
+
+        size_bytes += streams.back().SizeBytes();
+    }
+
+    buffer.reset(new uint8_t[src->SizeBytes()]);
+}
+
+ShiftVideo::~ShiftVideo()
+{
+}
+
+//! Implement VideoInput::Start()
+void ShiftVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+//! Implement VideoInput::Stop()
+void ShiftVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t ShiftVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& ShiftVideo::Streams() const
+{
+    return streams;
+}
+
+void DoShift16to8(
+    Image<uint8_t>& out,
+    const Image<uint8_t>& in,
+    const int shift_right_bits,
+    const uint32_t mask,
+    const uint16_t maxValBitDepth
+) {
+    for(size_t r = 0; r < out.h; ++r)
+    {
+        uint8_t* pout = (uint8_t*)(out.ptr + r*out.pitch);
+        uint16_t* pin = (uint16_t*)(in.ptr + r*in.pitch);
+        const uint16_t* pin_end = (uint16_t*)(in.ptr + (r+1)*in.pitch);
+        while(pin != pin_end) {
+            *(pout++) = (std::min(*(pin++), maxValBitDepth) >> shift_right_bits) & mask;
+        }
+    }
+}
+
+void ShiftVideo::Process(uint8_t* buffer_out, const uint8_t* buffer_in)
+{
+    for(size_t s=0; s<streams.size(); ++s) {
+        const Image<uint8_t> img_in  = videoin[0]->Streams()[s].StreamImage(buffer_in);
+        Image<uint8_t> img_out = Streams()[s].StreamImage(buffer_out);
+        const size_t bytes_per_pixel = Streams()[s].PixFormat().bpp / 8;
+
+        auto i = shift_right_bits.find(s);
+
+        if(i != shift_right_bits.end() && i->second != 0)
+        {
+            auto m = masks.find(s);
+            DoShift16to8(img_out, img_in, i->second, (m == masks.end() ? 0xffff : m->second), std::pow(2, videoin[0]->Streams()[s].PixFormat().channel_bit_depth) - 1);
+        }
+        else
+        {
+            //straight copy
+            if( img_out.w != img_in.w || img_out.h != img_in.h ) {
+                throw std::runtime_error("ShiftVideo: Incompatible image sizes");
+            }
+
+            for(size_t y=0; y < img_out.h; ++y) {
+                std::memcpy(img_out.RowPtr((int)y), img_in.RowPtr((int)y), bytes_per_pixel * img_in.w);
+            }
+        }
+    }
+}
+
+//! Implement VideoInput::GrabNext()
+bool ShiftVideo::GrabNext( uint8_t* image, bool wait )
+{
+    if(videoin[0]->GrabNext(buffer.get(),wait)) {
+        Process(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool ShiftVideo::GrabNewest( uint8_t* image, bool wait )
+{
+    if(videoin[0]->GrabNewest(buffer.get(),wait)) {
+        Process(image, buffer.get());
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& ShiftVideo::InputStreams()
+{
+    return videoin;
+}
+
+PANGOLIN_REGISTER_FACTORY(ShiftVideo)
+{
+    struct ShiftVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"shift",10}};
+        }
+        const char* Description() const override
+        {
+            return "Video Filter: bitwise shift pixel values.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"shift\\d+","0","shiftN, N:[1,streams]. Right shift pixel values."},
+                {"mask\\d+","65535","maskN, N:[1,streams]. Bitwise pixel mask (after shift)"},
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::map<size_t, int> shift_right_bits;
+            std::map<size_t, uint32_t> masks;
+
+            ParamReader reader(Params(), uri);
+
+            for(size_t i=0; i<100; ++i)
+            {
+                const std::string shift_key = pangolin::FormatString("shift%",i+1);
+                const std::string mask_key = pangolin::FormatString("mask%",i+1);
+
+                if(reader.Contains(shift_key))
+                {
+                    shift_right_bits[i] = reader.Get<int>(shift_key);
+                }
+
+                if(reader.Contains(mask_key))
+                {
+                    masks[i] = reader.Get<int>(mask_key);
+                }
+            }
+
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            return std::unique_ptr<VideoInterface>(
+                new ShiftVideo(subvid, shift_right_bits, masks)
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<ShiftVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/split.cpp

@@ -0,0 +1,180 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/split.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+#include <exception>
+
+namespace pangolin
+{
+
+SplitVideo::SplitVideo(std::unique_ptr<VideoInterface> &src_, const std::vector<StreamInfo>& streams)
+    : src(std::move(src_)), streams(streams)
+{
+    videoin.push_back(src.get());
+
+    // Warn if stream over-runs input stream
+    for(unsigned int i=0; i < streams.size(); ++i) {
+        if(src->SizeBytes() < (size_t)streams[i].Offset() + streams[i].SizeBytes() ) {
+            pango_print_warn("VideoSplitter: stream extends past end of input.\n");
+            break;
+        }
+    }
+}
+
+SplitVideo::~SplitVideo()
+{
+}
+
+size_t SplitVideo::SizeBytes() const
+{
+    return videoin[0]->SizeBytes();
+}
+
+const std::vector<StreamInfo>& SplitVideo::Streams() const
+{
+    return streams;
+}
+
+void SplitVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+void SplitVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+bool SplitVideo::GrabNext( unsigned char* image, bool wait )
+{
+    return videoin[0]->GrabNext(image, wait);
+}
+
+bool SplitVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return videoin[0]->GrabNewest(image, wait);
+}
+
+std::vector<VideoInterface*>& SplitVideo::InputStreams()
+{
+    return videoin;
+}
+
+PANGOLIN_REGISTER_FACTORY(SplitVideo)
+{
+    struct SplitVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"split",10}};
+        }
+        const char* Description() const override
+        {
+            return "Transforms a set of video streams into a new set by providing region-of-interest, raw memory layout, or stream order specification.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"roi\\d+","X+Y+WxH","Region of Interest as WidthxHeight"},
+                {"mem\\d+","width,height,pitch,pixelformat*","By default dynamically set from the first stream"},
+                {"stream\\d+","0","Integer"}
+            }};
+        }
+
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::vector<StreamInfo> streams;
+
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            if(subvid->Streams().size() == 0) {
+                throw VideoException("VideoSplitter input must have at least one stream");
+            }
+
+            ParamReader param_reader(Params(), uri);
+
+            while(true) {
+                const size_t n = streams.size() + 1;
+                std::string key_roi = std::string("roi") + pangolin::Convert<std::string, size_t>::Do(n);
+                std::string key_mem = std::string("mem") + pangolin::Convert<std::string, size_t>::Do(n);
+                std::string key_str = std::string("stream") + pangolin::Convert<std::string, size_t>::Do(n);
+
+                if(uri.Contains(key_roi)) {
+                    const StreamInfo& st1 = subvid->Streams()[0];
+                    const ImageRoi& roi = param_reader.Get<ImageRoi>(key_roi, ImageRoi());
+                    if(roi.w == 0 || roi.h == 0) {
+                        throw VideoException("split: empty ROI.");
+                    }
+                    const size_t start1 = roi.y * st1.Pitch() + st1.PixFormat().bpp * roi.x / 8;
+                    streams.push_back( StreamInfo( st1.PixFormat(), roi.w, roi.h, st1.Pitch(), reinterpret_cast<unsigned char*>(start1) ) );
+                }else if(uri.Contains(key_mem)) {
+                    const StreamInfo& info = param_reader.Get(key_mem, subvid->Streams()[0]); //uri.Get<StreamInfo>(key_mem, subvid->Streams()[0] );
+                    streams.push_back(info);
+                }else if(uri.Contains(key_str)) {
+                    const size_t old_stream = param_reader.Get<size_t>(key_str) - 1; //uri.Get<size_t>(key_str, 0) -1;
+                    if(old_stream >= subvid->Streams().size()) {
+                        throw VideoException("split: requesting source stream which does not exist.");
+                    }
+                    streams.push_back(subvid->Streams()[old_stream]);
+                }else{
+                    break;
+                }
+            }
+
+            // Default split if no arguments
+            if(streams.size() == 0) {
+                const StreamInfo& st1 = subvid->Streams()[0];
+                const size_t subw = st1.Width();
+                const size_t subh = st1.Height();
+
+                ImageRoi roi1, roi2;
+
+                if(subw > subh) {
+                    // split horizontally
+                    roi1 = ImageRoi(0,0, subw/2, subh );
+                    roi2 = ImageRoi(subw/2,0, subw/2, subh );
+                }else{
+                    // split vertically
+                    roi1 = ImageRoi(0,0, subw, subh/2 );
+                    roi2 = ImageRoi(0,subh/2, subw, subh/2 );
+                }
+
+                const size_t start1 = roi1.y * st1.Pitch() + st1.PixFormat().bpp * roi1.x / 8;
+                const size_t start2 = roi2.y * st1.Pitch() + st1.PixFormat().bpp * roi2.x / 8;
+                streams.push_back( StreamInfo( st1.PixFormat(), roi1.w, roi1.h, st1.Pitch(), (unsigned char*)(start1) ) );
+                streams.push_back( StreamInfo( st1.PixFormat(), roi2.w, roi2.h, st1.Pitch(), (unsigned char*)(start2) ) );
+            }
+
+            return std::unique_ptr<VideoInterface>( new SplitVideo(subvid,streams) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<SplitVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/teli.cpp

@@ -0,0 +1,563 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <XmlFeatures.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/drivers/teli.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace pangolin
+{
+
+// Represet lifetime of Teli SDK. Destructed by static deinitialisation.
+class TeliSystem
+{
+public:
+    static TeliSystem& Instance() {
+        static TeliSystem sys;
+        return sys;
+    }
+
+private:
+    TeliSystem()
+    {
+        Teli::CAM_API_STATUS uiStatus = Teli::Sys_Initialize();
+        if (uiStatus != Teli::CAM_API_STS_SUCCESS && uiStatus != Teli::CAM_API_STS_ALREADY_INITIALIZED) {
+            throw pangolin::VideoException(FormatString("Unable to initialise TeliSDK (%).", uiStatus));
+          }
+    }
+
+    ~TeliSystem()
+    {
+        Teli::CAM_API_STATUS uiStatus = Teli::Sys_Terminate();
+        if (uiStatus != Teli::CAM_API_STS_SUCCESS) {
+            pango_print_warn("TeliSDK: Error uninitialising.");
+        }
+    }
+};
+
+std::string GetNodeValStr(Teli::CAM_HANDLE cam, Teli::CAM_NODE_HANDLE node, std::string node_str)
+{
+    Teli::TC_NODE_TYPE node_type;
+    Teli::CAM_API_STATUS st = Teli::Nd_GetType(cam, node, &node_type);
+    if(st != Teli::CAM_API_STS_SUCCESS) {
+        throw std::runtime_error("TeliSDK: Unable to get Teli node type.");
+    }
+
+    Teli::CAM_API_STATUS status;
+
+    switch(node_type) {
+    case Teli::TC_NODE_TYPE_INTEGER:
+    {
+        int64_t val;
+        status = Teli::Nd_GetIntValue(cam, node, &val);
+        if(status == Teli::CAM_API_STS_SUCCESS) {
+            return pangolin::Convert<std::string, int64_t>::Do(val);
+        }
+        break;
+    }
+    case Teli::TC_NODE_TYPE_BOOLEAN:
+    {
+        bool8_t val;
+        status = Teli::Nd_GetBoolValue(cam, node, &val);
+        if(status == Teli::CAM_API_STS_SUCCESS) {
+            return pangolin::Convert<std::string, bool8_t>::Do(val);
+        }
+        break;
+    }
+    case Teli::TC_NODE_TYPE_FLOAT:
+    {
+        float64_t val;
+        status = Teli::Nd_GetFloatValue(cam, node, &val);
+        if(status == Teli::CAM_API_STS_SUCCESS) {
+            return pangolin::Convert<std::string, float64_t>::Do(val);
+        }
+        break;
+    }
+    case Teli::TC_NODE_TYPE_STRING:
+    {
+        uint32_t buffer_size = 10*1024;
+        char* buffer = new char[buffer_size];
+        status = Teli::Nd_GetStrValue(cam, node, buffer, &buffer_size);
+        std::string val(buffer);
+        delete[] buffer;
+        if(status == Teli::CAM_API_STS_SUCCESS) {
+            return val;
+        }
+        break;
+    }
+    case Teli::TC_NODE_TYPE_ENUMERATION:
+    {
+        uint32_t buffer_size = 10*1024;
+        char* buffer = new char[buffer_size];
+        status = Teli::Nd_GetEnumStrValue(cam, node, buffer, &buffer_size);
+        std::string val(buffer);
+        if(status == Teli::CAM_API_STS_SUCCESS) {
+            return val;
+        }
+        break;
+    }
+    case Teli::TC_NODE_TYPE_COMMAND:
+    case Teli::TC_NODE_TYPE_REGISTER:
+    case Teli::TC_NODE_TYPE_CATEGORY:
+    case Teli::TC_NODE_TYPE_ENUM_ENTRY:
+    case Teli::TC_NODE_TYPE_PORT:
+    default:
+        throw VideoException(FormatString("TeliSDK: Unsupported node_type: %", node_type));
+    }
+
+    if(status != Teli::CAM_API_STS_SUCCESS) {
+        Teli::CAM_GENICAM_ERR_MSG psErrMsg;
+        Teli::Misc_GetLastGenICamError(&psErrMsg);
+        throw VideoException("TeliSDK: Unable to get Teli parameter, " + node_str, psErrMsg.pszDescription);
+    }else{
+        throw VideoException("TeliSDK: Unable to get Teli parameter, " + node_str);
+    }
+}
+
+void TeliVideo::SetNodeValStr(Teli::CAM_HANDLE cam, Teli::CAM_NODE_HANDLE node, std::string node_str, std::string val_str)
+{
+    Teli::TC_NODE_TYPE node_type;
+    Teli::CAM_API_STATUS st = Teli::Nd_GetType(cam, node, &node_type);
+    if(st != Teli::CAM_API_STS_SUCCESS) {
+        throw VideoException("TeliSDK: Unable to get Teli node type.");
+    }
+
+    Teli::CAM_API_STATUS status = Teli::CAM_API_STS_SUCCESS;
+
+    switch(node_type) {
+    case Teli::TC_NODE_TYPE_INTEGER:
+    {
+        const int64_t val = pangolin::Convert<int64_t, std::string>::Do(val_str);
+        status = Teli::Nd_SetIntValue(cam, node, val);
+        break;
+    }
+    case Teli::TC_NODE_TYPE_BOOLEAN:
+    {
+        const bool8_t val = pangolin::Convert<bool8_t, std::string>::Do(val_str);
+        status = Teli::Nd_SetBoolValue(cam, node, val);
+        break;
+    }
+    case Teli::TC_NODE_TYPE_FLOAT:
+    {
+        const float64_t val = pangolin::Convert<float64_t, std::string>::Do(val_str);
+        status = Teli::Nd_SetFloatValue(cam, node, val);
+        break;
+    }
+    case Teli::TC_NODE_TYPE_STRING:
+    {
+        status = Teli::Nd_SetStrValue(cam, node, val_str.c_str());
+        break;
+    }
+    case Teli::TC_NODE_TYPE_ENUMERATION:
+    {
+        status = Teli::Nd_SetEnumStrValue(cam, node, val_str.c_str());
+        break;
+    }
+    case Teli::TC_NODE_TYPE_COMMAND:
+    {
+        status = Teli::Nd_CmdExecute(cam, node, true);
+
+        if (status != Teli::CAM_API_STS_SUCCESS) {
+            pango_print_error("TeliVideo: Nd_CmdExecute returned error, %u", status);
+            break;
+        }
+
+        // Confirm command is successful
+        bool done = false;
+        for(int attempts=20; attempts > 0; --attempts) {
+            // Confirm whether the execution has been accomplished.
+            status = Teli::Nd_GetCmdIsDone(cam, node, &done);
+            if (status != Teli::CAM_API_STS_SUCCESS) {
+                pango_print_error("TeliVideo: Nd_GetCmdIsDone returned error, %u", status);
+                break;
+            }
+            if(done) break;
+        }
+
+        pango_print_error("Timeout while waiting for command %s done\n", node_str.c_str());
+        break;
+    }
+    case Teli::TC_NODE_TYPE_REGISTER:
+    case Teli::TC_NODE_TYPE_CATEGORY:
+    case Teli::TC_NODE_TYPE_ENUM_ENTRY:
+    case Teli::TC_NODE_TYPE_PORT:
+    default:
+        throw VideoException("TeliSDK: Unsupported node_type: " + node_type);
+    }
+
+    if(status != Teli::CAM_API_STS_SUCCESS) {
+        Teli::CAM_GENICAM_ERR_MSG psErrMsg;
+        Teli::Misc_GetLastGenICamError(&psErrMsg);
+        throw VideoException("TeliSDK: Unable to set Teli parameter, " + node_str, psErrMsg.pszDescription);
+    }
+}
+
+TeliVideo::TeliVideo(const Params& p)
+    : cam(0), strm(0), hStrmCmpEvt(0), transfer_bandwidth_gbps(0), exposure_us(0)
+{
+    TeliSystem::Instance();
+
+    uint32_t num_cams = 0;
+    Teli::CAM_API_STATUS uiStatus = Teli::Sys_GetNumOfCameras(&num_cams);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("Unable to enumerate TeliSDK cameras.");
+
+    if (num_cams == 0)
+        throw pangolin::VideoException("No TeliSDK Cameras available.");
+
+    // Default to rogue values
+    std::string sn;
+    std::string mn;
+    int cam_index = 0;
+
+    Params device_params;
+
+    for(Params::ParamMap::const_iterator it = p.params.begin(); it != p.params.end(); it++) {
+        if(it->first == "model"){
+            mn = it->second;
+        } else if(it->first == "sn"){
+            sn = it->second;
+        } else if(it->first == "idx"){
+            cam_index = p.Get<int>("idx", 0);
+        } else if(it->first == "size") {
+            const ImageDim dim = p.Get<ImageDim>("size", ImageDim(0,0) );
+            device_params.Set("Width"  , dim.x);
+            device_params.Set("Height" , dim.y);
+        } else if(it->first == "pos") {
+            const ImageDim pos = p.Get<ImageDim>("pos", ImageDim(0,0) );
+            device_params.Set("OffsetX"  , pos.x);
+            device_params.Set("OffsetY" , pos.y);
+        } else if(it->first == "roi") {
+            const ImageRoi roi = p.Get<ImageRoi>("roi", ImageRoi(0,0,0,0) );
+            device_params.Set("Width"  , roi.w);
+            device_params.Set("Height" , roi.h);
+            device_params.Set("OffsetX", roi.x);
+            device_params.Set("OffsetY", roi.y);
+        } else {
+            device_params.Set(it->first, it->second);
+        }
+    }
+
+    if(sn.empty() && mn.empty()) {
+        uiStatus = Teli::Cam_Open(cam_index, &cam, 0, true, 0);
+    }else{
+        uiStatus = Teli::Cam_OpenFromInfo(
+            (sn.empty() ? 0 : sn.c_str()),
+            (mn.empty() ? 0 : mn.c_str()),
+            0, &cam, 0, true, 0
+        );
+    }
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException(FormatString("TeliSDK: Error opening camera, sn='%'", sn));
+
+    SetDeviceParams(device_params);
+    Initialise();
+}
+
+ bool TeliVideo::GetParameter(const std::string& name, std::string& result)
+{
+    Teli::CAM_NODE_HANDLE node;
+    Teli::CAM_API_STATUS st = Teli::Nd_GetNode(cam, name.c_str(), &node);
+    if( st == Teli::CAM_API_STS_SUCCESS) {
+        result = GetNodeValStr(cam, node, name);
+        return true;
+    }else{
+        pango_print_warn("TeliSDK: Unable to get reference to node: %s", name.c_str());
+        return false;
+    }
+}
+
+bool TeliVideo::SetParameter(const std::string& name, const std::string& value)
+{
+    Teli::CAM_NODE_HANDLE node;
+    Teli::CAM_API_STATUS st = Teli::Nd_GetNode(cam, name.c_str(), &node);
+    if( st == Teli::CAM_API_STS_SUCCESS) {
+        SetNodeValStr(cam, node, name, value);
+        return true;
+    }else{
+        pango_print_warn("TeliSDK: Unable to get reference to node: %s", name.c_str());
+        return false;
+    }
+}
+
+void TeliVideo::Initialise()
+{
+    Teli::CAM_API_STATUS uiStatus = Teli::CAM_API_STS_SUCCESS;
+
+    // Create completion event object for stream.
+#ifdef _WIN_
+    hStrmCmpEvt = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if (hStrmCmpEvt == NULL)
+        throw pangolin::VideoException("TeliSDK: Error creating event.");
+#endif
+#ifdef _LINUX_
+    uiStatus = Teli::Sys_CreateSignal(&hStrmCmpEvt);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error creating event.");
+#endif
+    uint32_t uiPyldSize = 0;
+    uiStatus = Teli::Strm_OpenSimple(cam, &strm, &uiPyldSize, hStrmCmpEvt);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error opening camera stream.");
+
+    // Read pixel format
+    PixelFormat pfmt;
+    Teli::CAM_PIXEL_FORMAT teli_fmt;
+    uiStatus = Teli::GetCamPixelFormat(cam, &teli_fmt);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error calling GetCamPixelFormat.");
+
+    switch( teli_fmt) {
+    case Teli::PXL_FMT_Mono8:
+    case Teli::PXL_FMT_BayerGR8:
+    case Teli::PXL_FMT_BayerBG8:
+        pfmt = pangolin::PixelFormatFromString("GRAY8");
+        break;
+    case Teli::PXL_FMT_Mono10:
+    case Teli::PXL_FMT_Mono12:
+    case Teli::PXL_FMT_Mono16:
+    case Teli::PXL_FMT_BayerGR10:
+    case Teli::PXL_FMT_BayerGR12:
+    case Teli::PXL_FMT_BayerBG10:
+    case Teli::PXL_FMT_BayerBG12:
+        pfmt = pangolin::PixelFormatFromString("GRAY16LE");
+        break;
+    case Teli::PXL_FMT_RGB8:
+        pfmt = pangolin::PixelFormatFromString("RGB24");
+        break;
+    case Teli::PXL_FMT_BGR8:
+        pfmt = pangolin::PixelFormatFromString("BGR24");
+        break;
+    default:
+        throw std::runtime_error("TeliSDK: Unknown pixel format: " + ToString<int>(teli_fmt) );
+    }
+
+    size_bytes = 0;
+
+    // Use width and height reported by camera
+    uint32_t w = 0;
+    uint32_t h = 0;
+    if( Teli::GetCamWidth(cam, &w) != Teli::CAM_API_STS_SUCCESS || Teli::GetCamHeight(cam, &h) != Teli::CAM_API_STS_SUCCESS) {
+        throw pangolin::VideoException("TeliSDK: Unable to establish stream dimensions.");
+    }
+
+    const int n = 1;
+    for(size_t c=0; c < n; ++c) {
+        const StreamInfo stream_info(pfmt, w, h, (w*pfmt.bpp) / 8, 0);
+        streams.push_back(stream_info);
+        size_bytes += uiPyldSize;
+    }
+
+    InitPangoDeviceProperties();
+}
+
+void TeliVideo::InitPangoDeviceProperties()
+{
+
+    Teli::CAM_INFO info;
+    Teli::Cam_GetInformation(cam, 0, &info);
+
+    // Store camera details in device properties
+    device_properties["SerialNumber"] = std::string(info.szSerialNumber);
+    device_properties["VendorName"] = std::string(info.szManufacturer);
+    device_properties["ModelName"] = std::string(info.szModelName);
+    device_properties["ManufacturerInfo"] = std::string(info.sU3vCamInfo.szManufacturerInfo);
+    device_properties["Version"] = std::string(info.sU3vCamInfo.szDeviceVersion);
+    device_properties[PANGO_HAS_TIMING_DATA] = true;
+
+    // TODO: Enumerate other settings.
+}
+
+void TeliVideo::SetDeviceParams(const Params& p)
+{
+    for(Params::ParamMap::const_iterator it = p.params.begin(); it != p.params.end(); it++) {
+        if(it->first == "transfer_bandwidth_gbps") {
+            transfer_bandwidth_gbps = atof(it->second.c_str());
+        } else {
+        try{
+            if (it->second == "Execute") {
+                //
+                std::runtime_error("TeliSDK: Execution commands not yet supported.");
+            } else {
+                SetParameter(it->first, it->second);
+            }
+        }catch(std::exception& e) {
+            std::cerr << e.what() << std::endl;
+        }
+        }
+    }
+}
+
+TeliVideo::~TeliVideo()
+{
+    Teli::CAM_API_STATUS uiStatus = Teli::Strm_Close(strm);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        pango_print_warn("TeliSDK: Error closing camera stream.");
+
+    uiStatus = Teli::Cam_Close(cam);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        pango_print_warn("TeliSDK: Error closing camera.");
+}
+
+//! Implement VideoInput::Start()
+void TeliVideo::Start()
+{
+    Teli::CAM_API_STATUS uiStatus = Teli::Strm_Start(strm);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error starting stream.");
+}
+
+//! Implement VideoInput::Stop()
+void TeliVideo::Stop()
+{
+    Teli::CAM_API_STATUS uiStatus = Teli::Strm_Stop(strm);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error stopping stream.");
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t TeliVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& TeliVideo::Streams() const
+{
+    return streams;
+}
+
+void TeliVideo::PopulateEstimatedCenterCaptureTime(basetime host_reception_time)
+{
+    if(transfer_bandwidth_gbps) {
+        const float transfer_time_us = size_bytes / int64_t((transfer_bandwidth_gbps * 1E3) / 8.0);
+        frame_properties[PANGO_ESTIMATED_CENTER_CAPTURE_TIME_US] = picojson::value(int64_t(pangolin::Time_us(host_reception_time) -  (exposure_us/2.0) - transfer_time_us));
+    }
+}
+
+bool TeliVideo::GrabNext(unsigned char* image, bool /*wait*/)
+{
+#ifdef _WIN_
+    unsigned int uiRet = WaitForSingleObject(hStrmCmpEvt, 2000);
+    if (uiRet == WAIT_OBJECT_0) {
+#endif
+#ifdef _LINUX_
+    unsigned int uiRet = Teli::Sys_WaitForSignal(hStrmCmpEvt, 2000);
+    if (uiRet == Teli::CAM_API_STS_SUCCESS) {
+#endif
+        Teli::CAM_IMAGE_INFO sImageInfo;
+        uint32_t uiPyldSize = (uint32_t)size_bytes;
+        Teli::CAM_API_STATUS uiStatus = Teli::Strm_ReadCurrentImage(strm, image, &uiPyldSize, &sImageInfo);
+        frame_properties[PANGO_EXPOSURE_US] = picojson::value(exposure_us);
+        frame_properties[PANGO_CAPTURE_TIME_US] = picojson::value(sImageInfo.ullTimestamp/1000);
+        basetime now = pangolin::TimeNow();
+        frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(now));
+        PopulateEstimatedCenterCaptureTime(now);
+        return (uiStatus == Teli::CAM_API_STS_SUCCESS);
+    }
+
+    return false;
+}
+
+//! Implement VideoInput::GrabNewest()
+bool TeliVideo::GrabNewest(unsigned char* image, bool wait)
+{
+    return GrabNext(image,wait);
+}
+
+//! Returns number of available frames
+uint32_t TeliVideo::AvailableFrames() const
+{
+    uint32_t puiCount = 0;
+    Teli::CAM_API_STATUS uiStatus = Teli::GetCamImageBufferFrameCount(cam, &puiCount);
+    if (uiStatus != Teli::CAM_API_STS_SUCCESS)
+        throw pangolin::VideoException("TeliSDK: Error reading frame buffer frame count.");
+    return puiCount;
+}
+
+//! Drops N frames in the queue starting from the oldest
+//! returns false if less than n frames arae available
+bool TeliVideo::DropNFrames(uint32_t n)
+{
+    for (uint32_t i=0;i<n;++i) {
+#ifdef _WIN_
+        unsigned int uiRet = WaitForSingleObject(hStrmCmpEvt, 2000);
+        if (uiRet == WAIT_OBJECT_0) {
+#endif
+#ifdef _LINUX_
+            unsigned int uiRet = Teli::Sys_WaitForSignal(hStrmCmpEvt, 2000);
+            if (uiRet == Teli::CAM_API_STS_SUCCESS) {
+#endif
+                Teli::CAM_IMAGE_INFO sImageInfo;
+                uint32_t uiPyldSize = 0 ;
+                Teli::Strm_ReadCurrentImage(strm, 0, &uiPyldSize, &sImageInfo);
+            } else {
+                return false;
+            }
+        }
+    return true;
+}
+
+//! Access JSON properties of device
+const picojson::value& TeliVideo::DeviceProperties() const
+{
+    return device_properties;
+}
+
+//! Access JSON properties of most recently captured frame
+const picojson::value& TeliVideo::FrameProperties() const
+{
+    return frame_properties;
+}
+
+PANGOLIN_REGISTER_FACTORY(TeliVideo)
+{
+    struct TeliVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"teli",10}, {"u3v",5}};
+        }
+        const char* Description() const override
+        {
+            return "Uses Toshiba TeliCam library to open u3v camera.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"*","Enumerates arguments dynamically from camera. Use native u3v properties."}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            return std::unique_ptr<VideoInterface>(new TeliVideo(uri));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<TeliVideoFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/drivers/test.cpp

@@ -0,0 +1,128 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/video/drivers/test.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace pangolin
+{
+
+void setRandomData(unsigned char * arr, size_t size){
+  for(size_t i = 0 ; i < size;i++) {
+//      arr[i] = (unsigned char)(i * 255.0 / size);
+      arr[i] = (unsigned char)(rand()/(RAND_MAX/255.0));
+  }
+}
+
+TestVideo::TestVideo(size_t w, size_t h, size_t n, std::string pix_fmt)
+{
+    const PixelFormat pfmt = PixelFormatFromString(pix_fmt);
+
+    size_bytes = 0;
+
+    for(size_t c=0; c < n; ++c) {
+        const StreamInfo stream_info(pfmt, w, h, (w*pfmt.bpp)/8, 0);
+        streams.push_back(stream_info);
+        size_bytes += w*h*(pfmt.bpp)/8;
+    }
+}
+
+TestVideo::~TestVideo()
+{
+
+}
+
+//! Implement VideoInput::Start()
+void TestVideo::Start()
+{
+
+}
+
+//! Implement VideoInput::Stop()
+void TestVideo::Stop()
+{
+
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t TestVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& TestVideo::Streams() const
+{
+    return streams;
+}
+
+//! Implement VideoInput::GrabNext()
+bool TestVideo::GrabNext( unsigned char* image, bool /*wait*/ )
+{
+    setRandomData(image, size_bytes);
+    return true;
+}
+
+//! Implement VideoInput::GrabNewest()
+bool TestVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image,wait);
+}
+
+PANGOLIN_REGISTER_FACTORY(TestVideo)
+{
+    struct TestVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"test",10}};
+        }
+        const char* Description() const override
+        {
+            return "A test video feed with pixel-wise white noise.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"n","1","Number of streams"},
+                {"fmt","RGB24","Pixel format: see pixel format help for all possible values"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(), uri);
+            const ImageDim dim = reader.Get<ImageDim>("size");
+            const int n = reader.Get<int>("n");
+            std::string fmt  = reader.Get<std::string>("fmt");
+            return std::unique_ptr<VideoInterface>(new TestVideo(dim.x,dim.y,n,fmt));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<TestVideoFactory>());
+}
+
+}