3373503aba8db07f42f956473290cf8cf3836907fbd9aa5d2d6eb20784f60c8c

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

@@ -0,0 +1,296 @@
+/* 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/video/drivers/thread.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+#ifdef DEBUGTHREAD
+  #include <pangolin/utils/timer.h>
+  #define TSTART() pangolin::basetime start,last,now; start = pangolin::TimeNow(); last = start;
+  #define TGRABANDPRINT(...)  now = pangolin::TimeNow(); fprintf(stderr,"THREAD: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr, " %fms.\n",1000*pangolin::TimeDiff_s(last, now)); last = now;
+  #define DBGPRINT(...) fprintf(stderr,"THREAD: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr,"\n");
+#else
+  #define TSTART()
+  #define TGRABANDPRINT(...)
+  #define DBGPRINT(...)
+#endif
+
+namespace pangolin
+{
+
+const uint64_t grab_fail_thread_sleep_us = 1000;
+const uint64_t capture_timout_ms = 5000;
+
+ThreadVideo::ThreadVideo(std::unique_ptr<VideoInterface> &src_, size_t num_buffers, const std::string& name)
+    : src(std::move(src_)), quit_grab_thread(true), thread_name(name)
+{
+    if(!src) {
+        throw VideoException("ThreadVideo: VideoInterface in must not be null");
+    }
+    videoin.push_back(src.get());
+
+//    // queue init allocates buffers.
+    const size_t buffer_size = videoin[0]->SizeBytes();
+    for(size_t i=0; i < num_buffers; ++i)
+    {
+        queue.returnOrAddUsedBuffer( GrabResult(buffer_size) );
+    }
+}
+
+ThreadVideo::~ThreadVideo()
+{
+    Stop();
+
+    src.reset();
+}
+
+//! Implement VideoInput::Start()
+void ThreadVideo::Start()
+{
+    // Only start thread if not already running.
+    if(quit_grab_thread) {
+        videoin[0]->Start();
+        quit_grab_thread = false;
+        grab_thread = std::thread(std::ref(*this));
+    }
+}
+
+//! Implement VideoInput::Stop()
+void ThreadVideo::Stop()
+{
+    quit_grab_thread = true;
+    if(grab_thread.joinable()) {
+        grab_thread.join();
+    }
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t ThreadVideo::SizeBytes() const
+{
+    return videoin[0]->SizeBytes();
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& ThreadVideo::Streams() const
+{
+    return videoin[0]->Streams();
+}
+
+const picojson::value& ThreadVideo::DeviceProperties() const
+{
+    device_properties = GetVideoDeviceProperties(videoin[0]);
+    return device_properties;
+}
+
+const picojson::value& ThreadVideo::FrameProperties() const
+{
+    return frame_properties;
+}
+
+uint32_t ThreadVideo::AvailableFrames() const
+{
+    return (uint32_t)queue.AvailableFrames();
+}
+
+bool ThreadVideo::DropNFrames(uint32_t n)
+{
+    return queue.DropNFrames(n);
+}
+
+//! Implement VideoInput::GrabNext()
+bool ThreadVideo::GrabNext( unsigned char* image, bool wait )
+{
+    TSTART()
+
+    if(queue.EmptyBuffers() == 0) {
+       pango_print_warn("Thread %s(%12p) has run out of %d buffers\n", thread_name.c_str(), this, (int)queue.AvailableFrames());
+    }
+
+    if(queue.AvailableFrames() == 0 && !wait) {
+        // No frames available, no wait, simply return false.
+        DBGPRINT("GrabNext no available frames no wait.");
+        return false;
+    }else{
+        if(queue.AvailableFrames() == 0 && wait) {
+            if (quit_grab_thread)
+            {
+                return false;
+            }
+            // Must return a frame so block on notification from grab thread.
+            std::unique_lock<std::mutex> lk(cvMtx);
+            DBGPRINT("GrabNext no available frames wait for notification.");
+            if(cv.wait_for(lk, std::chrono::milliseconds(capture_timout_ms)) == std::cv_status::timeout)
+            {
+                pango_print_warn("ThreadVideo: GrabNext blocking read for frames reached timeout.\n");
+                return false;
+            }
+        }
+
+        // At least one valid frame in queue, return it.
+        GrabResult grab = queue.getNext();
+        if(grab.return_status) {
+            DBGPRINT("GrabNext at least one frame available.");
+            const size_t buffer_size = videoin[0]->SizeBytes();
+            std::memcpy(image, grab.buffer.get(), buffer_size);
+            frame_properties = grab.frame_properties;
+        }else{
+            DBGPRINT("GrabNext returned false")
+        }
+        queue.returnOrAddUsedBuffer(std::move(grab));
+
+        TGRABANDPRINT("GrabNext took")
+        return grab.return_status;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool ThreadVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    TSTART()
+    if(queue.AvailableFrames() == 0 && !wait) {
+        // No frames available, no wait, simply return false.
+        DBGPRINT("GrabNext no available frames no wait.");
+        return false;
+    }else{
+        if(queue.AvailableFrames() == 0 && wait) {
+            // Must return a frame so block on notification from grab thread.
+            std::unique_lock<std::mutex> lk(cvMtx);
+            DBGPRINT("GrabNewest no available frames wait for notification.");
+            if(cv.wait_for(lk, std::chrono::milliseconds(capture_timout_ms)) == std::cv_status::timeout)
+            {
+                pango_print_warn("ThreadVideo: GrabNewest blocking read for frames reached timeout.\n");
+                return false;
+            }
+        }
+
+        // At least one valid frame in queue, return it.
+        DBGPRINT("GrabNewest at least one frame available.");
+        GrabResult grab = queue.getNewest();
+        const bool success = grab.return_status;
+        if(success) {
+            std::memcpy(image, grab.buffer.get(), videoin[0]->SizeBytes());
+            frame_properties = grab.frame_properties;
+        }
+        queue.returnOrAddUsedBuffer(std::move(grab));
+        TGRABANDPRINT("GrabNewest memcpy of available frame took")
+
+        return success;
+    }
+}
+
+void ThreadVideo::operator()()
+{
+    DBGPRINT("Grab thread Started.")
+    // Spinning thread attempting to read from videoin[0] as fast as possible
+    // relying on the videoin[0] blocking grab.
+    while(!quit_grab_thread) {
+        // Get a buffer from the queue;
+
+        if(queue.EmptyBuffers() > 0) {
+            GrabResult grab = queue.getFreeBuffer();
+
+            // Blocking grab (i.e. GrabNext with wait = true).
+            try{
+                grab.return_status = videoin[0]->GrabNext(grab.buffer.get(), true);
+            }catch(const VideoException& e) {
+                // User doesn't have the opportunity to catch exceptions here.
+                std::string what = e.what();
+                pango_print_warn("ThreadVideo caught VideoException (%s)\n",  what.c_str());
+                if (what.find("No such device") != std::string::npos) {
+                  pango_print_warn("Device is gone, exiting thread.\n");
+                  quit_grab_thread = true;
+                }
+                grab.return_status = false;
+            }catch(const std::exception& e){
+                // User doesn't have the opportunity to catch exceptions here.
+                pango_print_warn("ThreadVideo caught exception (%s)\n", e.what());
+                grab.return_status = false;
+            }
+
+            if(grab.return_status){
+                grab.frame_properties = GetVideoFrameProperties(videoin[0]);
+            }else{
+                std::this_thread::sleep_for(std::chrono::microseconds(grab_fail_thread_sleep_us) );
+            }
+            queue.addValidBuffer(std::move(grab));
+
+            DBGPRINT("Grab thread got frame. valid:%d free:%d",queue.AvailableFrames(),queue.EmptyBuffers())
+            // Let listening threads know we got a frame in case they are waiting.
+            cv.notify_all();
+        }else{
+            std::this_thread::sleep_for(std::chrono::microseconds(grab_fail_thread_sleep_us) );
+        }
+        std::this_thread::yield();
+    }
+    DBGPRINT("Grab thread Stopped.")
+
+    return;
+}
+
+std::vector<VideoInterface*>& ThreadVideo::InputStreams()
+{
+    return videoin;
+}
+
+PANGOLIN_REGISTER_FACTORY(ThreadVideo)
+{
+    struct ThreadVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"thread",10}};
+        }
+        const char* Description() const override
+        {
+            return "Queues sub-video frames in thread.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"num_buffers", "30", "Size of the input queue/buffer for this thread"},
+                {"name","Unnamed","Name of the thread"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(), uri);
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            const int num_buffers = reader.Get<int>("num_buffers");
+            const std::string name = reader.Get<std::string>("name");
+            return std::unique_ptr<VideoInterface>(new ThreadVideo(subvid, num_buffers, name));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<ThreadVideoFactory>());
+}
+
+}
+
+#undef TSTART
+#undef TGRABANDPRINT
+#undef DBGPRINT

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

@@ -0,0 +1,597 @@
+/* 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/transform.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+#include <unordered_map>
+#include <vector>
+
+namespace pangolin
+{
+
+
+TransformVideo::TransformVideo(std::unique_ptr<VideoInterface>& src, const std::vector<TransformOptions>& flips)
+    : videoin(std::move(src)), flips(flips), size_bytes(0),buffer(0)
+{
+    if(!videoin) {
+        throw VideoException("TransformVideo: VideoInterface in must not be null");
+    }
+
+    inputs.push_back(videoin.get());
+
+    for(size_t i=0;i<videoin->Streams().size();i++)
+        switch (flips[i]) {
+            case TransformOptions::FlipX:
+            case TransformOptions::FlipY:
+            case TransformOptions::FlipXY:
+            case TransformOptions::None:
+            streams.push_back(videoin->Streams()[i]);
+            break;
+
+            case TransformOptions::Transpose:
+            case TransformOptions::RotateCW:
+            case TransformOptions::RotateCCW:
+
+            unsigned char*ptr=videoin->Streams()[i].Offset();
+            size_t w=videoin->Streams()[i].Height();
+            size_t h=videoin->Streams()[i].Width();
+            size_t Bpp=videoin->Streams()[i].PixFormat().bpp / 8;
+
+            streams.emplace_back(videoin->Streams()[i].PixFormat(),pangolin::Image<unsigned char>(ptr,w,h,w*Bpp));
+            break;
+        };
+
+    size_bytes = videoin->SizeBytes();
+    buffer = new unsigned char[size_bytes];
+}
+
+TransformVideo::~TransformVideo()
+{
+    delete[] buffer;
+}
+
+//! Implement VideoInput::Start()
+void TransformVideo::Start()
+{
+    videoin->Start();
+}
+
+//! Implement VideoInput::Stop()
+void TransformVideo::Stop()
+{
+    videoin->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t TransformVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& TransformVideo::Streams() const
+{
+    return streams;
+}
+
+void PitchedImageCopy(
+    Image<unsigned char>& img_out,
+    const Image<unsigned char>& img_in,
+    size_t bytes_per_pixel
+) {
+    if( img_out.w != img_in.w || img_out.h != img_in.h ) {
+        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), bytes_per_pixel * img_in.w);
+    }
+}
+
+void FlipY(
+    Image<unsigned char>& img_out,
+    const Image<unsigned char>& img_in,
+    size_t bytes_per_pixel
+) {
+    if( img_out.w != img_in.w || img_out.h != img_in.h ) {
+        throw std::runtime_error("FlipY: Incompatible image sizes");
+    }
+
+    for(size_t y_out=0; y_out < img_out.h; ++y_out) {
+        const size_t y_in = (img_in.h-1) - y_out;
+        std::memcpy(img_out.RowPtr((int)y_out), img_in.RowPtr((int)y_in), bytes_per_pixel * img_in.w);
+    }
+}
+
+template <typename T>
+void ChainSwap2(T& a, T& b)
+{
+    T t = a;
+    a = b;
+    b = t;
+}
+
+template <typename T>
+void ChainSwap4(T& a, T& b, T& c, T& d)
+{
+    T t = a;
+    a = b;
+    b = c;
+    c = d;
+    d = t;
+}
+
+template <size_t BPP, size_t TSZ>
+void TiledFlipX(Image<unsigned char>& img_out, const Image<unsigned char>& img_in)
+{
+    const size_t w = img_in.w;
+    const size_t h = img_in.h;
+
+    typedef struct
+    {
+        unsigned char d[BPP];
+    } T;
+    T d[TSZ][TSZ];
+
+    for(size_t xin = 0; xin < w; xin += TSZ)
+        for(size_t yin = 0; yin < h; yin += TSZ)
+        {
+            const size_t xspan = std::min(TSZ, w - xin);
+            const size_t yspan = std::min(TSZ, h - yin);
+            const size_t xout = w - xin - TSZ;
+            const size_t yout = yin;
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(d[y], img_in.RowPtr(yin + y) + xin * BPP, xspan * BPP);
+
+            for(size_t y = 0; y < TSZ; y++)
+                for(size_t x = 0; x < TSZ / 2; x++)
+                    ChainSwap2(d[y][x], d[y][TSZ - 1 - x]);
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(img_out.RowPtr(yout + y) + (xout + TSZ - xspan) * BPP, d[y] + TSZ - xspan, xspan * BPP);
+        }
+}
+
+template <size_t BPP, size_t TSZ>
+void TiledRotate180(Image<unsigned char>& img_out, const Image<unsigned char>& img_in)
+{
+    static_assert(!(TSZ & 1), "Tilesize must be even.");
+
+    const size_t w = img_in.w;
+    const size_t h = img_in.h;
+
+    typedef struct
+    {
+        unsigned char d[BPP];
+    } T;
+    T d[TSZ][TSZ];
+
+    for(size_t xin = 0; xin < w; xin += TSZ)
+        for(size_t yin = 0; yin < h; yin += TSZ)
+        {
+            const size_t xspan = std::min(TSZ, w - xin);
+            const size_t yspan = std::min(TSZ, h - yin);
+            const size_t xout = w - xin - TSZ;
+            const size_t yout = h - yin - TSZ;
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(d[y], img_in.RowPtr(yin + y) + xin * BPP, xspan * BPP);
+
+            for(size_t y = 0; y < TSZ / 2; y++)
+                for(size_t x = 0; x < TSZ; x++)
+                    ChainSwap2(d[y][x], d[TSZ - 1 - y][TSZ - 1 - x]);
+
+            for(size_t y = TSZ - yspan; y < TSZ; y++)
+                memcpy(img_out.RowPtr(yout + y) + (xout + TSZ - xspan) * BPP, d[y] + TSZ - xspan, xspan * BPP);
+        }
+}
+
+template <size_t BPP, size_t TSZ>
+void TiledTranspose(Image<unsigned char>& img_out, const Image<unsigned char>& img_in)
+{
+    const size_t w = img_in.w;
+    const size_t h = img_in.h;
+
+    typedef struct
+    {
+        unsigned char d[BPP];
+    } T;
+    T d[TSZ][TSZ];
+
+    for(size_t xin = 0; xin < w; xin += TSZ)
+        for(size_t yin = 0; yin < h; yin += TSZ)
+        {
+            const size_t xspan = std::min(TSZ, w - xin);
+            const size_t yspan = std::min(TSZ, h - yin);
+            const size_t dmin = std::min(xspan, yspan);
+            const size_t dmax = std::max(xspan, yspan);
+            const size_t xout = yin;
+            const size_t yout = xin;
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(d[y], img_in.RowPtr(yin + y) + xin * BPP, xspan * BPP);
+
+            for(size_t x = 0; x < dmin; x++)
+                for(size_t y = x + 1; y < dmax; y++)
+                    ChainSwap2(d[x][y], d[y][x]);
+
+            for(size_t y = 0; y < xspan; y++)
+                memcpy(img_out.RowPtr(yout + y) + xout * BPP, d[y], yspan * BPP);
+        }
+}
+
+template <size_t BPP, size_t TSZ>
+void TiledRotateCW(Image<unsigned char>& img_out, const Image<unsigned char>& img_in)
+{
+    static_assert(!(TSZ & 1), "Tilesize must be even.");
+
+    const size_t w = img_in.w;
+    const size_t h = img_in.h;
+
+    typedef struct
+    {
+        unsigned char d[BPP];
+    } T;
+    T d[TSZ][TSZ];
+
+    for(size_t xin = 0; xin < w; xin += TSZ)
+        for(size_t yin = 0; yin < h; yin += TSZ)
+        {
+            const size_t xspan = std::min(TSZ, w - xin);
+            const size_t yspan = std::min(TSZ, h - yin);
+            const size_t xout = h - yin - TSZ;
+            const size_t yout = xin;
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(d[y], img_in.RowPtr(yin + y) + xin * BPP, xspan * BPP);
+
+            for(size_t y = 0; y < TSZ / 2; y++)
+                for(size_t x = 0; x < TSZ / 2; x++)
+                    ChainSwap4(d[TSZ - 1 - x][y], d[TSZ - 1 - y][TSZ - 1 - x], d[x][TSZ - 1 - y], d[y][x]);
+
+            for(size_t y = 0; y < xspan; y++)
+                memcpy(img_out.RowPtr(yout + y) + (xout + TSZ - yspan) * BPP, d[y] + TSZ - yspan, yspan * BPP);
+        }
+}
+
+template <size_t BPP, size_t TSZ>
+void TiledRotateCCW(Image<unsigned char>& img_out, const Image<unsigned char>& img_in)
+{
+    static_assert(!(TSZ & 1), "Tilesize must be even.");
+
+    const size_t w = img_in.w;
+    const size_t h = img_in.h;
+
+    typedef struct
+    {
+        unsigned char d[BPP];
+    } T;
+    T d[TSZ][TSZ];
+
+    for(size_t xin = 0; xin < w; xin += TSZ)
+        for(size_t yin = 0; yin < h; yin += TSZ)
+        {
+            const size_t xspan = std::min(TSZ, w - xin);
+            const size_t yspan = std::min(TSZ, h - yin);
+            const size_t xout = yin;
+            const size_t yout = w - xin - TSZ;
+
+            for(size_t y = 0; y < yspan; y++)
+                memcpy(d[y], img_in.RowPtr(yin + y) + xin * BPP, xspan * BPP);
+
+            for(size_t y = 0; y < TSZ / 2; y++)
+                for(size_t x = 0; x < TSZ / 2; x++)
+                    ChainSwap4(d[y][x], d[x][TSZ - 1 - y], d[TSZ - 1 - y][TSZ - 1 - x], d[TSZ - 1 - x][y]);
+
+            for(size_t y = TSZ - xspan; y < TSZ; y++)
+                memcpy(img_out.RowPtr(yout + y) + xout * BPP, d[y], yspan * BPP);
+        }
+}
+
+void FlipX(Image<unsigned char>& img_out, const Image<unsigned char>& img_in, size_t bytes_per_pixel)
+{
+    if(bytes_per_pixel == 1)
+        TiledFlipX<1, 160>(img_out, img_in);
+    else if(bytes_per_pixel == 2)
+        TiledFlipX<2, 120>(img_out, img_in);
+    else if(bytes_per_pixel == 3)
+        TiledFlipX<3, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 4)
+        TiledFlipX<4, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 6)
+        TiledFlipX<6, 64>(img_out, img_in);
+    else {
+        for(size_t y = 0; y < img_out.h; ++y) {
+            for(size_t x = 0; x < img_out.w; ++x) {
+                memcpy(img_out.RowPtr((int)y) + (img_out.w - 1 - x) * bytes_per_pixel,
+                       img_in.RowPtr((int)y) + x * bytes_per_pixel,
+                       bytes_per_pixel);
+            }
+        }
+    }
+}
+
+void FlipXY(Image<unsigned char>& img_out, const Image<unsigned char>& img_in, size_t bytes_per_pixel)
+{
+    if(bytes_per_pixel == 1)
+        TiledRotate180<1, 160>(img_out, img_in);
+    else if(bytes_per_pixel == 2)
+        TiledRotate180<2, 120>(img_out, img_in);
+    else if(bytes_per_pixel == 3)
+        TiledRotate180<3, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 4)
+        TiledRotate180<4, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 6)
+        TiledRotate180<6, 64>(img_out, img_in);
+    else {
+        for(size_t y_out = 0; y_out < img_out.h; ++y_out) {
+            for(size_t x = 0; x < img_out.w; ++x) {
+                const size_t y_in = (img_in.h - 1) - y_out;
+                memcpy(img_out.RowPtr((int)y_out) + (img_out.w - 1 - x) * bytes_per_pixel,
+                       img_in.RowPtr((int)y_in) + x * bytes_per_pixel,
+                       bytes_per_pixel);
+            }
+        }
+    }
+}
+
+void RotateCW(Image<unsigned char>& img_out, const Image<unsigned char>& img_in, size_t bytes_per_pixel)
+{
+    if(bytes_per_pixel == 1)
+        TiledRotateCW<1, 160>(img_out, img_in);
+    else if(bytes_per_pixel == 2)
+        TiledRotateCW<2, 120>(img_out, img_in);
+    else if(bytes_per_pixel == 3)
+        TiledRotateCW<3, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 4)
+        TiledRotateCW<4, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 6)
+        TiledRotateCW<6, 64>(img_out, img_in);
+    else {
+        for(size_t yout = 0; yout < img_out.h; ++yout)
+            for(size_t xout = 0; xout < img_out.w; ++xout) {
+                size_t xin = yout;
+                size_t yin = img_out.w - 1 - xout;
+                memcpy(img_out.RowPtr((int)yout) + xout * bytes_per_pixel,
+                       img_in.RowPtr((int)yin) + xin * bytes_per_pixel,
+                       bytes_per_pixel);
+            }
+    }
+}
+
+void Transpose(Image<unsigned char>& img_out, const Image<unsigned char>& img_in, size_t bytes_per_pixel)
+{
+    if(bytes_per_pixel == 1)
+        TiledTranspose<1, 160>(img_out, img_in);
+    else if(bytes_per_pixel == 2)
+        TiledTranspose<2, 120>(img_out, img_in);
+    else if(bytes_per_pixel == 3)
+        TiledTranspose<3, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 4)
+        TiledTranspose<4, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 6)
+        TiledTranspose<6, 64>(img_out, img_in);
+    else {
+        for(size_t yout = 0; yout < img_out.h; ++yout)
+            for(size_t xout = 0; xout < img_out.w; ++xout) {
+                size_t xin = yout;
+                size_t yin = xout;
+                memcpy(img_out.RowPtr((int)yout) + xout * bytes_per_pixel,
+                       img_in.RowPtr((int)yin) + xin * bytes_per_pixel,
+                       bytes_per_pixel);
+            }
+    }
+}
+
+void RotateCCW(Image<unsigned char>& img_out, const Image<unsigned char>& img_in, size_t bytes_per_pixel)
+{
+    if(bytes_per_pixel == 1)
+        TiledRotateCCW<1, 160>(img_out, img_in);
+    else if(bytes_per_pixel == 2)
+        TiledRotateCCW<2, 120>(img_out, img_in);
+    else if(bytes_per_pixel == 3)
+        TiledRotateCCW<3, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 4)
+        TiledRotateCCW<4, 80>(img_out, img_in);
+    else if(bytes_per_pixel == 6)
+        TiledRotateCCW<6, 64>(img_out, img_in);
+    else {
+        for(size_t yout = 0; yout < img_out.h; ++yout)
+            for(size_t xout = 0; xout < img_out.w; ++xout) {
+                size_t xin = img_out.h - 1 - yout;
+                size_t yin = xout;
+                memcpy(img_out.RowPtr((int)yout) + xout * bytes_per_pixel,
+                       img_in.RowPtr((int)yin) + xin * bytes_per_pixel,
+                       bytes_per_pixel);
+            }
+    }
+}
+
+
+void TransformVideo::Process(unsigned char* buffer_out, const unsigned char* buffer_in)
+{
+
+    for(size_t s=0; s<streams.size(); ++s) {
+        Image<unsigned char> img_out = Streams()[s].StreamImage(buffer_out);
+        const Image<unsigned char> img_in  = videoin->Streams()[s].StreamImage(buffer_in);
+        const size_t bytes_per_pixel = Streams()[s].PixFormat().bpp / 8;
+
+        switch (flips[s]) {
+        case TransformOptions::FlipX:
+            FlipX(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::FlipY:
+            FlipY(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::FlipXY:
+            FlipXY(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::RotateCW:
+            RotateCW(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::RotateCCW:
+            RotateCCW(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::Transpose:
+            Transpose(img_out, img_in, bytes_per_pixel);
+            break;
+        case TransformOptions::None:
+            PitchedImageCopy(img_out, img_in, bytes_per_pixel);
+            break;
+        default:
+            pango_print_warn("TransformVideo::Process(): Invalid enum %i.\n", int(flips[s]));
+            break;
+        }
+    }
+
+}
+
+//! Implement VideoInput::GrabNext()
+bool TransformVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(videoin->GrabNext(buffer,wait)) {
+        Process(image, buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool TransformVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    if(videoin->GrabNewest(buffer,wait)) {
+        Process(image, buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& TransformVideo::InputStreams()
+{
+    return inputs;
+}
+
+unsigned int TransformVideo::AvailableFrames() const
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin.get());
+    if(!vpi)
+    {
+        pango_print_warn("Mirror: child interface is not buffer aware.");
+        return 0;
+    }
+    else
+    {
+        return vpi->AvailableFrames();
+    }
+}
+
+bool TransformVideo::DropNFrames(uint32_t n)
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin.get());
+    if(!vpi)
+    {
+        pango_print_warn("Mirror: child interface is not buffer aware.");
+        return false;
+    }
+    else
+    {
+        return vpi->DropNFrames(n);
+    }
+}
+
+const std::map<std::string,TransformOptions> StringToMirrorOptionMap = {
+    {"none", TransformOptions::None},
+    {"transform", TransformOptions::None},
+    {"mirror", TransformOptions::FlipX},
+    {"flipx", TransformOptions::FlipX},
+    {"flip", TransformOptions::FlipY},
+    {"flipy", TransformOptions::FlipY},
+    {"flipxy", TransformOptions::FlipXY},
+    {"transpose", TransformOptions::Transpose},
+    {"rotate", TransformOptions::RotateCW},
+    {"rotatecw", TransformOptions::RotateCW},
+    {"rotateccw", TransformOptions::RotateCCW}
+};
+
+std::istream& operator>> (std::istream &is, TransformOptions &mirror)
+{
+    std::string str_mirror;
+    is >> str_mirror;
+
+    auto default_it = StringToMirrorOptionMap.find(str_mirror);
+    mirror = (default_it != StringToMirrorOptionMap.end()) ?
+        default_it->second : TransformOptions::None;
+
+    return is;
+}
+
+PANGOLIN_REGISTER_FACTORY(TransformVideo) {
+    struct TransformVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override {
+            return {
+                {"transform",10}, {"mirror",10}, {"flip",10}, {"rotate",10}, {"transpose",10},
+                {"rotatecw",10}, {"rotateccw",10}, {"flipx",10}, {"flipy",10}, {"flipxy",10}
+            };
+        }
+        const char* Description() const override {
+            return "Filter: Apply one of a number of simple image transforms to the streams.";
+        }
+        ParamSet Params() const override
+        {
+            return {{ {"stream\\d+","none (or scheme name)", "Transform to apply to stream. One of "
+                        "(None,FlipX,FlipY,FlipXY,Transpose,RotateCW,RotateCCW)."} }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            auto default_it = StringToMirrorOptionMap.find(uri.scheme);
+            const TransformOptions default_transform = (default_it != StringToMirrorOptionMap.end()) ?
+                default_it->second : TransformOptions::None;
+
+            ParamReader reader(Params(), uri);
+            std::vector<TransformOptions> transforms;
+
+            for(size_t i=0; i < subvid->Streams().size(); ++i){
+                std::stringstream ss;
+                ss << "stream" << i;
+                const std::string key = ss.str();
+                transforms.push_back(reader.Get<TransformOptions>(key, default_transform) );
+            }
+
+            return std::unique_ptr<VideoInterface> (new TransformVideo(subvid, transforms));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<TransformVideoFactory>());
+}
+
+}

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

@@ -0,0 +1,127 @@
+/* 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/truncate.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/video.h>
+
+namespace pangolin
+{
+
+TruncateVideo::TruncateVideo(std::unique_ptr<VideoInterface> &src_, size_t begin, size_t end)
+    : src(std::move(src_)), streams(src->Streams()), begin(begin), end(end), next_frame_to_grab(0)
+{
+    videoin.push_back(src.get());
+
+    if(VideoPlaybackInterface* v = GetVideoPlaybackInterface()){
+        // Guard against the obscure case of nested TruncateVideo filters
+        if( !pangolin::FindFirstMatchingVideoInterface<TruncateVideo>(*src) ) {
+            next_frame_to_grab = v->Seek(begin);
+        }
+    }
+}
+
+TruncateVideo::~TruncateVideo()
+{
+}
+
+size_t TruncateVideo::SizeBytes() const
+{
+    return videoin[0]->SizeBytes();
+}
+
+const std::vector<StreamInfo>& TruncateVideo::Streams() const
+{
+    return streams;
+}
+
+void TruncateVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+void TruncateVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+bool TruncateVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(next_frame_to_grab < end) {
+        bool grab_success = videoin[0]->GrabNext(image, wait);
+        return grab_success && (next_frame_to_grab++) >= begin;
+    }
+    return false;
+}
+
+bool TruncateVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return videoin[0]->GrabNewest(image, wait);
+}
+
+std::vector<VideoInterface*>& TruncateVideo::InputStreams()
+{
+    return videoin;
+}
+
+PANGOLIN_REGISTER_FACTORY(TruncateVideo)
+{
+    struct TruncateVideoFactory : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"truncate",10}};
+        }
+        const char* Description() const override
+        {
+            return "Truncates the length of a video stream with begin and end markers";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                    {"begin","0","Beginning of the stream"},
+                    {"end","size_t::max*","Dynamically set to the max of size_t"},
+                }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            std::unique_ptr<VideoInterface> subvid = pangolin::OpenVideo(uri.url);
+            if(subvid->Streams().size() == 0) {
+                throw VideoException("VideoTruncater input must have at least one stream");
+            }
+
+            ParamReader reader(Params(),uri);
+            const size_t start = reader.Get<size_t>("begin");
+            const size_t end = reader.Get<size_t>("end", std::numeric_limits<size_t>::max());
+
+            return std::unique_ptr<VideoInterface>( new TruncateVideo(subvid,start,end) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<TruncateVideoFactory>());
+}
+
+}

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

@@ -0,0 +1,284 @@
+/* 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/unpack.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
+{
+
+UnpackVideo::UnpackVideo(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("UnpackVideo: Only supports single channel output.");
+    }
+
+    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("UnpackVideo: Only supports one channel input.");
+        }
+
+        const size_t pitch = (w*out_fmt.bpp)/ 8;
+        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()];
+}
+
+UnpackVideo::~UnpackVideo()
+{
+    delete[] buffer;
+}
+
+//! Implement VideoInput::Start()
+void UnpackVideo::Start()
+{
+    videoin[0]->Start();
+}
+
+//! Implement VideoInput::Stop()
+void UnpackVideo::Stop()
+{
+    videoin[0]->Stop();
+}
+
+//! Implement VideoInput::SizeBytes()
+size_t UnpackVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+//! Implement VideoInput::Streams()
+const std::vector<StreamInfo>& UnpackVideo::Streams() const
+{
+    return streams;
+}
+
+template<typename T>
+void ConvertFrom8bit(
+    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 ConvertFrom10bit(
+    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) {
+            uint64_t val = *(pin++);
+            val |= uint64_t(*(pin++)) << 8;
+            val |= uint64_t(*(pin++)) << 16;
+            val |= uint64_t(*(pin++)) << 24;
+            val |= uint64_t(*(pin++)) << 32;
+            *(pout++) = T( val & 0x00000003FF);
+            *(pout++) = T((val & 0x00000FFC00) >> 10);
+            *(pout++) = T((val & 0x003FF00000) >> 20);
+            *(pout++) = T((val & 0xFFC0000000) >> 30);
+        }
+    }
+}
+
+template<typename T>
+void ConvertFrom12bit(
+    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) {
+            uint32_t val = *(pin++);
+            val |= uint32_t(*(pin++)) << 8;
+            val |= uint32_t(*(pin++)) << 16;
+            *(pout++) = T( val & 0x000FFF);
+            *(pout++) = T((val & 0xFFF000) >> 12);
+        }
+    }
+}
+
+void UnpackVideo::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_in  = videoin[0]->Streams()[s].PixFormat().bpp;
+
+        if(Streams()[s].PixFormat().format == "GRAY32F") {
+            if( bits_in == 8) {
+                ConvertFrom8bit<float>(img_out, img_in);
+            }else if( bits_in == 10) {
+                ConvertFrom10bit<float>(img_out, img_in);
+            }else if( bits_in == 12){
+                ConvertFrom12bit<float>(img_out, img_in);
+            }else{
+                throw pangolin::VideoException("Unsupported bitdepths.");
+            }
+        }else if(Streams()[s].PixFormat().format == "GRAY16LE") {
+            if( bits_in == 8) {
+                ConvertFrom8bit<uint16_t>(img_out, img_in);
+            }else if( bits_in == 10) {
+                ConvertFrom10bit<uint16_t>(img_out, img_in);
+            }else if( bits_in == 12){
+                ConvertFrom12bit<uint16_t>(img_out, img_in);
+            }else{
+                throw pangolin::VideoException("Unsupported bitdepths.");
+            }
+        }else{
+        }
+    }
+    TGRABANDPRINT("Unpacking took ")
+}
+
+//! Implement VideoInput::GrabNext()
+bool UnpackVideo::GrabNext( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNext(buffer,wait)) {
+        Process(image,buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+//! Implement VideoInput::GrabNewest()
+bool UnpackVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    if(videoin[0]->GrabNewest(buffer,wait)) {
+        Process(image,buffer);
+        return true;
+    }else{
+        return false;
+    }
+}
+
+std::vector<VideoInterface*>& UnpackVideo::InputStreams()
+{
+    return videoin;
+}
+
+unsigned int UnpackVideo::AvailableFrames() const
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Unpack: child interface is not buffer aware.");
+        return 0;
+    }
+    else
+    {
+        return vpi->AvailableFrames();
+    }
+}
+
+bool UnpackVideo::DropNFrames(uint32_t n)
+{
+    BufferAwareVideoInterface* vpi = dynamic_cast<BufferAwareVideoInterface*>(videoin[0]);
+    if(!vpi)
+    {
+        pango_print_warn("Unpack: child interface is not buffer aware.");
+        return false;
+    }
+    else
+    {
+        return vpi->DropNFrames(n);
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY(UnpackVideo)
+{
+    struct UnpackVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"unpack",10}};
+        }
+        const char* Description() const override
+        {
+            return "Converts from a potentially packed pixel format to a higher bit-depth format (e.g. 10 to 16 bit).";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"fmt","GRAY16LE","Destination pixel format."}
+            }};
+        }
+        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("fmt", std::string("GRAY16LE") );
+            return std::unique_ptr<VideoInterface>(
+                new UnpackVideo(subvid, PixelFormatFromString(fmt) )
+            );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<UnpackVideoFactory>());
+}
+
+}
+
+#undef TSTART
+#undef TGRABANDPRINT
+#undef DBGPRINT

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

@@ -0,0 +1,382 @@
+/* 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/factory/factory_registry.h>
+#include <pangolin/video/drivers/uvc.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace pangolin
+{
+
+UvcVideo::UvcVideo(int vendor_id, int product_id, const char* sn, int device_id, int width, int height, int fps)
+    : ctx_(NULL),
+      dev_(NULL),
+      devh_(NULL),
+      frame_(NULL),
+      is_streaming(false)
+{
+    uvc_init(&ctx_, NULL);
+    if(!ctx_) {
+        throw VideoException("Unable to open UVC Context");
+    }
+
+    InitDevice(vendor_id, product_id, sn, device_id, width, height, fps);
+    InitPangoDeviceProperties();
+
+    // FIX: CRASHING IF WE DON'T START STREAMING STRAIGHT AWAY
+
+    Start();
+}
+
+UvcVideo::~UvcVideo()
+{
+    DeinitDevice();
+
+    if(devh_) uvc_close(devh_);
+    if(dev_) uvc_unref_device(dev_);
+
+    if (ctx_) {
+        uvc_exit(ctx_);
+        ctx_ = 0;
+    }
+}
+
+uvc_error_t UvcVideo::FindDevice(
+    uvc_context_t *ctx, uvc_device_t **dev,
+    int vid, int pid, const char *sn, int device_id) {
+  uvc_error_t ret = UVC_SUCCESS;
+
+  uvc_device_t **list;
+  uvc_device_t *test_dev;
+
+  ret = uvc_get_device_list(ctx, &list);
+
+  int cnt = 0;
+  while(list[cnt++]!=NULL);
+  pango_print_info("UVC Descriptor list contains %d devices.\n", (cnt-1));
+
+  if (ret != UVC_SUCCESS) {
+    return ret;
+  }
+
+  int dev_idx = 0;
+  int num_found = 0;
+  bool found_dev = false;
+
+  while (!found_dev && (test_dev = list[dev_idx++]) != NULL) {
+    uvc_device_descriptor_t *desc;
+
+    if (uvc_get_device_descriptor(test_dev, &desc) != UVC_SUCCESS)
+      continue;
+
+
+    const bool matches = (!vid || desc->idVendor == vid)
+            && (!pid || desc->idProduct == pid)
+            && (!sn || (desc->serialNumber && !strcmp(desc->serialNumber, sn)));
+
+    uvc_free_device_descriptor(desc);
+
+    if (matches) {
+        if(device_id == num_found) {
+            found_dev = true;
+            break;
+        }
+        num_found++;
+    }
+  }
+
+  if (found_dev)
+    uvc_ref_device(test_dev);
+
+  uvc_free_device_list(list, 1);
+
+  if (found_dev) {
+    *dev = test_dev;
+    return UVC_SUCCESS;
+  } else {
+    return UVC_ERROR_NO_DEVICE;
+  }
+}
+
+void UvcVideo::InitDevice(int vid, int pid, const char* sn, int device_id, int width, int height, int fps)
+{
+    uvc_error_t find_err = FindDevice(ctx_, &dev_, vid, pid, sn, device_id );
+    if (find_err != UVC_SUCCESS) {
+        uvc_perror(find_err, "uvc_find_device");
+        throw VideoException("Unable to open UVC Device");
+    }
+    if(!dev_) {
+        throw VideoException("Unable to open UVC Device - no pointer returned.");
+    }
+
+    uvc_error_t open_err = uvc_open(dev_, &devh_);
+    if (open_err != UVC_SUCCESS) {
+        uvc_perror(open_err, "uvc_open");
+        uvc_unref_device(dev_);
+        throw VideoException("Unable to open device");
+    }
+
+    //uvc_print_diag(devh_, stderr);
+
+    uvc_error_t mode_err = uvc_get_stream_ctrl_format_size(
+                devh_, &ctrl_,
+                UVC_FRAME_FORMAT_ANY,
+                width, height,
+                fps);
+
+    //uvc_print_stream_ctrl(&ctrl_, stderr);
+
+    if (mode_err != UVC_SUCCESS) {
+        uvc_perror(mode_err, "uvc_get_stream_ctrl_format_size");
+        uvc_close(devh_);
+        uvc_unref_device(dev_);
+        throw VideoException("Unable to set device mode.");
+    }
+
+    uvc_error_t strm_err = uvc_stream_open_ctrl(devh_, &strm_, &ctrl_);
+    if(strm_err != UVC_SUCCESS) {
+        uvc_perror(strm_err, "uvc_stream_open_ctrl");
+        uvc_close(devh_);
+        uvc_unref_device(dev_);
+        throw VideoException("Unable to open device stream.");
+    }
+
+    // Default to greyscale.
+    PixelFormat pfmt = PixelFormatFromString("GRAY8");
+
+    const uvc_format_desc_t* uvc_fmt = uvc_get_format_descs(devh_);
+    while( uvc_fmt->bFormatIndex != ctrl_.bFormatIndex && uvc_fmt ) {
+        uvc_fmt = uvc_fmt->next;
+    }
+
+    if(uvc_fmt) {
+        // TODO: Use uvc_fmt->fourccFormat
+        if( uvc_fmt->bBitsPerPixel == 16 ) {
+            pfmt = PixelFormatFromString("GRAY16LE");
+        }
+    }
+
+    const StreamInfo stream_info(pfmt, width, height, (width*pfmt.bpp)/8, 0);
+    streams.push_back(stream_info);
+}
+
+void UvcVideo::InitPangoDeviceProperties()
+{
+    // Store camera details in device properties
+    device_properties["BusNumber"] = std::to_string(uvc_get_bus_number(dev_));
+    device_properties["DeviceAddress"] = std::to_string(uvc_get_device_address(dev_));
+    device_properties[PANGO_HAS_TIMING_DATA] = true;
+}
+
+void UvcVideo::DeinitDevice()
+{
+    Stop();
+
+    if (frame_) {
+        uvc_free_frame(frame_);
+        frame_ = 0;
+    }
+}
+
+void UvcVideo::Start()
+{
+    if(!is_streaming) {
+        uvc_error_t stream_err = uvc_stream_start(strm_, NULL, this, 0);
+
+        if (stream_err != UVC_SUCCESS) {
+            uvc_perror(stream_err, "uvc_stream_start");
+            uvc_close(devh_);
+            uvc_unref_device(dev_);
+            throw VideoException("Unable to start streaming.");
+        }else{
+            is_streaming = true;
+        }
+
+        if (frame_) {
+            uvc_free_frame(frame_);
+        }
+
+        size_bytes = ctrl_.dwMaxVideoFrameSize;
+        frame_ = uvc_allocate_frame(size_bytes);
+        if(!frame_) {
+            throw VideoException("Unable to allocate frame.");
+        }
+    }
+}
+
+void UvcVideo::Stop()
+{
+    if(is_streaming && devh_) {
+        uvc_stop_streaming(devh_);
+    }
+    is_streaming = false;
+}
+
+size_t UvcVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+const std::vector<StreamInfo>& UvcVideo::Streams() const
+{
+    return streams;
+}
+
+bool UvcVideo::GrabNext( unsigned char* image, bool wait )
+{
+    uvc_frame_t* frame = NULL;
+    uvc_error_t err = uvc_stream_get_frame(strm_, &frame, wait ? 0 : -1);
+
+    if(err!= UVC_SUCCESS) {
+        pango_print_error("UvcVideo Error: %s", uvc_strerror(err) );
+        return false;
+    }else{
+        if(frame) {
+            memcpy(image, frame->data, frame->data_bytes );
+            // This is a hack, this ts sould come from the device.
+            frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(pangolin::TimeNow()));
+            return true;
+        }else{
+            if(wait) {
+                pango_print_debug("UvcVideo: No frame data");
+            }
+            return false;
+        }
+    }
+}
+
+bool UvcVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    return GrabNext(image, wait);
+}
+
+int UvcVideo::IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code)
+{
+    if(req_code == UVC_SET_CUR) {
+        return uvc_set_ctrl(devh_, unit, ctrl, data, len);
+    }else{
+        return uvc_get_ctrl(devh_, unit, ctrl, data, len, (uvc_req_code)req_code);
+    }
+}
+
+bool UvcVideo::SetExposure(int exp_us)
+{
+    uint32_t e = uint32_t(exp_us);
+
+    if (uvc_set_exposure_abs(devh_, e) < 0) {
+        pango_print_warn("UvcVideo::setExposure() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool UvcVideo::GetExposure(int& exp_us)
+{
+    uint32_t e;
+    if (uvc_get_exposure_abs(devh_, &e, uvc_req_code::UVC_GET_CUR) < 0) {
+        pango_print_warn("UvcVideo::GetExposure() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        exp_us = e;
+        return true;
+    }
+}
+
+bool UvcVideo::SetGain(float gain)
+{
+    uint16_t g = uint16_t(gain);
+
+    if (uvc_set_gain(devh_, g) < 0) {
+        pango_print_warn("UvcVideo::setGain() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool UvcVideo::GetGain(float& gain)
+{
+    uint16_t g;
+    if (uvc_get_gain(devh_, &g, uvc_req_code::UVC_GET_CUR) < 0) {
+        pango_print_warn("UvcVideo::GetGain() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        gain = g;
+        return true;
+    }
+}
+
+//! Access JSON properties of device
+const picojson::value& UvcVideo::DeviceProperties() const
+{
+        return device_properties;
+}
+
+//! Access JSON properties of most recently captured frame
+const picojson::value& UvcVideo::FrameProperties() const
+{
+    return frame_properties;
+}
+
+PANGOLIN_REGISTER_FACTORY(UvcVideo)
+{
+    struct UvcVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"uvc",10}};
+        }
+        const char* Description() const override
+        {
+            return "Use libuvc to open UVC USB device";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","0","Frames per second (0:unspecified)"},
+                {"num","0","Open the nth device (no need for vid and pid)"},
+                {"vid","0x0000","Open based on USB VID and PID"},
+                {"pid","0x0000","Open based on USB VID and PID"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            int vid = 0;
+            int pid = 0;
+            std::istringstream(uri.Get<std::string>("vid","0x0000")) >> std::hex >> vid;
+            std::istringstream(uri.Get<std::string>("pid","0x0000")) >> std::hex >> pid;
+            const unsigned int dev_id = uri.Get<int>("num",0);
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(640,480));
+            const unsigned int fps = uri.Get<unsigned int>("fps", 0); // 0 means unspecified.
+            return std::unique_ptr<VideoInterface>( new UvcVideo(vid,pid,0,dev_id,dim.x,dim.y,fps) );
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<UvcVideoFactory>());
+}
+
+}

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

@@ -0,0 +1,1091 @@
+#ifndef NOMINMAX
+#  define NOMINMAX
+#endif
+
+#include <mfapi.h>
+#include <mferror.h>
+#include <mfidl.h>
+#include <mfreadwrite.h>
+
+#include <dshow.h>
+#include <ks.h>
+#include <ksmedia.h>
+#include <ksproxy.h>
+#include <vidcap.h>
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/utils/timer.h>
+#include <pangolin/video/drivers/uvc_mediafoundation.h>
+#include <pangolin/video/iostream_operators.h>
+
+#include <condition_variable>
+#include <mutex>
+
+namespace pangolin
+{
+
+static constexpr DWORD KS_CONTROL_NODE_ID_INVALID = ~0;
+
+const GUID GUID_EXTENSION_UNIT_DESCRIPTOR_OV580{
+  0x2ccb0bda, 0x6331, 0x4fdb, 0x85, 0x0e, 0x79, 0x05, 0x4d, 0xbd, 0x56, 0x71
+};
+
+class AsyncSourceReader : public IMFSourceReaderCallback
+{
+public:
+    AsyncSourceReader(IMFMediaSource* mediaSource, uint64_t timeout_ms) : ref_(1), timeout_(std::chrono::milliseconds(timeout_ms))
+    {
+        HRESULT hr;
+
+        IMFAttributes *pAttributes;
+        hr = MFCreateAttributes(&pAttributes, 1);
+        if (FAILED(hr))
+        {
+            throw VideoException(FormatString("Unable to initialize attributes for source reader (%)", hr));
+        }
+
+        hr = pAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, this);
+        if (FAILED(hr))
+        {
+            throw VideoException(FormatString("Unable to set async attribute for source reader (%)", hr));
+        }
+
+        hr = MFCreateSourceReaderFromMediaSource(mediaSource, pAttributes, &reader_);
+        if(FAILED(hr))
+        {
+            throw VideoException(FormatString("Unable to create source reader from UVC media source (%)", hr));
+        }
+    }
+
+    // IUnknown methods
+    STDMETHODIMP QueryInterface(REFIID iid, void** ppv)
+    {
+      if (iid != __uuidof(IMFSourceReaderCallback)) {
+        return E_NOINTERFACE;
+      }
+      InterlockedIncrement(&ref_);
+      *ppv = this;
+      return S_OK;
+    }
+    STDMETHODIMP_(ULONG) AddRef()
+    {
+        return InterlockedIncrement(&ref_);
+    }
+    STDMETHODIMP_(ULONG) Release()
+    {
+        ULONG snapped = InterlockedDecrement(&ref_);
+        if (snapped == 0)
+        {
+            delete this;
+        }
+        return snapped;
+    }
+
+    // IMFSourceReaderCallback methods
+    STDMETHODIMP OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex, DWORD dwStreamFlags, LONGLONG llTimestamp, IMFSample *pSample)
+    {
+        {
+            std::lock_guard<std::mutex> lock(sample_lock_);
+
+            sample_hr_ = hrStatus;
+            sample_actual_stream_index_ = dwStreamIndex;
+            sample_stream_flags_ = dwStreamFlags;
+            sample_timestamp_ = llTimestamp;
+            sample_ = pSample;
+
+            if (sample_ != nullptr)
+            {
+                sample_->AddRef();
+            }
+        }
+
+        sample_ready_.notify_one();
+
+        return S_OK;
+    }
+
+    STDMETHODIMP OnEvent(DWORD, IMFMediaEvent *)
+    {
+        return S_OK;
+    }
+
+    STDMETHODIMP OnFlush(DWORD)
+    {
+        return S_OK;
+    }
+
+    IMFSourceReader* AddRefReader()
+    {
+        reader_->AddRef();
+        return reader_;
+    }
+
+    HRESULT ReadSample(DWORD dwStreamIndex, DWORD dwControlFlags, DWORD* pdwActualStreamIndex, DWORD* pdwStreamFlags, LONGLONG* pllTimestamp, IMFSample** ppSample)
+    {
+      auto wait_target = std::chrono::steady_clock::now() + timeout_;
+
+      std::unique_lock<std::mutex> lock(sample_lock_);
+
+      // If there's already a pending read, just piggyback on it and wait. Otherwise, issue now.
+      if (sample_hr_ != E_PENDING)
+      {
+        HRESULT sync_hr = reader_->ReadSample(dwStreamIndex, dwControlFlags, NULL, NULL, NULL, NULL);
+        if (FAILED(sync_hr))
+        {
+            return sync_hr;
+        }
+
+        sample_hr_ = E_PENDING;
+      }
+
+      while (sample_hr_ == E_PENDING)
+      {
+          if (sample_ready_.wait_until(lock, wait_target) == std::cv_status::timeout)
+          {
+             // Leave sample_hr_ as E_PENDING since there's still an oustanding async call.
+             // It may be set later by the callback.
+             return RPC_E_TIMEOUT;
+          }
+      }
+
+      if (SUCCEEDED(sample_hr_))
+      {
+          *pdwActualStreamIndex = sample_actual_stream_index_;
+          *pdwStreamFlags = sample_stream_flags_;
+          *pllTimestamp = sample_timestamp_;
+
+          *ppSample = sample_;
+          sample_ = nullptr;
+      }
+
+      return sample_hr_;
+    }
+
+private:
+    // Destructor is private. Caller should call Release.
+    virtual ~AsyncSourceReader()
+    {
+        if (reader_ != nullptr)
+        {
+            reader_->Release();
+        }
+
+        if (sample_ != nullptr)
+        {
+            sample_->Release();
+        }
+    }
+
+    LONG ref_;
+    std::chrono::steady_clock::duration timeout_;
+    IMFSourceReader* reader_;
+
+    std::mutex sample_lock_;
+    std::condition_variable sample_ready_;
+    // This just needs to be initialized to anything other than E_PENDING.
+    HRESULT sample_hr_ = E_UNEXPECTED;
+    DWORD sample_actual_stream_index_;
+    DWORD sample_stream_flags_;
+    LONGLONG sample_timestamp_;
+    IMFSample* sample_ = nullptr;
+};
+
+UvcMediaFoundationVideo::UvcMediaFoundationVideo(int vendorId, int productId, const std::string& instanceId, size_t width, size_t height, int fps)
+    : size_bytes(0),
+      mediaSource(nullptr),
+      sourceReader(nullptr),
+      baseFilter(nullptr),
+      ksControl(nullptr),
+      ksControlNodeId(KS_CONTROL_NODE_ID_INVALID),
+      camera_control(nullptr),
+      video_control(nullptr),
+      expected_fps(fps)
+{
+	HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    if(FAILED(hr))
+    {
+        throw VideoException("CoInitializeEx failed");
+    }
+
+    if(FAILED(MFStartup(MF_VERSION)))
+    {
+        throw VideoException("MfStartup failed");
+    }
+
+    if(!FindDevice(vendorId, productId, instanceId))
+    {
+        throw VideoException("Unable to open UVC media source");
+    }
+    // Use async always (same interface, but allows for timing out).
+    InitDevice(width, height, true);
+
+    device_properties[PANGO_HAS_TIMING_DATA] = true;
+}
+
+UvcMediaFoundationVideo::~UvcMediaFoundationVideo()
+{
+    DeinitDevice();
+    HRESULT hr = MFShutdown();
+    if(FAILED(hr))
+    {
+        pango_print_warn("MFShutdown failed with result %X", hr);
+    }
+    CoUninitialize();
+}
+
+void UvcMediaFoundationVideo::Start()
+{
+
+}
+
+void UvcMediaFoundationVideo::Stop()
+{
+}
+
+size_t UvcMediaFoundationVideo::SizeBytes() const
+{
+    return size_bytes;
+}
+
+const std::vector<pangolin::StreamInfo>& UvcMediaFoundationVideo::Streams() const
+{
+    return streams;
+}
+
+
+bool UvcMediaFoundationVideo::GrabNext(unsigned char* image, bool wait)
+{
+    HRESULT hr;
+    IMFSample* sample = nullptr;
+    DWORD streamIndex = 0;
+    DWORD flags = 0;
+    LONGLONG timeStamp;
+
+    if (asyncSourceReader != nullptr)
+    {
+        hr = asyncSourceReader->ReadSample(
+                (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, &streamIndex, &flags, &timeStamp, &sample);
+    }
+    else
+    {
+        hr = sourceReader->ReadSample(
+                (DWORD)MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0, &streamIndex, &flags, &timeStamp, &sample);
+    }
+
+    if(SUCCEEDED(hr))
+    {
+        if((flags & MF_SOURCE_READERF_ENDOFSTREAM) != 0)
+        {
+            return false;
+        }
+
+        if((flags & MF_SOURCE_READERF_STREAMTICK) != 0)
+        {
+            return false;
+        }
+        // Believe that at this point sample should not be null
+        if(!sample)
+        {
+            return false;
+        }
+    }
+    else if (hr == MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED && wait)
+    {
+      std::this_thread::sleep_for(std::chrono::microseconds(1000000 / expected_fps));
+    }
+
+    IMFMediaBuffer* mediaBuffer = nullptr;
+    if(SUCCEEDED(hr))
+    {
+        hr = sample->ConvertToContiguousBuffer(&mediaBuffer);
+    }
+    if(SUCCEEDED(hr))
+    {
+        // Use the 2D buffer interface if it's available
+        IMF2DBuffer* mediaBuffer2d = nullptr;
+        hr = mediaBuffer->QueryInterface(&mediaBuffer2d);
+        if(SUCCEEDED(hr))
+        {
+            hr = mediaBuffer2d->ContiguousCopyTo(image, (DWORD)size_bytes);
+            mediaBuffer2d->Release();
+            mediaBuffer2d = nullptr;
+        }
+        else
+        {
+            // No 2D buffer is available
+            byte* buffer;
+            DWORD bufferSize = 0;
+            hr = mediaBuffer->Lock(&buffer, nullptr, &bufferSize);
+            if(SUCCEEDED(hr))
+            {
+                size_t copySize = std::min((size_t)bufferSize, size_bytes);
+                memcpy(image, buffer, copySize);
+                mediaBuffer->Unlock();
+            }
+        }
+    }
+
+    if(SUCCEEDED(hr))
+    {
+        using namespace std::chrono;
+        frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(pangolin::TimeNow()));
+    }
+
+    if(mediaBuffer)
+    {
+        mediaBuffer->Release();
+        mediaBuffer = nullptr;
+    }
+
+    if(sample)
+    {
+        sample->Release();
+        sample = nullptr;
+    }
+
+    return SUCCEEDED(hr);
+}
+
+bool UvcMediaFoundationVideo::GrabNewest(unsigned char* image, bool wait)
+{
+    return GrabNext(image, wait);
+}
+
+int UvcMediaFoundationVideo::IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code)
+{
+    if(!ksControl || ksControlNodeId == KS_CONTROL_NODE_ID_INVALID)
+    {
+        return -1;
+    }
+
+    HRESULT hr;
+    KSP_NODE s = {};
+    ULONG ulBytesReturned;
+
+    s.Property.Set = GUID_EXTENSION_UNIT_DESCRIPTOR_OV580;
+    s.Property.Id = ctrl;
+    s.NodeId = ksControlNodeId;
+
+    s.Property.Flags = KSPROPERTY_TYPE_TOPOLOGY;
+    if(req_code == UVC_GET_CUR)
+    {
+        s.Property.Flags |= KSPROPERTY_TYPE_GET;
+    }
+    else if(req_code == UVC_SET_CUR)
+    {
+        s.Property.Flags |= KSPROPERTY_TYPE_SET;
+    }
+    else if(req_code == UVC_GET_LEN)
+    {
+        if(len != sizeof(uint16_t)){
+            std::cerr << "UVC_GET_LEN requested with a buffer not the size of uint16_t" << std::endl;
+            return -1;
+        }
+
+        s.Property.Flags |= KSPROPERTY_TYPE_GET;
+        hr = ksControl->KsProperty((PKSPROPERTY)&s, sizeof(s), NULL, 0, &ulBytesReturned);
+        if(hr == HRESULT_FROM_WIN32(ERROR_MORE_DATA))
+        {
+            *(uint16_t*)data = (uint16_t)ulBytesReturned;
+            return 0;
+        }
+        return -1;
+    }
+
+    hr = ksControl->KsProperty((PKSPROPERTY)&s, sizeof(s), data, len, &ulBytesReturned);
+
+    if (hr == HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER))
+    {
+      std::cerr << "IoCtrl result is " << ulBytesReturned << ", buffer supplied is " << len << ", result truncated." << std::endl;
+      hr = S_OK;
+    }
+
+    if(FAILED(hr))
+    {
+      pango_print_error("KsProperty failed on UVC device");
+      return -1;
+    }
+
+    return 0;
+}
+
+// https://technet.microsoft.com/en-us/dd318253(v=vs.90)
+// Windows exposure time is specified in log base 2
+long to_100micros(long v)
+{
+    double res = pow(2.0, v);
+    return static_cast<long>(res * 10000);
+}
+
+long from_100micros(long val)
+{
+    double d = val * 0.0001;
+    double l = (d != 0) ? std::log2(d) : 1;
+    long v = static_cast<long>(std::roundl(l));
+    return v;
+}
+
+bool UvcMediaFoundationVideo::GetExposure(int& exp_us)
+{
+    long val = 0;
+    long flags = 0;
+
+    if(!camera_control)
+    {
+        pango_print_warn("GetExposure called with no camera_control interface");
+        return false;
+    }
+    HRESULT hr = camera_control->Get(CameraControl_Exposure, &val, &flags);
+
+    exp_us = to_100micros(val) * 100;
+    return SUCCEEDED(hr);
+}
+
+bool UvcMediaFoundationVideo::SetExposure(int exp_us)
+{
+    if(!camera_control)
+    {
+        pango_print_warn("SetExposure called with no camera_control interface");
+        return false;
+    }
+    HRESULT hr = camera_control->Set(CameraControl_Exposure, from_100micros(exp_us / 100), CameraControl_Flags_Manual);
+    return SUCCEEDED(hr);
+}
+
+bool UvcMediaFoundationVideo::GetGain(float& gain)
+{
+    if(!video_control)
+    {
+        pango_print_warn("GetGain called without gain controlls populated");
+        return false;
+    }
+
+    long camGain;
+    long flags;
+    HRESULT hr = video_control->Get(VideoProcAmp_Gain, &camGain, &flags);
+
+    if(FAILED(hr))
+    {
+        pango_print_warn("Failed to read the gain. hr:0x%x", hr);
+        return false;
+    }
+
+    // (FW bug) We can't rely on gainCamMin/gainCamMax here, as they don't correspond to the values returned
+    // by this API
+    // (HAL bug) This assumes that the caller knows to normalize back into API space
+    gain = static_cast<float>(camGain);
+
+
+    return true;
+}
+
+bool UvcMediaFoundationVideo::SetGain(float gain)
+{
+    if(!video_control)
+    {
+        pango_print_warn("SetGain called without gain controlls populated");
+        return false;
+    }
+
+    // (FW bug) We can't rely on gainCamMin/gainCamMax here, as they don't correspond to the values supported
+    // by this API
+    // (HAL bug) This assumes that the caller knows to normalize into camera register space [16, 256]
+    long targetGain = gain;
+
+    HRESULT hr = video_control->Set(VideoProcAmp_Gain, targetGain, VideoProcAmp_Flags_Manual);
+    if(FAILED(hr))
+    {
+        pango_print_warn("Failed to set gain value %f. hr:0x%x", gain, hr);
+        return false;
+    }
+    return true;
+}
+
+
+const picojson::value& UvcMediaFoundationVideo::DeviceProperties() const
+{
+    return device_properties;
+}
+
+const picojson::value& UvcMediaFoundationVideo::FrameProperties() const
+{
+    return frame_properties;
+}
+
+bool UvcMediaFoundationVideo::FindDevice(int vendorId, int productId, const std::string& instanceId)
+{
+    // Create attributes for finding UVC devices
+    IMFAttributes* searchAttributes = nullptr;
+    HRESULT hr = MFCreateAttributes(&searchAttributes, 1);
+    if(FAILED(hr))
+    {
+        pango_print_error("Unable to create UVC device search attributes");
+    }
+
+    // Request video capture devices
+    if(SUCCEEDED(hr))
+    {
+        hr = searchAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
+                                       MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID);
+        if(FAILED(hr))
+        {
+            pango_print_error("Unable to set UVC source type attribute");
+        }
+    }
+
+    // Enumerate the devices
+    IMFActivate** devices = nullptr;
+    UINT32 deviceCount = 0;
+    if(SUCCEEDED(hr))
+    {
+        hr = MFEnumDeviceSources(searchAttributes, &devices, &deviceCount);
+        if(FAILED(hr))
+        {
+            pango_print_error("Unable to enumerate UVC device sources");
+        }
+    }
+
+    std::wstring symLink;
+    bool activatedDevice = false;
+    if(SUCCEEDED(hr))
+    {
+        std::wstring wInstanceId;
+        wInstanceId.assign(instanceId.begin(), instanceId.end());
+
+        for(UINT32 i = 0; i < deviceCount; ++i)
+        {
+            // Get this device's sym link
+            WCHAR* symLinkWCStr = nullptr;
+            UINT32 symLinkLength = 0;
+            hr = devices[i]->GetAllocatedString(
+                    MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &symLinkWCStr, &symLinkLength);
+            if(FAILED(hr))
+            {
+                hr = S_OK;
+                continue;
+            }
+
+            std::wstring checkSymLink(symLinkWCStr);
+
+            // Check if this device matches the requested vendor ID and product ID
+            if(!DeviceMatches(checkSymLink, vendorId, productId, wInstanceId))
+            {
+                continue;
+            }
+
+            hr = devices[i]->ActivateObject(IID_PPV_ARGS(&mediaSource));
+            activatedDevice = SUCCEEDED(hr);
+            if(activatedDevice)
+            {
+                symLink = std::move(checkSymLink);
+            }
+            break;
+        }
+
+        if(!activatedDevice)
+        {
+            pango_print_error("Unable to activate UVC device source");
+            hr = E_FAIL;
+        }
+    }
+
+    for(UINT32 i = 0; i < deviceCount; ++i)
+    {
+        devices[i]->Release();
+        devices[i] = nullptr;
+    }
+    devices = nullptr;
+
+    CoTaskMemFree(devices);
+
+    if(searchAttributes != nullptr)
+    {
+        searchAttributes->Release();
+        searchAttributes = nullptr;
+    }
+
+    // Find the DirectShow device
+    ICreateDevEnum* dshowDevices = nullptr;
+    if(SUCCEEDED(hr))
+    {
+        hr = CoCreateInstance(CLSID_SystemDeviceEnum, 0, CLSCTX_INPROC, IID_ICreateDevEnum, (void**)&dshowDevices);
+    }
+
+    IEnumMoniker* videoInputEnumerator = nullptr;
+    if(SUCCEEDED(hr))
+    {
+        hr = dshowDevices->CreateClassEnumerator(CLSID_VideoInputDeviceCategory, &videoInputEnumerator, 0);
+    }
+
+    if(SUCCEEDED(hr))
+    {
+        IMoniker* moniker = nullptr;
+        while((hr = videoInputEnumerator->Next(1, &moniker, 0)) == S_OK)
+        {
+            IPropertyBag* propertyBag = nullptr;
+            hr = moniker->BindToStorage(0, 0, IID_IPropertyBag, (void**)&propertyBag);
+            if(FAILED(hr))
+            {
+                moniker->Release();
+                moniker = nullptr;
+                continue;
+            }
+
+            VARIANT variantPath;
+            VariantInit(&variantPath);
+            hr = propertyBag->Read(L"DevicePath", &variantPath, nullptr);
+
+            bool pathMatches;
+            if(SUCCEEDED(hr) && variantPath.vt == VT_BSTR)
+            {
+                // Determine if this is the correct device by comparing its path against the source's symbolic link
+                // This breaks the rules, but it seems to be the only way to make sure it's the correct device
+
+                // DirectShow and MediaFoundation appear to each create their own symbolic link which contains a GUID
+                // Ignore the GUID portion of the link, leaving just the path information
+                size_t braceOffset = symLink.find(L'{');
+
+                pathMatches = 0 == std::wcsncmp(symLink.c_str(), variantPath.bstrVal, braceOffset);
+            }
+            else
+            {
+                pathMatches = false;
+            }
+
+            VARIANT variantFriendlyName;
+            VariantInit(&variantFriendlyName);
+            hr = propertyBag->Read(L"FriendlyName", &variantFriendlyName, nullptr);
+
+            if(!pathMatches)
+            {
+                moniker->Release();
+                moniker = nullptr;
+                continue;
+            }
+
+            // Found the correct video input
+            break;
+        }
+
+        if(moniker)
+        {
+            hr = moniker->BindToObject(0, 0, IID_IBaseFilter, (void**)&baseFilter);
+        }
+        else
+        {
+            hr = E_FAIL;
+        }
+
+        IKsTopologyInfo* ksTopologyInfo = nullptr;
+        if(SUCCEEDED(hr))
+        {
+            hr = baseFilter->QueryInterface(__uuidof(IKsTopologyInfo), (void**)&ksTopologyInfo);
+        }
+
+        DWORD numberOfNodes = 0;
+        if(SUCCEEDED(hr))
+        {
+            hr = ksTopologyInfo->get_NumNodes(&numberOfNodes);
+        }
+
+        GUID nodeGuid;
+        for(DWORD nodeIndex = 0; nodeIndex < numberOfNodes; ++nodeIndex)
+        {
+            if(FAILED(ksTopologyInfo->get_NodeType(nodeIndex, &nodeGuid)))
+            {
+                continue;
+            }
+
+            if(nodeGuid == KSNODETYPE_DEV_SPECIFIC)
+            {
+                // This is the extension node
+                IKsNodeControl* pUnknown = nullptr;
+                hr = ksTopologyInfo->CreateNodeInstance(nodeIndex, __uuidof(IUnknown), (void**)&pUnknown);
+
+                if(SUCCEEDED(hr) && pUnknown != nullptr)
+                {
+                    hr = pUnknown->QueryInterface(__uuidof(IKsControl), (void**)&ksControl);
+                }
+                if(SUCCEEDED(hr))
+                {
+                    ksControlNodeId = nodeIndex;
+                }
+
+                if(pUnknown)
+                {
+                    pUnknown->Release();
+                    pUnknown = nullptr;
+                }
+            }
+        }
+
+        if(ksTopologyInfo)
+        {
+            ksTopologyInfo->Release();
+            ksTopologyInfo = nullptr;
+        }
+
+        if(moniker)
+        {
+            moniker->Release();
+            moniker = nullptr;
+        }
+    }
+
+    if(videoInputEnumerator)
+    {
+        videoInputEnumerator->Release();
+    }
+
+    if(dshowDevices)
+    {
+        dshowDevices->Release();
+    }
+
+    return SUCCEEDED(hr);
+}
+
+
+const GUID MFVideoFormat_Y10 =
+{
+    0x20303159,
+    0x0000,
+    0x0010,
+    0x80,
+    0x00,
+    0x00,
+    0xAA,
+    0x00,
+    0x38,
+    0x9b,
+    0x71
+};
+
+void UvcMediaFoundationVideo::InitDevice(size_t width, size_t height, bool async)
+{
+    HRESULT hr;
+
+    if (async)
+    {
+        int64_t timeout_ms = expected_fps ? 4 * 1000 / expected_fps : 500;
+        asyncSourceReader = new AsyncSourceReader(mediaSource, timeout_ms);
+        sourceReader = asyncSourceReader->AddRefReader();
+    }
+    else
+    {
+        hr = MFCreateSourceReaderFromMediaSource(mediaSource, nullptr, &sourceReader);
+        if(FAILED(hr))
+        {
+            throw VideoException(FormatString("Unable to create source reader from UVC media source (%)", hr));
+        }
+    }
+
+    // Find the closest supported resolution
+    UINT32 stride;
+    bool hasValidStride = false;
+    PixelFormat pixelFormat;
+
+    uint32_t bit_depth = 0;
+    IMFMediaType* bestMediaType = nullptr;
+    int bestError = std::numeric_limits<int>::max();
+    UINT32 bestWidth;
+    UINT32 bestHeight;
+    UINT32 bestStride;
+    GUID bestGuid;
+
+    for(DWORD i = 0;; ++i)
+    {
+        IMFMediaType* checkMediaType;
+        hr = sourceReader->GetNativeMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, i, &checkMediaType);
+        if(FAILED(hr))
+        {
+            if(hr == MF_E_NO_MORE_TYPES)
+            {
+                // Reached the end of the available media types
+                hr = S_OK;
+            }
+            else
+            {
+                pango_print_error("Failed to get UVC native media type");
+            }
+            break;
+        }
+
+        UINT32 checkWidth;
+        UINT32 checkHeight;
+        if(FAILED(MFGetAttributeSize(checkMediaType, MF_MT_FRAME_SIZE, &checkWidth, &checkHeight)))
+        {
+            checkWidth = 0;
+            checkHeight = 0;
+        }
+
+        int checkError = abs(int(checkWidth) - int(width)) + abs(int(checkHeight) - int(height));
+        if(bestError > checkError)
+        {
+            // Release the previous best
+            if(bestMediaType)
+            {
+                bestMediaType->Release();
+            }
+
+            bestError = checkError;
+            bestMediaType = checkMediaType;
+            bestWidth = checkWidth;
+            bestHeight = checkHeight;
+
+            if(FAILED(checkMediaType->GetGUID(MF_MT_SUBTYPE, &bestGuid)))
+            {
+                bestGuid = {0};
+            }
+
+            const auto stride_result = checkMediaType->GetUINT32(MF_MT_DEFAULT_STRIDE,&bestStride);
+            hasValidStride = !(stride_result == MF_E_ATTRIBUTENOTFOUND);
+        }
+        else
+        {
+            checkMediaType->Release();
+        }
+    }
+
+    if(bestMediaType)
+    {
+        if(SUCCEEDED(hr))
+        {
+            sourceReader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_VIDEO_STREAM, nullptr, bestMediaType);
+            width = bestWidth;
+            height = bestHeight;
+            if(hasValidStride)
+            {
+                stride = bestStride;
+            }
+
+            if(bestGuid == MFVideoFormat_YUY2)
+            {
+                pixelFormat = PixelFormatFromString("GRAY8");
+                bit_depth = 8;
+            }
+            else if(bestGuid == MFVideoFormat_Y10)
+            {
+                pixelFormat = PixelFormatFromString("GRAY10");
+                bit_depth = 10;
+            }
+            else if((unsigned char)((bestGuid.Data1 >> 0) & 0xff) == 'Y' && (unsigned char)((bestGuid.Data1 >> 8) & 0xff) == '8')
+            {
+                pixelFormat = PixelFormatFromString("GRAY8");
+                bit_depth = 8;
+            }
+            else
+            {
+                pango_print_warn("Unexpected MFVideoFormat with FOURCC %c.%c.%c.%c",
+                                 (unsigned char)((bestGuid.Data1 >> 0) & 0xff),
+                                 (unsigned char)((bestGuid.Data1 >> 8) & 0xff),
+                                 (unsigned char)((bestGuid.Data1 >> 16) & 0xff),
+                                 (unsigned char)((bestGuid.Data1 >> 24) & 0xff));
+            }
+        }
+
+        bestMediaType->Release();
+    }
+    else
+    {
+        width = 0;
+        height = 0;
+    }
+
+    if(SUCCEEDED(hr))
+    {
+        PopulateGainControls();
+    }
+
+    if(SUCCEEDED(hr))
+    {
+        hr = mediaSource->QueryInterface(__uuidof(IAMCameraControl), (void**)&camera_control);
+        if(FAILED(hr))
+        {
+            // On failure, soldier on without manual exposure controls
+            pango_print_warn("Failed to populate IAMCameraControl (0x%x). Exposure control will not function", hr);
+        }
+    }
+
+    if(hasValidStride)
+    {
+        size_bytes = stride * height;
+    }
+    else
+    {
+        size_bytes = width * pixelFormat.bpp * height / 8;
+    }
+    pixelFormat.channel_bit_depth = bit_depth;
+    const StreamInfo stream_info(pixelFormat, width, height, size_bytes / height, 0);
+    streams.emplace_back(stream_info);
+}
+
+void UvcMediaFoundationVideo::PopulateGainControls()
+{
+    if(!mediaSource)
+    {
+        pango_print_warn("PopulateGainControls called without a media source");
+        return;
+    }
+
+    HRESULT hr = mediaSource->QueryInterface(__uuidof(IAMVideoProcAmp) , (void**)&video_control);
+
+    // read the min and max values from the camera to allow mapping from our fixed ranges
+    if(SUCCEEDED(hr))
+    {
+        long steppingDelta;
+        long flags;
+
+        // FW bug: this range is being reported as [0, 1024], but the Get/Set pathway handles register values [16, 256]
+        hr = video_control->GetRange(VideoProcAmp_Gain, &gainCamMin, &gainCamMax, &steppingDelta, &gainCamDefault, &flags);
+
+        // should we be checking that flags are correctly set to VideoProcAmp_Flags_Manual ?
+    }
+
+    if(FAILED(hr))
+    {
+        pango_print_warn("Failed to populate gain controls (0x%x)", hr);
+        if(video_control)
+        {
+            video_control->Release();
+            video_control = nullptr;
+        }
+    }
+
+    return;
+}
+
+void UvcMediaFoundationVideo::DeinitDevice()
+{
+    if(ksControl)
+    {
+        ksControl->Release();
+        ksControl = nullptr;
+    }
+
+    ksControlNodeId = KS_CONTROL_NODE_ID_INVALID;
+
+    if(baseFilter)
+    {
+        baseFilter->Release();
+        baseFilter = nullptr;
+    }
+
+    if(sourceReader)
+    {
+        sourceReader->Release();
+        sourceReader = nullptr;
+    }
+
+    if(asyncSourceReader)
+    {
+        asyncSourceReader->Release();
+        asyncSourceReader = nullptr;
+    }
+
+    if(camera_control)
+    {
+        camera_control->Release();
+        camera_control = nullptr;
+    }
+
+    if(video_control)
+    {
+        video_control->Release();
+        video_control = nullptr;
+    }
+
+    if(mediaSource)
+    {
+        mediaSource->Shutdown();
+        mediaSource->Release();
+        mediaSource = nullptr;
+    }
+
+    streams.clear();
+}
+
+bool UvcMediaFoundationVideo::DeviceMatches(const std::wstring& symLink, int vendorId, int productId, std::wstring& instanceId)
+{
+    // Example symlink:
+    // \\?\usb#vid_05a9&pid_0581&mi_00#6&2ff327a4&2&0000#{e5323777-f976-4f5b-9b55-b94699c46e44}\global
+    //         ^^^^^^^^ ^^^^^^^^       ^^^^^^^^^^^^^^^^^
+    std::wstring symLinkString(symLink);
+    if(vendorId != 0 && !SymLinkIDMatches(symLinkString, L"vid_", vendorId))
+    {
+        return false;
+    }
+
+    if(productId != 0 && !SymLinkIDMatches(symLinkString, L"pid_", productId))
+    {
+        return false;
+    }
+
+    std::wstring instanceSearch = L"#" + instanceId + L"#";
+    if(std::string::npos == symLinkString.find(instanceSearch))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+bool UvcMediaFoundationVideo::SymLinkIDMatches(const std::wstring& symLink, const wchar_t* idStr, int id)
+{
+    // Find the ID prefix
+    size_t idOffset = symLink.find(idStr);
+    if(idOffset == std::wstring::npos)
+    {
+        // Unable to find the prefix
+        return false;
+    }
+
+    // Parse the ID as a hexadecimal number
+    int found = std::wcstol(&symLink[idOffset + std::wcslen(idStr)], nullptr, 16);
+    return id == found;
+}
+
+PANGOLIN_REGISTER_FACTORY(UvcMediaFoundationVideo)
+{
+    struct UvcMediaFoundationVideoFactory final : public TypedFactoryInterface<VideoInterface>
+    {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"uvc",10}};
+        }
+        const char* Description() const override
+        {
+            return "Use Windows Media Foundation to open UVC USB device.";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"size","640x480","Image dimension"},
+                {"fps","0","Frames per second (0:unspecified)"},
+                {"period","0","Specify frame period in microseconds (0:unspecified)"},
+                {"num","0","Open the nth device (no need for vid and pid)"},
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override
+        {
+            int vendorId = 0;
+            int productId = 0;
+
+            const std::string instanceId = uri.url.substr(uri.url.rfind("\\") + 1);
+            std::istringstream(uri.url.substr(uri.url.find("vid_", 0) + 4, 4)) >> std::hex >> vendorId;
+            std::istringstream(uri.url.substr(uri.url.find("pid_", 0) + 4, 4)) >> std::hex >> productId;
+            const ImageDim dim = uri.Get<ImageDim>("size", ImageDim(640, 480));
+            unsigned int fps = uri.Get<unsigned int>("fps", 0);  // 0 means unspecified
+            if (fps == 0 && uri.Contains("period")) {
+              uint32_t period_us = uri.Get<uint32_t>("period", 0);
+              fps = 1000000 / period_us;
+            }
+
+            return std::unique_ptr<VideoInterface>(new UvcMediaFoundationVideo(vendorId, productId, instanceId, dim.x, dim.y, fps));
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<UvcMediaFoundationVideoFactory>());
+}
+}
+

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

@@ -0,0 +1,852 @@
+/* This file is part of the Pangolin Project,
+ * http://github.com/stevenlovegrove/Pangolin
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * adapted from V4L2 video capture example
+ *
+ * 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/timer.h>
+#include <pangolin/video/drivers/v4l.h>
+#include <pangolin/video/iostream_operators.h>
+
+#include <assert.h>
+#include <iostream>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/usb/video.h>
+#include <linux/uvcvideo.h>
+#include <malloc.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define CLEAR(x) memset (&(x), 0, sizeof (x))
+
+using namespace std;
+
+namespace pangolin
+{
+
+static int xioctl(int fd, int request, void* arg)
+{
+    int r;
+    do r = ioctl (fd, request, arg);
+    while (-1 == r && EINTR == errno);
+    return r;
+}
+
+inline std::string V4lToString(int32_t v)
+{
+    //	v = ((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
+    char cc[5];
+    cc[0] = v       & 0xff;
+    cc[1] = (v>>8)  & 0xff;
+    cc[2] = (v>>16) & 0xff;
+    cc[3] = (v>>24) & 0xff;
+    cc[4] = 0;
+    return std::string(cc);
+}
+
+V4lVideo::V4lVideo(const char* dev_name, uint32_t period, io_method io, unsigned iwidth, unsigned iheight, unsigned v4l_format)
+    : io(io), fd(-1), buffers(0), n_buffers(0), running(false), period(period)
+{
+    open_device(dev_name);
+    init_device(dev_name,iwidth,iheight,0,v4l_format);
+    InitPangoDeviceProperties();
+
+    Start();
+}
+
+V4lVideo::~V4lVideo()
+{
+    if(running)
+    {
+        Stop();
+    }
+
+    uninit_device();
+    close_device();
+}
+
+void V4lVideo::InitPangoDeviceProperties()
+{
+    // Store camera details in device properties
+    device_properties[PANGO_HAS_TIMING_DATA] = true;
+}
+
+const std::vector<StreamInfo>& V4lVideo::Streams() const
+{
+    return streams;
+}
+
+size_t V4lVideo::SizeBytes() const
+{
+    return image_size;
+}
+
+bool V4lVideo::GrabNext( unsigned char* image, bool wait )
+{
+    for (;;) {
+        fd_set fds;
+        struct timeval tv;
+        int r;
+
+        FD_ZERO (&fds);
+        FD_SET (fd, &fds);
+
+        /* Timeout. */
+        tv.tv_sec = 0;
+        tv.tv_usec = 2 * period;
+
+        r = select (fd + 1, &fds, NULL, NULL, &tv);
+
+        if (-1 == r) {
+            if (EINTR == errno)
+                continue;
+
+            // This is a terminal condition that must be propogated up.
+            throw VideoException ("select", strerror(errno));
+        }
+
+        if (0 == r) {
+            // Timeout has occured - This is longer than any reasonable frame interval,
+            // but not necessarily terminal, so return false to indicate that no frame was captured.
+            return false;
+        }
+
+        if (ReadFrame(image, wait))
+            break;
+
+        /* EAGAIN - continue select loop. */
+    }
+
+    return true;
+}
+
+bool V4lVideo::GrabNewest( unsigned char* image, bool wait )
+{
+    // TODO: Implement
+    return GrabNext(image,wait);
+}
+
+int V4lVideo::ReadFrame(unsigned char* image, bool wait)
+{
+    struct v4l2_buffer buf;
+    unsigned int i;
+
+    switch (io) {
+    case IO_METHOD_READ:
+        if (-1 == read (fd, buffers[0].start, buffers[0].length)) {
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+
+            case EIO:
+                /* Could ignore EIO, see spec. */
+
+                /* fall through */
+
+            default:
+                throw VideoException("read", strerror(errno));
+            }
+        }
+        // This is a hack, this ts sould come from the device.
+        frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(pangolin::TimeNow()));
+
+        //            process_image(buffers[0].start);
+        memcpy(image,buffers[0].start,buffers[0].length);
+
+        break;
+
+    case IO_METHOD_MMAP:
+        CLEAR (buf);
+
+        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory = V4L2_MEMORY_MMAP;
+
+        if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
+            // Sleep for one period if wait is specified
+            if (wait) {
+              std::this_thread::sleep_for(std::chrono::microseconds(period));
+            }
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+
+            case EIO:
+                /* Could ignore EIO, see spec. */
+
+                /* fall through */
+
+            default:
+                throw VideoException("VIDIOC_DQBUF", strerror(errno));
+            }
+        }
+        // This is a hack, this ts sould come from the device.
+        frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(pangolin::TimeNow()));
+
+        assert (buf.index < n_buffers);
+
+        //            process_image (buffers[buf.index].start);
+        memcpy(image,buffers[buf.index].start,buffers[buf.index].length);
+
+
+        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+            throw VideoException("VIDIOC_QBUF", strerror(errno));
+
+        break;
+
+    case IO_METHOD_USERPTR:
+        CLEAR (buf);
+
+        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory = V4L2_MEMORY_USERPTR;
+
+        if (-1 == xioctl (fd, VIDIOC_DQBUF, &buf)) {
+            switch (errno) {
+            case EAGAIN:
+                return 0;
+
+            case EIO:
+                /* Could ignore EIO, see spec. */
+
+                /* fall through */
+
+            default:
+                throw VideoException("VIDIOC_DQBUF", strerror(errno));
+            }
+        }
+        // This is a hack, this ts sould come from the device.
+        frame_properties[PANGO_HOST_RECEPTION_TIME_US] = picojson::value(pangolin::Time_us(pangolin::TimeNow()));
+
+        for (i = 0; i < n_buffers; ++i)
+            if (buf.m.userptr == (unsigned long) buffers[i].start
+                    && buf.length == buffers[i].length)
+                break;
+
+        assert (i < n_buffers);
+
+        //            process_image ((void *) buf.m.userptr);
+        memcpy(image,(void *)buf.m.userptr,buf.length);
+
+
+        if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+            throw VideoException("VIDIOC_QBUF", strerror(errno));
+
+        break;
+    }
+
+    return 1;
+}
+
+void V4lVideo::Stop()
+{
+    if(running) {
+        enum v4l2_buf_type type;
+
+        switch (io) {
+        case IO_METHOD_READ:
+            /* Nothing to do. */
+            break;
+
+        case IO_METHOD_MMAP:
+        case IO_METHOD_USERPTR:
+            type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+            if (-1 == xioctl (fd, VIDIOC_STREAMOFF, &type)) {
+                // throwing on dtors is not good, commenting out for now
+                // throw VideoException("VIDIOC_STREAMOFF", strerror(errno));
+                pango_print_warn("V4lVideo::Stop() VIDIOC_STREAMOFF error: %s\n", strerror(errno));
+            }
+
+            break;
+        }
+
+        running = false;
+    }
+}
+
+void V4lVideo::Start()
+{
+    if(!running) {
+        unsigned int i;
+        enum v4l2_buf_type type;
+
+        switch (io) {
+        case IO_METHOD_READ:
+            /* Nothing to do. */
+            break;
+
+        case IO_METHOD_MMAP:
+            for (i = 0; i < n_buffers; ++i) {
+                struct v4l2_buffer buf;
+
+                CLEAR (buf);
+
+                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory      = V4L2_MEMORY_MMAP;
+                buf.index       = i;
+
+                if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+                    throw VideoException("VIDIOC_QBUF", strerror(errno));
+            }
+
+            type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+            if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
+                throw VideoException("VIDIOC_STREAMON", strerror(errno));
+
+            break;
+
+        case IO_METHOD_USERPTR:
+            for (i = 0; i < n_buffers; ++i) {
+                struct v4l2_buffer buf;
+
+                CLEAR (buf);
+
+                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory      = V4L2_MEMORY_USERPTR;
+                buf.index       = i;
+                buf.m.userptr   = (unsigned long) buffers[i].start;
+                buf.length      = buffers[i].length;
+
+                if (-1 == xioctl (fd, VIDIOC_QBUF, &buf))
+                    throw VideoException("VIDIOC_QBUF", strerror(errno));
+            }
+
+            type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+            if (-1 == xioctl (fd, VIDIOC_STREAMON, &type))
+                throw VideoException ("VIDIOC_STREAMON", strerror(errno));
+
+            break;
+        }
+
+        running = true;
+    }
+}
+
+void V4lVideo::uninit_device()
+{
+    unsigned int i;
+
+    switch (io) {
+    case IO_METHOD_READ:
+        free (buffers[0].start);
+        break;
+
+    case IO_METHOD_MMAP:
+        for (i = 0; i < n_buffers; ++i)
+            if (-1 == munmap (buffers[i].start, buffers[i].length))
+                throw VideoException ("munmap");
+        break;
+
+    case IO_METHOD_USERPTR:
+        for (i = 0; i < n_buffers; ++i)
+            free (buffers[i].start);
+        break;
+    }
+
+    free (buffers);
+}
+
+void V4lVideo::init_read(unsigned int buffer_size)
+{
+    buffers = (buffer*)calloc (1, sizeof (buffer));
+
+    if (!buffers) {
+        throw VideoException("Out of memory\n");
+    }
+
+    buffers[0].length = buffer_size;
+    buffers[0].start = malloc (buffer_size);
+
+    if (!buffers[0].start) {
+        throw VideoException("Out of memory\n");
+    }
+}
+
+void V4lVideo::init_mmap(const char* /*dev_name*/)
+{
+    struct v4l2_requestbuffers req;
+
+    CLEAR (req);
+
+    req.count               = 4;
+    req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    req.memory              = V4L2_MEMORY_MMAP;
+
+    if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
+        if (EINVAL == errno) {
+            throw VideoException("does not support memory mapping", strerror(errno));
+        } else {
+            throw VideoException ("VIDIOC_REQBUFS", strerror(errno));
+        }
+    }
+
+    if (req.count < 2) {
+        throw VideoException("Insufficient buffer memory");
+    }
+
+    buffers = (buffer*)calloc(req.count, sizeof(buffer));
+
+    if (!buffers) {
+        throw VideoException( "Out of memory\n");
+    }
+
+    for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
+        struct v4l2_buffer buf;
+
+        CLEAR (buf);
+
+        buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        buf.memory      = V4L2_MEMORY_MMAP;
+        buf.index       = n_buffers;
+
+        if (-1 == xioctl (fd, VIDIOC_QUERYBUF, &buf))
+            throw VideoException ("VIDIOC_QUERYBUF", strerror(errno));
+
+        buffers[n_buffers].length = buf.length;
+        buffers[n_buffers].start =
+                mmap (NULL /* start anywhere */,
+                      buf.length,
+                      PROT_READ | PROT_WRITE /* required */,
+                      MAP_SHARED /* recommended */,
+                      fd, buf.m.offset);
+
+        if (MAP_FAILED == buffers[n_buffers].start)
+            throw VideoException ("mmap");
+    }
+}
+
+void V4lVideo::init_userp(const char* /*dev_name*/, unsigned int buffer_size)
+{
+    struct v4l2_requestbuffers req;
+    unsigned int page_size;
+
+    page_size = getpagesize ();
+    buffer_size = (buffer_size + page_size - 1) & ~(page_size - 1);
+
+    CLEAR (req);
+
+    req.count               = 4;
+    req.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    req.memory              = V4L2_MEMORY_USERPTR;
+
+    if (-1 == xioctl (fd, VIDIOC_REQBUFS, &req)) {
+        if (EINVAL == errno) {
+            throw VideoException( "Does not support user pointer i/o", strerror(errno));
+        } else {
+            throw VideoException ("VIDIOC_REQBUFS", strerror(errno));
+        }
+    }
+
+    buffers = (buffer*)calloc(4, sizeof(buffer));
+
+    if (!buffers) {
+        throw VideoException( "Out of memory\n");
+    }
+
+    for (n_buffers = 0; n_buffers < 4; ++n_buffers) {
+        buffers[n_buffers].length = buffer_size;
+        buffers[n_buffers].start = memalign (/* boundary */ page_size,
+                                             buffer_size);
+
+        if (!buffers[n_buffers].start) {
+            throw VideoException( "Out of memory\n");
+        }
+    }
+}
+
+void V4lVideo::init_device(const char* dev_name, unsigned iwidth, unsigned iheight, unsigned ifps, unsigned v4l_format, v4l2_field field)
+{
+    struct v4l2_capability cap;
+    struct v4l2_cropcap cropcap;
+    struct v4l2_crop crop;
+    struct v4l2_format fmt;
+    struct v4l2_streamparm strm;
+
+    unsigned int min;
+
+    if (-1 == xioctl (fd, VIDIOC_QUERYCAP, &cap)) {
+        if (EINVAL == errno) {
+            throw VideoException("Not a V4L2 device", strerror(errno));
+        } else {
+            throw VideoException ("VIDIOC_QUERYCAP", strerror(errno));
+        }
+    }
+
+    if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+        throw VideoException("Not a video capture device");
+    }
+
+    switch (io) {
+    case IO_METHOD_READ:
+        if (!(cap.capabilities & V4L2_CAP_READWRITE)) {
+            throw VideoException("Does not support read i/o");
+        }
+
+        break;
+
+    case IO_METHOD_MMAP:
+    case IO_METHOD_USERPTR:
+        if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+            throw VideoException("Does not support streaming i/o");
+        }
+
+        break;
+    }
+
+
+    /* Select video input, video standard and tune here. */
+
+    CLEAR (cropcap);
+
+    cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+    if (0 == xioctl (fd, VIDIOC_CROPCAP, &cropcap)) {
+        crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        crop.c = cropcap.defrect; /* reset to default */
+
+        if (-1 == xioctl (fd, VIDIOC_S_CROP, &crop)) {
+            switch (errno) {
+            case EINVAL:
+                /* Cropping not supported. */
+                break;
+            default:
+                /* Errors ignored. */
+                break;
+            }
+        }
+    } else {
+        /* Errors ignored. */
+    }
+
+    CLEAR (fmt);
+
+    if(iwidth!=0 && iheight!=0) {
+        fmt.type                = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt.fmt.pix.width       = iwidth;
+        fmt.fmt.pix.height      = iheight;
+        fmt.fmt.pix.pixelformat = v4l_format;
+        fmt.fmt.pix.field       = field;
+
+        if (-1 == xioctl (fd, VIDIOC_S_FMT, &fmt))
+            throw VideoException("VIDIOC_S_FMT", strerror(errno));
+    }else{
+        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+
+        /* Preserve original settings as set by v4l2-ctl for example */
+        if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
+            throw VideoException("VIDIOC_G_FMT", strerror(errno));
+    }
+
+    /* Buggy driver paranoia. */
+    min = fmt.fmt.pix.width * 2;
+    if (fmt.fmt.pix.bytesperline < min)
+        fmt.fmt.pix.bytesperline = min;
+    min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
+    if (fmt.fmt.pix.sizeimage < min)
+        fmt.fmt.pix.sizeimage = min;
+
+    /* Note VIDIOC_S_FMT may change width and height. */
+    width = fmt.fmt.pix.width;
+    height = fmt.fmt.pix.height;
+    image_size = fmt.fmt.pix.sizeimage;
+
+    if(ifps!=0)
+    {
+        CLEAR(strm);
+        strm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        strm.parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
+        strm.parm.capture.timeperframe.numerator = 1;
+        strm.parm.capture.timeperframe.denominator = ifps;
+
+        if (-1 == xioctl (fd, VIDIOC_S_PARM, &fmt))
+            throw VideoException("VIDIOC_S_PARM", strerror(errno));
+
+        fps = (float)strm.parm.capture.timeperframe.denominator / strm.parm.capture.timeperframe.numerator;
+    }else{
+        fps = 0;
+    }
+
+    switch (io) {
+    case IO_METHOD_READ:
+        init_read (fmt.fmt.pix.sizeimage);
+        break;
+
+    case IO_METHOD_MMAP:
+        init_mmap (dev_name );
+        break;
+
+    case IO_METHOD_USERPTR:
+        init_userp (dev_name, fmt.fmt.pix.sizeimage);
+        break;
+    }
+
+    uint32_t bit_depth = 0;
+
+    std::string spix="GRAY8";
+    if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_GREY) {
+        spix="GRAY8";
+        bit_depth = 8;
+    }else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_YUYV) {
+        spix="YUYV422";
+        bit_depth = 8;
+    } else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_UYVY) {
+        spix="UYVY422";
+        bit_depth = 8;
+    }else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_Y16) {
+        spix="GRAY16LE";
+        bit_depth = 16;
+    }else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_Y10) {
+        spix="GRAY10";
+        bit_depth = 10;
+    }else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_Y12) {
+        spix="GRAY12";
+        bit_depth = 12;
+    }else if(fmt.fmt.pix.pixelformat == V4L2_PIX_FMT_RGB24) {
+        spix="RGB24";
+        bit_depth = 24;
+    }else{
+        // TODO: Add method to translate from V4L to FFMPEG type.
+        std::cerr << "V4L Format " << V4lToString(fmt.fmt.pix.pixelformat)
+                  << " not recognised. Defaulting to '" << spix << std::endl;
+    }
+
+    PixelFormat pfmt = PixelFormatFromString(spix);
+    pfmt.channel_bit_depth = bit_depth;
+    const StreamInfo stream_info(pfmt, width, height, (width*pfmt.bpp)/8, 0);
+
+    streams.push_back(stream_info);
+}
+
+bool V4lVideo::SetExposure(int exposure_us)
+{
+    struct v4l2_ext_controls ctrls = {};
+    struct v4l2_ext_control ctrl = {};
+
+    ctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
+    // v4l specifies exposure in 100us units
+    ctrl.value = int(exposure_us / 100.0);
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.count = 1;
+    ctrls.controls = &ctrl;
+
+    if (-1 == xioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)){
+        pango_print_warn("V4lVideo::SetExposure() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool V4lVideo::GetExposure(int& exposure_us)
+{
+    struct v4l2_ext_controls ctrls = {};
+    struct v4l2_ext_control ctrl = {};
+
+    ctrl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
+    ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
+    ctrls.count = 1;
+    ctrls.controls = &ctrl;
+
+    if (-1 == xioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls)){
+        pango_print_warn("V4lVideo::GetExposure() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        // v4l specifies exposure in 100us units
+        exposure_us = ctrls.controls->value * 100;
+        return true;
+    }
+}
+
+bool V4lVideo::SetGain(float gain)
+{
+    struct v4l2_control control;
+    control.id = V4L2_CID_GAIN;
+    control.value = gain;
+
+    if (-1 == xioctl (fd, VIDIOC_S_CTRL, &control)) {
+        pango_print_warn("V4lVideo::SetGain() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        return true;
+    }
+}
+
+bool V4lVideo::GetGain(float& gain)
+{
+    struct v4l2_control control;
+    control.id = V4L2_CID_GAIN;
+
+    if (-1 == xioctl (fd, VIDIOC_G_CTRL, &control)) {
+        pango_print_warn("V4lVideo::GetGain() ioctl error: %s\n", strerror(errno));
+        return false;
+    } else {
+        gain = control.value;
+        return true;
+    }
+}
+
+void V4lVideo::close_device()
+{
+    if (-1 == close (fd))
+        throw VideoException("close");
+
+    fd = -1;
+}
+
+void V4lVideo::open_device(const char* dev_name)
+{
+    struct stat st;
+
+    if (-1 == stat (dev_name, &st)) {
+        throw VideoException("Cannot stat device", strerror(errno));
+    }
+
+    if (!S_ISCHR (st.st_mode)) {
+        throw VideoException("Not device");
+    }
+
+    fd = open (dev_name, O_RDWR /* required */ | O_NONBLOCK, 0);
+
+    if (-1 == fd) {
+        throw VideoException("Cannot open device");
+    }
+}
+
+int V4lVideo::IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, UvcRequestCode req_code)
+{
+    struct uvc_xu_control_query xu;
+    xu.unit = unit;
+    xu.selector = ctrl;
+    xu.size = len;
+    xu.data = data;
+    xu.query = req_code;
+
+    int ret = ioctl(fd, UVCIOC_CTRL_QUERY, &xu);
+    if (ret == -1) {
+        pango_print_warn("V4lVideo::IoCtrl() ioctl error: %d\n", errno);
+        return ret;
+    }
+    return 0;
+}
+
+//! Access JSON properties of device
+const picojson::value& V4lVideo::DeviceProperties() const
+{
+        return device_properties;
+}
+
+//! Access JSON properties of most recently captured frame
+const picojson::value& V4lVideo::FrameProperties() const
+{
+    return frame_properties;
+}
+
+PANGOLIN_REGISTER_FACTORY(V4lVideo)
+{
+    struct V4lVideoFactory final : public TypedFactoryInterface<VideoInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"v4l",0}, {"uvc",20}};
+        }
+        const char* Description() const override
+        {
+            return "Use V4L to open a video device";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"method","mmap","Possible values are: read, mmap, userptr"},
+                {"size","0x0","Desired image size"},
+                {"format","YUYV422","Desired image format"},
+                {"period","50000","Period in microsecs"},
+                {"ExposureTime","10000","Exposure time in microsecs"},
+                {"Gain","1","Image gain parameter"}
+            }};
+        }
+        std::unique_ptr<VideoInterface> Open(const Uri& uri) override {
+            ParamReader reader(Params(), uri);
+
+            const std::string smethod = reader.Get<std::string>("method");
+            const ImageDim desired_dim = reader.Get<ImageDim>("size");
+            const std::string sformat = reader.Get<std::string>("format");
+
+            unsigned format = V4L2_PIX_FMT_YUYV;
+
+            if(sformat == "GRAY8") {
+                format = V4L2_PIX_FMT_GREY;
+            } else if(sformat == "YUYV422") {
+                format = V4L2_PIX_FMT_YUYV;
+            } else if(sformat == "UYVY422") {
+                format = V4L2_PIX_FMT_UYVY;
+            } else if(sformat == "GRAY16LE") {
+                format = V4L2_PIX_FMT_Y16;
+            } else if(sformat == "GRAY10") {
+                format = V4L2_PIX_FMT_Y10;
+            } else if(sformat == "GRAY12") {
+                format = V4L2_PIX_FMT_Y12;
+            } else if(sformat == "RGB24") {
+                format = V4L2_PIX_FMT_RGB24;
+            }
+
+            io_method method = IO_METHOD_MMAP;
+
+            if(smethod == "read" ) {
+                method = IO_METHOD_READ;
+            }else if(smethod == "mmap" ) {
+                method = IO_METHOD_MMAP;
+            }else if(smethod == "userptr" ) {
+                method = IO_METHOD_USERPTR;
+            }
+
+            uint32_t period = reader.Get<int>("period");
+
+            V4lVideo* video_raw = new V4lVideo(uri.url.c_str(), period, method, desired_dim.x, desired_dim.y, format);
+            if(video_raw  && uri.Contains("ExposureTime")) {
+                static_cast<V4lVideo*>(video_raw)->SetExposure(reader.Get<int>("ExposureTime"));
+            }
+            if(video_raw  && uri.Contains("Gain")) {
+                static_cast<V4lVideo*>(video_raw)->SetGain(reader.Get<int>("Gain"));
+            }
+            return std::unique_ptr<VideoInterface>(video_raw);
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<VideoInterface>(std::make_shared<V4lVideoFactory>());
+}
+
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/stream_encoder_factory.cpp

@@ -0,0 +1,62 @@
+#include <pangolin/video/stream_encoder_factory.h>
+
+#include <cctype>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/type_convert.h>
+
+namespace pangolin {
+
+StreamEncoderFactory& StreamEncoderFactory::I()
+{
+    static StreamEncoderFactory instance;
+    return instance;
+}
+
+struct EncoderDetails
+{
+    std::string encoder_name;
+    ImageFileType file_type;
+    float quality;
+};
+
+inline EncoderDetails EncoderDetailsFromString(const std::string& encoder_spec)
+{
+    std::string::const_reverse_iterator rit = encoder_spec.rbegin();
+    for(; std::isdigit(*rit) && rit != encoder_spec.rend(); ++rit );
+
+    // png, tga, ...
+    std::string encoder_name(encoder_spec.begin(), rit.base());
+    ToLower(encoder_name);
+
+    // Quality of encoding for lossy encoders [0..100]
+    float quality = 100.0;
+    if(rit != encoder_spec.rbegin()) {
+        quality = pangolin::Convert<float,std::string>::Do(std::string(rit.base(),encoder_spec.end()));
+    }
+
+
+    return { encoder_name, NameToImageFileType(encoder_name), quality};
+}
+
+ImageEncoderFunc StreamEncoderFactory::GetEncoder(const std::string& encoder_spec, const PixelFormat& fmt)
+{
+    const EncoderDetails encdet = EncoderDetailsFromString(encoder_spec);
+    if(encdet.file_type == ImageFileTypeUnknown)
+        throw std::invalid_argument("Unsupported encoder format: " + encoder_spec);
+
+    return [fmt,encdet](std::ostream& os, const Image<unsigned char>& img){
+        SaveImage(img,fmt,os,encdet.file_type,true,encdet.quality);
+    };
+}
+
+ImageDecoderFunc StreamEncoderFactory::GetDecoder(const std::string& encoder_spec, const PixelFormat& fmt)
+{
+    const EncoderDetails encdet = EncoderDetailsFromString(encoder_spec);
+    PANGO_ENSURE(encdet.file_type != ImageFileTypeUnknown);
+
+    return [fmt,encdet](std::istream& is){
+        return LoadImage(is,encdet.file_type);
+    };
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/video.cpp

@@ -0,0 +1,75 @@
+/* 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/video.h>
+#include <pangolin/video/video_output.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/factory/RegisterFactoriesVideoInterface.h>
+#include <pangolin/factory/RegisterFactoriesVideoOutputInterface.h>
+
+namespace pangolin
+{
+
+std::unique_ptr<VideoInterface> OpenVideo(const std::string& str_uri)
+{
+    return OpenVideo( ParseUri(str_uri) );
+}
+
+std::unique_ptr<VideoInterface> OpenVideo(const Uri& uri)
+{
+    RegisterFactoriesVideoInterface();
+
+    std::unique_ptr<VideoInterface> video =
+            FactoryRegistry::I()->Construct<VideoInterface>(uri);
+
+    if(!video) {
+        throw VideoExceptionNoKnownHandler(uri.scheme);
+    }
+
+    return video;
+}
+
+std::unique_ptr<VideoOutputInterface> OpenVideoOutput(const std::string& str_uri)
+{
+    return OpenVideoOutput( ParseUri(str_uri) );
+}
+
+std::unique_ptr<VideoOutputInterface> OpenVideoOutput(const Uri& uri)
+{
+    RegisterFactoriesVideoOutputInterface();
+
+    std::unique_ptr<VideoOutputInterface> video =
+            FactoryRegistry::I()->Construct<VideoOutputInterface>(uri);
+
+    if(!video) {
+        throw VideoException("No known video handler for URI '" + uri.scheme + "', or device not found.");
+    }
+
+    return video;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/video_help.cpp

@@ -0,0 +1,45 @@
+#include <pangolin/video/video_help.h>
+#include <pangolin/video/video_interface.h>
+
+#include <pangolin/factory/RegisterFactoriesVideoInterface.h>
+#include <pangolin/factory/RegisterFactoriesVideoOutputInterface.h>
+
+namespace pangolin
+{
+
+void PrintPixelFormats(std::ostream& out, bool color)
+{
+    const std::string c_normal = color ? "\033[0m"  : "";
+    const std::string c_alias  = color ? "\033[32m" : "";
+
+   out << "Supported pixel format codes (and their respective bits-per-pixel):" << std::endl;
+   std::vector<pangolin::PixelFormat> pixelFormats = pangolin::GetSupportedPixelFormats();
+   for(const auto& format: pixelFormats ){
+       out << c_alias << format.format << c_normal << " (" << format.bpp << "), ";
+   }
+   out << std::endl;
+}
+
+void VideoHelp( std::ostream& out, const std::string& scheme_filter, HelpVerbosity verbosity)
+{
+    RegisterFactoriesVideoInterface();
+
+#ifndef _WIN32_
+    const bool use_color = true;
+#else
+    const bool use_color = false;
+#endif
+
+    if( verbosity >= HelpVerbosity::SYNOPSIS ) {
+        PrintSchemeHelp(out, use_color);
+        out << std::endl;
+    }
+
+    PrintFactoryRegistryDetails(out, *FactoryRegistry::I(), typeid(VideoInterface), scheme_filter, verbosity, use_color);
+
+    if( verbosity >= HelpVerbosity::PARAMS ) {
+        PrintPixelFormats(out, use_color);
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/src/video_input.cpp

@@ -0,0 +1,220 @@
+/* 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/video_input.h>
+#include <pangolin/video/video_output.h>
+
+namespace pangolin
+{
+
+VideoInput::VideoInput()
+    : frame_num(0), record_frame_skip(1), record_once(false), record_continuous(false)
+{
+}
+
+VideoInput::VideoInput(
+    const std::string& input_uri,
+    const std::string& output_uri
+    ) : frame_num(0), record_frame_skip(1), record_once(false), record_continuous(false)
+{
+    Open(input_uri, output_uri);
+}
+
+void VideoInput::Open(
+    const std::string& input_uri,
+    const std::string& output_uri
+    )
+{
+    uri_input = ParseUri(input_uri);
+    uri_output = ParseUri(output_uri);
+
+    if (uri_output.scheme == "file") {
+        // Default to pango output
+        uri_output.scheme = "pango";
+    }
+
+    // Start off playing from video_src
+    video_src = OpenVideo(input_uri);
+
+    // Reset state
+    frame_num = 0;
+    videos.resize(1);
+    videos[0] = video_src.get();
+}
+
+void VideoInput::Close()
+{
+    // Reset this first so that recording data gets written out to disk ASAP.
+    video_recorder.reset();
+
+    video_src.reset();
+    videos.clear();
+}
+
+VideoInput::~VideoInput()
+{
+    Close();
+}
+
+const std::string& VideoInput::LogFilename() const
+{
+    return uri_output.url;
+}
+
+std::string& VideoInput::LogFilename()
+{
+    return uri_output.url;
+}
+
+bool VideoInput::Grab( unsigned char* buffer, std::vector<Image<unsigned char> >& images, bool wait, bool newest)
+{
+    if( !video_src ) throw VideoException("No video source open");
+
+    bool success;
+
+    if(newest) {
+        success = GrabNewest(buffer, wait);
+    }else{
+        success = GrabNext(buffer, wait);
+    }
+
+    if(success) {
+        images.clear();
+        for(size_t s=0; s < Streams().size(); ++s) {
+            images.push_back(Streams()[s].StreamImage(buffer));
+        }
+    }
+
+    return success;
+}
+
+void VideoInput::InitialiseRecorder()
+{
+    video_recorder.reset();
+    video_recorder = OpenVideoOutput(uri_output);
+    video_recorder->SetStreams(
+        video_src->Streams(), uri_input.full_uri,
+        GetVideoDeviceProperties(video_src.get())
+    );
+}
+
+void VideoInput::Record()
+{
+    // Switch sub-video
+    videos.resize(1);
+    videos[0] = video_src.get();
+
+    // Initialise recorder and ensure src is started
+    InitialiseRecorder();
+    video_src->Start();
+    frame_num = 0;
+    record_continuous = true;
+}
+
+void VideoInput::RecordOneFrame()
+{
+    // Append to existing video.
+    if(!video_recorder) {
+        InitialiseRecorder();
+    }
+    record_continuous = false;
+    record_once = true;
+
+    // Switch sub-video
+    videos.resize(1);
+    videos[0] = video_src.get();
+}
+
+size_t VideoInput::SizeBytes() const
+{
+    if( !video_src ) throw VideoException("No video source open");
+    return video_src->SizeBytes();
+}
+
+const std::vector<StreamInfo>& VideoInput::Streams() const
+{
+    return video_src->Streams();
+}
+
+void VideoInput::Start()
+{
+    video_src->Start();
+}
+
+void VideoInput::Stop()
+{
+    if(IsRecording()) {
+        video_recorder.reset();
+    }else{
+        video_src->Stop();
+    }
+}
+
+bool VideoInput::GrabNext( unsigned char* image, bool wait )
+{
+    frame_num++;
+
+    const bool should_record = (record_continuous && !(frame_num % record_frame_skip)) || record_once;
+
+    const bool success = video_src->GrabNext(image, wait);
+
+    if( should_record && video_recorder != 0 && success) {
+        video_recorder->WriteStreams(image, GetVideoFrameProperties(video_src.get()) );
+        record_once = false;
+    }
+
+    return success;
+}
+
+bool VideoInput::GrabNewest( unsigned char* image, bool wait )
+{
+    frame_num++;
+
+    const bool should_record = (record_continuous && !(frame_num % record_frame_skip)) || record_once;
+    const bool success = video_src->GrabNewest(image,wait);
+
+    if( should_record && video_recorder != 0 && success)
+    {
+        video_recorder->WriteStreams(image, GetVideoFrameProperties(video_src.get()) );
+        record_once = false;
+    }
+
+    return success;
+}
+
+void VideoInput::SetTimelapse(size_t one_in_n_frames)
+{
+    record_frame_skip = one_in_n_frames;
+}
+
+bool VideoInput::IsRecording() const
+{
+    return video_recorder != 0;
+}
+
+}
+

third-party/DPVO/Pangolin/components/pango_video/src/video_output.cpp

@@ -0,0 +1,137 @@
+/* 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.
+ */
+
+#include <pangolin/video/video.h>
+#include <pangolin/video/video_output.h>
+
+#include <pangolin/video/drivers/pango_video_output.h>
+
+#include <pangolin/utils/file_utils.h>
+
+namespace pangolin
+{
+VideoOutput::VideoOutput()
+{
+}
+
+VideoOutput::VideoOutput(const std::string& uri)
+{
+    Open(uri);
+}
+
+VideoOutput::~VideoOutput()
+{
+}
+
+bool VideoOutput::IsOpen() const
+{
+    return recorder.get() != nullptr;
+}
+
+void VideoOutput::Open(const std::string& str_uri)
+{
+    Close();
+    uri = ParseUri(str_uri);
+    recorder = OpenVideoOutput(uri);
+}
+
+void VideoOutput::Close()
+{
+    recorder.reset();
+}
+
+const std::vector<StreamInfo>& VideoOutput::Streams() const
+{
+    return recorder->Streams();
+}
+
+void VideoOutput::SetStreams(const std::vector<StreamInfo>& streams,
+                             const std::string& uri,
+                             const picojson::value& properties)
+{
+    recorder->SetStreams(streams, uri, properties);
+}
+
+int VideoOutput::WriteStreams(const unsigned char* data, const picojson::value& frame_properties)
+{
+    return recorder->WriteStreams(data, frame_properties);
+}
+
+bool VideoOutput::IsPipe() const
+{
+    return recorder->IsPipe();
+}
+
+void VideoOutput::AddStream(const PixelFormat& pf, size_t w, size_t h, size_t pitch)
+{
+    streams.emplace_back(pf, w, h, pitch, nullptr);
+}
+
+void VideoOutput::AddStream(const PixelFormat& pf, size_t w, size_t h)
+{
+    AddStream(pf, w, h, w * pf.bpp / 8);
+}
+
+void VideoOutput::SetStreams(const std::string& uri, const picojson::value& properties)
+{
+    size_t offset = 0;
+    for(size_t i = 0; i < streams.size(); i++)
+    {
+        streams[i] = StreamInfo(streams[i].PixFormat(),
+                                streams[i].Width(),
+                                streams[i].Height(),
+                                streams[i].Pitch(),
+                                (unsigned char*)offset);
+        offset += streams[i].SizeBytes();
+    }
+    SetStreams(streams, uri, properties);
+}
+
+size_t VideoOutput::SizeBytes(void) const
+{
+    size_t total = 0;
+    for(const StreamInfo& si : recorder->Streams())
+        total += si.SizeBytes();
+    return total;
+}
+
+std::vector<Image<unsigned char>> VideoOutput::GetOutputImages(unsigned char* buffer) const
+{
+    std::vector<Image<unsigned char>> images;
+    for(size_t s = 0; s < recorder->Streams().size(); ++s)
+    {
+        images.push_back(recorder->Streams()[s].StreamImage(buffer));
+    }
+    return images;
+}
+
+std::vector<Image<unsigned char>> VideoOutput::GetOutputImages(std::vector<unsigned char>& buffer) const
+{
+    buffer.resize(SizeBytes());
+    return GetOutputImages(buffer.data());
+}
+}

third-party/DPVO/Pangolin/components/pango_video/tests/tests_video_loading.cpp

@@ -0,0 +1,26 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+#include <pangolin/video/video.h>
+#include <pangolin/factory/factory_registry.h>
+
+TEST_CASE( "Loading built in video driver" ) {
+    // If this throws, we've probably messed up the factory loading stuff again...
+    auto video = pangolin::OpenVideo("test:[size=123x345,n=1,fmt=RGB24]//");
+
+    REQUIRE(video.get());
+    REQUIRE(video->SizeBytes() == 123*345*3);
+    REQUIRE(video->Streams().size() == 1);
+    REQUIRE(video->Streams()[0].PixFormat().format == "RGB24");
+    REQUIRE(video->Streams()[0].Width() == 123);
+    REQUIRE(video->Streams()[0].Height() == 345);
+
+    std::unique_ptr<unsigned char[]> image(new unsigned char[video->SizeBytes()]);
+    const bool success = video->GrabNext(image.get());
+    REQUIRE(success);
+}
+
+TEST_CASE( "Error when providing the wrong arguments" )
+{
+    REQUIRE_THROWS_AS(pangolin::OpenVideo("test:[width=123,height=345,n=3,fmt=RGB24]//"), pangolin::FactoryRegistry::ParameterMismatchException);
+}

third-party/DPVO/Pangolin/components/pango_video/tests/tests_video_uri.cpp

@@ -0,0 +1,72 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+#include <string>
+#include <limits>
+#include <functional>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/video/video.h>
+#include <pangolin/video/video_exception.h>
+#include <pangolin/video/iostream_operators.h>
+
+template<typename T>
+inline void ExpectExceptionWithMessageFromAction(
+    std::function<void()> action,
+    const std::string& exceptionMessageBegin
+) {
+    try
+    {
+        action();
+
+        FAIL("The action succeeded when it should have failed.");
+    }
+    catch(const T& ex)
+    {
+        std::string exceptionMessage = std::string(ex.what());
+        std::string exceptionMessageRelevantPortion
+            = exceptionMessage.substr(0, exceptionMessageBegin.size());
+        REQUIRE(exceptionMessageRelevantPortion.compare(exceptionMessageBegin) == 0);
+    }
+    catch(...)
+    {
+        FAIL("Another kind of exception was thrown to the one expected");
+    }
+}
+
+TEST_CASE("Empty Uri Test")
+{
+    REQUIRE_THROWS_AS(pangolin::OpenVideo(""), pangolin::VideoException);
+}
+
+TEST_CASE("Uri Dimension Legal Separator Character")
+{
+
+    using char_t = std::string::value_type;
+    using char_nl = std::numeric_limits<char_t>;
+    for(char_t c = char_nl::min(); c < char_nl::max(); ++c)
+    {
+        if(c == '\0' || c == '=' || c == ']' || c == ',' || (c >= '0' && c <= '9'))
+        {
+            continue;
+        }
+
+        const int dimWidth = 123, dimHeight = 456;
+        const std::string encodedDim = std::to_string(dimWidth) + c
+            + std::to_string(dimHeight);
+        const std::string fullUri = "abc:[size=" + encodedDim + ",other=value]";
+        const pangolin::Uri pangoUri = pangolin::ParseUri(fullUri);
+
+        REQUIRE(pangoUri.params.size() == 2);
+        REQUIRE( pangoUri.params[0].first == std::string("size"));
+        REQUIRE( pangoUri.params[1].first == std::string("other"));
+
+        const pangolin::ImageDim dim
+            = pangoUri.Get<pangolin::ImageDim>("size", pangolin::ImageDim(0,0));
+        REQUIRE( dim.x == dimWidth);
+        REQUIRE( dim.y == dimHeight);
+
+        const std::string otherValue = pangoUri.Get<std::string>("other", "");
+        REQUIRE( otherValue == std::string("value"));
+
+    }
+}

third-party/DPVO/Pangolin/components/pango_windowing/CMakeLists.txt

@@ -0,0 +1,102 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    target_link_libraries(${COMPONENT} PRIVATE "-framework Cocoa" )
+    target_sources( ${COMPONENT}
+        PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/src/display_osx.mm
+        ${CMAKE_CURRENT_LIST_DIR}/src/PangolinNSApplication.mm
+        ${CMAKE_CURRENT_LIST_DIR}/src/PangolinNSGLView.mm
+    )
+    target_compile_definitions(${COMPONENT} PUBLIC "PANGO_DEFAULT_WIN_URI=\"cocoa\"")
+    target_compile_options(${COMPONENT} PRIVATE
+        $<$<OR:$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:GNU>>:
+        -Wno-deprecated-declarations>
+    )
+    PangolinRegisterFactory(WindowInterface OsxWindow)
+elseif(WIN32 OR WIN64)
+    target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/display_win.cpp )
+    target_compile_definitions(${COMPONENT} PUBLIC "PANGO_DEFAULT_WIN_URI=\"winapi\"")
+    PangolinRegisterFactory(WindowInterface WinWindow)
+elseif(EMSCRIPTEN)
+    target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/display_emscripten.cpp )
+    target_compile_definitions(${COMPONENT} PUBLIC "PANGO_DEFAULT_WIN_URI=\"emscripten\"")
+    PangolinRegisterFactory(WindowInterface EmscriptenWindow)
+else()
+    find_package(X11 QUIET)
+    if(X11_FOUND)
+        target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/display_x11.cpp )
+        target_link_libraries(${COMPONENT} PRIVATE ${X11_LIBRARIES} )
+        target_include_directories(${COMPONENT} PRIVATE ${X11_INCLUDE_DIR} )
+        PangolinRegisterFactory(WindowInterface X11Window)
+    endif()
+
+    # Wayland
+    find_package(PkgConfig)
+    pkg_check_modules(WAYLAND_CLIENT wayland-client QUIET)
+    pkg_check_modules(wayland-protocols QUIET wayland-protocols>=1.13)
+    if(WAYLAND_CLIENT_FOUND AND wayland-protocols_FOUND)
+        pkg_check_modules(WAYLAND_EGL wayland-egl REQUIRED)
+        pkg_check_modules(WAYLAND_CURSOR wayland-cursor REQUIRED)
+        pkg_check_modules(xkbcommon REQUIRED xkbcommon)
+
+        target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/display_wayland.cpp )
+
+        target_link_libraries(${COMPONENT} PRIVATE ${X11_LIBRARIES}
+            ${WAYLAND_CLIENT_LIBRARIES}
+            ${WAYLAND_EGL_LIBRARIES}
+            ${WAYLAND_CURSOR_LIBRARIES}
+            ${xkbcommon_LIBRARIES}
+        )
+
+        # find Wayland protocols
+        pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir)
+
+        # find 'wayland-scanner' executable
+        pkg_get_variable(WAYLAND_SCANNER wayland-scanner wayland_scanner)
+
+        # generate protocol implementation
+        set(XDG_PROT_DEF "${WAYLAND_PROTOCOLS_DIR}/stable/xdg-shell/xdg-shell.xml")
+        add_custom_command(
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-protocol.h
+            COMMAND ${WAYLAND_SCANNER} client-header ${XDG_PROT_DEF} xdg-shell-client-protocol.h)
+        add_custom_command(
+            OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-protocol.c
+            COMMAND ${WAYLAND_SCANNER} private-code ${XDG_PROT_DEF} xdg-shell-protocol.c
+            DEPENDS xdg-shell-client-protocol.h)
+        target_include_directories(${COMPONENT} PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+        target_sources( ${COMPONENT} PRIVATE xdg-shell-protocol.c)
+
+        # register window factory
+        target_compile_definitions(${COMPONENT} PUBLIC "PANGO_DEFAULT_WIN_URI=\"wayland\"")
+        PangolinRegisterFactory(WindowInterface WaylandWindow)
+    else()
+        target_compile_definitions(${COMPONENT} PUBLIC "PANGO_DEFAULT_WIN_URI=\"x11\"")
+    endif()
+endif()
+
+# headless offscreen rendering via EGL
+if(_LINUX_)
+    set(OpenGL_GL_PREFERENCE "GLVND")
+endif()
+find_package(OpenGL QUIET COMPONENTS EGL)
+if(OpenGL_EGL_FOUND)
+    target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/display_headless.cpp )
+    target_link_libraries(${COMPONENT} PRIVATE ${OPENGL_egl_LIBRARY} )
+    PangolinRegisterFactory(WindowInterface HeadlessWindow)
+endif()
+
+
+target_sources(${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/window.cpp)
+target_link_libraries(${COMPONENT} PUBLIC pango_core pango_opengl )
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" DESTINATION ${CMAKE_INSTALL_PREFIX})
+install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include" DESTINATION ${CMAKE_INSTALL_PREFIX})
+
+# Create RegisterFactoriesWindowInterface() method call file to load built drivers and add as source
+create_factory_registry_file( "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory" WindowInterface )
+target_sources(${COMPONENT} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory/RegisterFactoriesWindowInterface.h")

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/EmscriptenWindow.h

@@ -0,0 +1,72 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2018 Andrey Mnatsakanov
+ *
+ * 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/windowing/window.h>
+
+#include <stdexcept>
+#include <string>
+#include <list>
+
+#include <emscripten.h>
+#include <emscripten/html5.h>
+
+namespace pangolin
+{
+
+struct EmscriptenWindow : public WindowInterface
+{
+ public:
+    EmscriptenWindow();
+
+    ~EmscriptenWindow();
+
+    void Move(int x, int y) override;
+
+    void Resize(unsigned int w, unsigned int h) override;
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void SwapBuffers() override;
+
+    void ProcessEvents() override;
+
+    int x;
+    int y;
+    KeyModifierBitmask key_modifier_state;
+ private:
+    EMSCRIPTEN_WEBGL_CONTEXT_HANDLE ctx = NULL;
+    GLuint program = 0;
+    bool done_init_events;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/OsxWindow.h

@@ -0,0 +1,63 @@
+/* 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/platform.h>
+#include <pangolin/windowing/window.h>
+#include <pangolin/windowing/PangolinNSApplication.h>
+#include <pangolin/windowing/PangolinNSGLView.h>
+
+namespace pangolin
+{
+
+struct OsxWindow : public WindowInterface
+{
+    OsxWindow(const std::string& title, int width, int height, bool USE_RETINA);
+
+    ~OsxWindow();
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void Move(int x, int y) override;
+
+    void Resize(unsigned int w, unsigned int h) override;
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void ProcessEvents() override;
+
+    void SwapBuffers() override;
+
+private:
+    NSWindow* _window;
+    PangolinNSGLView *view;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/PangolinNSApplication.h

@@ -0,0 +1,61 @@
+/* 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
+
+#import <Carbon/Carbon.h>
+#import <Cocoa/Cocoa.h>
+#include <pangolin/windowing/window.h>
+
+////////////////////////////////////////////////////////////////////
+// PangolinNSApplication
+////////////////////////////////////////////////////////////////////
+
+@interface PangolinNSApplication : NSObject {
+}
+
++ (void)run_pre;
++ (void)run_step;
+
+@end
+
+////////////////////////////////////////////////////////////////////
+// PangolinWindowDelegate
+////////////////////////////////////////////////////////////////////
+
+@interface PangolinWindowDelegate : NSObject <NSWindowDelegate>{
+    @public pangolin::WindowInterface* osx_window;
+}
+@end
+
+////////////////////////////////////////////////////////////////////
+// PangolinAppDelegate
+////////////////////////////////////////////////////////////////////
+
+@interface PangolinAppDelegate : NSObject <NSApplicationDelegate>
+
+@end

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/PangolinNSGLView.h

@@ -0,0 +1,44 @@
+/* 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
+
+#import <Carbon/Carbon.h>
+#import <Cocoa/Cocoa.h>
+#include <pangolin/windowing/window.h>
+
+////////////////////////////////////////////////////////////////////
+// PangolinNSGLView
+////////////////////////////////////////////////////////////////////
+
+@interface PangolinNSGLView : NSOpenGLView
+{
+    float backing_scale;
+    @public pangolin::WindowInterface* osx_window;
+}
+@end
+

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/WinWindow.h

@@ -0,0 +1,89 @@
+/* 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 <string>
+#include <pangolin/platform.h>
+#include <pangolin/windowing/window.h>
+#include <windowsx.h>
+
+namespace pangolin
+{
+
+struct WinWindow : public WindowInterface
+{
+    WinWindow(
+        const std::string& title, int width, int height
+    );
+
+    ~WinWindow();
+
+    void Move(int x, int y) override;
+
+    void Resize(unsigned int w, unsigned int h) override;
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void ProcessEvents() override;
+
+    void SwapBuffers() override;
+
+    HGLRC GetGLRenderContext()
+    {
+        return hGLRC;
+    }
+
+private:
+    void StartFullScreen();
+    void StopFullScreen();
+
+    static LRESULT APIENTRY WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+
+    LRESULT HandleWinMessages(UINT message, WPARAM wParam, LPARAM lParam);
+
+    void RegisterThisClass(HMODULE hCurrentInst);
+
+    void SetupPixelFormat(HDC hdc);
+
+    void SetupPalette(HDC hDC);
+
+    // Owns the Window
+    HWND hWnd;
+    HDC hDC;
+    HGLRC hGLRC;
+    HPALETTE hPalette;
+    bool bIsFullscreen;
+    RECT cWindowedRect;
+    float afLastMousePos[2];
+};
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/X11Window.h

@@ -0,0 +1,109 @@
+/* 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/platform.h>
+#include <pangolin/windowing/window.h>
+#include <stdexcept>
+#include <memory>
+#include <string>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <GL/glx.h>
+
+namespace pangolin
+{
+
+struct X11Display
+{
+    X11Display(const char* name = 0) {
+        XInitThreads();
+        display = XOpenDisplay(name);
+        if (!display) {
+            throw std::runtime_error("Pangolin X11: Failed to open X display");
+        }
+    }
+
+    ~X11Display() {
+        XCloseDisplay(display);
+    }
+
+    // Owns the display
+    ::Display* display;
+};
+
+struct X11GlContext : public GlContextInterface
+{
+    X11GlContext(std::shared_ptr<X11Display> &d, ::GLXFBConfig chosenFbc, std::shared_ptr<X11GlContext> shared_context = std::shared_ptr<X11GlContext>() );
+    ~X11GlContext();
+
+    std::shared_ptr<X11Display> display;
+
+    std::shared_ptr<X11GlContext> shared_context;
+
+    // Owns the OpenGl Context
+    ::GLXContext glcontext;
+};
+
+struct X11Window : public WindowInterface
+{
+    X11Window(
+        const std::string& title, int width, int height,
+        std::shared_ptr<X11Display>& display, ::GLXFBConfig chosenFbc
+    );
+
+    ~X11Window();
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void Move(int x, int y) override;
+
+    void Resize(unsigned int w, unsigned int h) override;
+
+    void MakeCurrent(GLXContext ctx);
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void SwapBuffers() override;
+
+    void ProcessEvents() override;
+
+    // References the X11 display and context.
+    std::shared_ptr<X11Display> display;
+    std::shared_ptr<X11GlContext> glcontext;
+
+    // Owns the X11 Window and Colourmap
+    ::Window win;
+    ::Colormap cmap;
+
+    Atom delete_message;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/display_android.h

@@ -0,0 +1,333 @@
+/* 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 <poll.h>
+#include <pthread.h>
+#include <sched.h>
+
+#include <android/configuration.h>
+#include <android/looper.h>
+#include <android/native_activity.h>
+#include <android/log.h>
+#include <string>
+
+#include <pangolin/utils/type_convert.h>
+
+#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO,  "pango", __VA_ARGS__))
+#define LOGW(...) ((void)__android_log_print(ANDROID_LOG_WARN,  "pango", __VA_ARGS__))
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "pango", __VA_ARGS__))
+
+/* For debug builds, always enable the debug traces in this library */
+#undef NDEBUG
+#ifndef NDEBUG
+#  define LOGV(...)  ((void)__android_log_print(ANDROID_LOG_VERBOSE, "pango", __VA_ARGS__))
+#else
+#  define LOGV(...)  ((void)0)
+#endif
+
+template<typename T> inline
+void Log(T v) {
+    const std::string sv = pangolin::Convert<std::string,T>::Do(v);
+    LOGI(sv.c_str());
+}
+
+template<typename T> inline
+void Log(const std::string& str, T v)
+{
+    const std::string sv = pangolin::Convert<std::string,T>::Do(v);
+    LOGI((str + ":" + sv).c_str());
+}
+
+namespace pangolin
+{
+    void CreateAndroidWindowAndBind(std::string name);
+    void ProcessAndroidEvents();
+    void FinishAndroidFrame();
+}
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct android_app;
+
+/**
+ * Data associated with an ALooper fd that will be returned as the "outData"
+ * when that source has data ready.
+ */
+struct android_poll_source {
+    // The identifier of this source.  May be LOOPER_ID_MAIN or
+    // LOOPER_ID_INPUT.
+    int32_t id;
+
+    // The android_app this ident is associated with.
+    struct android_app* app;
+
+    // Function to call to perform the standard processing of data from
+    // this source.
+    void (*process)(struct android_app* app, struct android_poll_source* source);
+};
+
+/**
+ * This is the interface for the standard glue code of a threaded
+ * application.  In this model, the application's code is running
+ * in its own thread separate from the main thread of the process.
+ * It is not required that this thread be associated with the Java
+ * VM, although it will need to be in order to make JNI calls any
+ * Java objects.
+ */
+struct android_app {
+    // The application can place a pointer to its own state object
+    // here if it likes.
+    void* userData;
+
+    // Fill this in with the function to process main app commands (APP_CMD_*)
+    void (*onAppCmd)(struct android_app* app, int32_t cmd);
+
+    // Fill this in with the function to process input events.  At this point
+    // the event has already been pre-dispatched, and it will be finished upon
+    // return.  Return 1 if you have handled the event, 0 for any default
+    // dispatching.
+    int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
+
+    // The ANativeActivity object instance that this app is running in.
+    ANativeActivity* activity;
+
+    // The current configuration the app is running in.
+    AConfiguration* config;
+
+    // This is the last instance's saved state, as provided at creation time.
+    // It is NULL if there was no state.  You can use this as you need; the
+    // memory will remain around until you call android_app_exec_cmd() for
+    // APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
+    // These variables should only be changed when processing a APP_CMD_SAVE_STATE,
+    // at which point they will be initialized to NULL and you can malloc your
+    // state and place the information here.  In that case the memory will be
+    // freed for you later.
+    void* savedState;
+    size_t savedStateSize;
+
+    // The ALooper associated with the app's thread.
+    ALooper* looper;
+
+    // When non-NULL, this is the input queue from which the app will
+    // receive user input events.
+    AInputQueue* inputQueue;
+
+    // When non-NULL, this is the window surface that the app can draw in.
+    ANativeWindow* window;
+
+    // Current content rectangle of the window; this is the area where the
+    // window's content should be placed to be seen by the user.
+    ARect contentRect;
+
+    // Current state of the app's activity.  May be either APP_CMD_START,
+    // APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
+    int activityState;
+
+    // This is non-zero when the application's NativeActivity is being
+    // destroyed and waiting for the app thread to complete.
+    int destroyRequested;
+
+    // -------------------------------------------------
+    // Below are "private" implementation of the glue code.
+
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+
+    int msgread;
+    int msgwrite;
+
+    pthread_t thread;
+
+    struct android_poll_source cmdPollSource;
+    struct android_poll_source inputPollSource;
+
+    int running;
+    int stateSaved;
+    int destroyed;
+    int redrawNeeded;
+    AInputQueue* pendingInputQueue;
+    ANativeWindow* pendingWindow;
+    ARect pendingContentRect;
+
+    const char* application_so;
+};
+
+enum {
+    /**
+     * Looper data ID of commands coming from the app's main thread, which
+     * is returned as an identifier from ALooper_pollOnce().  The data for this
+     * identifier is a pointer to an android_poll_source structure.
+     * These can be retrieved and processed with android_app_read_cmd()
+     * and android_app_exec_cmd().
+     */
+    LOOPER_ID_MAIN = 1,
+
+    /**
+     * Looper data ID of events coming from the AInputQueue of the
+     * application's window, which is returned as an identifier from
+     * ALooper_pollOnce().  The data for this identifier is a pointer to an
+     * android_poll_source structure.  These can be read via the inputQueue
+     * object of android_app.
+     */
+    LOOPER_ID_INPUT = 2,
+
+    /**
+     * Start of user-defined ALooper identifiers.
+     */
+    LOOPER_ID_USER = 3,
+};
+
+enum {
+    /**
+     * Command from main thread: the AInputQueue has changed.  Upon processing
+     * this command, android_app->inputQueue will be updated to the new queue
+     * (or NULL).
+     */
+    APP_CMD_INPUT_CHANGED,
+
+    /**
+     * Command from main thread: a new ANativeWindow is ready for use.  Upon
+     * receiving this command, android_app->window will contain the new window
+     * surface.
+     */
+    APP_CMD_INIT_WINDOW,
+
+    /**
+     * Command from main thread: the existing ANativeWindow needs to be
+     * terminated.  Upon receiving this command, android_app->window still
+     * contains the existing window; after calling android_app_exec_cmd
+     * it will be set to NULL.
+     */
+    APP_CMD_TERM_WINDOW,
+
+    /**
+     * Command from main thread: the current ANativeWindow has been resized.
+     * Please redraw with its new size.
+     */
+    APP_CMD_WINDOW_RESIZED,
+
+    /**
+     * Command from main thread: the system needs that the current ANativeWindow
+     * be redrawn.  You should redraw the window before handing this to
+     * android_app_exec_cmd() in order to avoid transient drawing glitches.
+     */
+    APP_CMD_WINDOW_REDRAW_NEEDED,
+
+    /**
+     * Command from main thread: the content area of the window has changed,
+     * such as from the soft input window being shown or hidden.  You can
+     * find the new content rect in android_app::contentRect.
+     */
+    APP_CMD_CONTENT_RECT_CHANGED,
+
+    /**
+     * Command from main thread: the app's activity window has gained
+     * input focus.
+     */
+    APP_CMD_GAINED_FOCUS,
+
+    /**
+     * Command from main thread: the app's activity window has lost
+     * input focus.
+     */
+    APP_CMD_LOST_FOCUS,
+
+    /**
+     * Command from main thread: the current device configuration has changed.
+     */
+    APP_CMD_CONFIG_CHANGED,
+
+    /**
+     * Command from main thread: the system is running low on memory.
+     * Try to reduce your memory use.
+     */
+    APP_CMD_LOW_MEMORY,
+
+    /**
+     * Command from main thread: the app's activity has been started.
+     */
+    APP_CMD_START,
+
+    /**
+     * Command from main thread: the app's activity has been resumed.
+     */
+    APP_CMD_RESUME,
+
+    /**
+     * Command from main thread: the app should generate a new saved state
+     * for itself, to restore from later if needed.  If you have saved state,
+     * allocate it with malloc and place it in android_app.savedState with
+     * the size in android_app.savedStateSize.  The will be freed for you
+     * later.
+     */
+    APP_CMD_SAVE_STATE,
+
+    /**
+     * Command from main thread: the app's activity has been paused.
+     */
+    APP_CMD_PAUSE,
+
+    /**
+     * Command from main thread: the app's activity has been stopped.
+     */
+    APP_CMD_STOP,
+
+    /**
+     * Command from main thread: the app's activity is being destroyed,
+     * and waiting for the app thread to clean up and exit before proceeding.
+     */
+    APP_CMD_DESTROY,
+};
+
+/**
+ * Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
+ * app command message.
+ */
+int8_t android_app_read_cmd(struct android_app* android_app);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * initial pre-processing of the given command.  You can perform your own
+ * actions for the command after calling this function.
+ */
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+/**
+ * Call with the command returned by android_app_read_cmd() to do the
+ * final post-processing of the given command.  You must have done your own
+ * actions for the command before calling this function.
+ */
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
+
+#ifdef __cplusplus
+}
+#endif

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/handler_bitsets.h

@@ -0,0 +1,40 @@
+/* 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/utils/bitmask.h>
+#include <pangolin/windowing/handler_enums.h>
+
+namespace pangolin
+{
+
+using MouseButtonBitmask = bitmask<MouseButton,true>;
+
+using KeyModifierBitmask = bitmask<KeyModifier,true>;
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/handler_enums.h

@@ -0,0 +1,94 @@
+/* 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
+
+namespace pangolin
+{
+
+// Supported Key modifiers for GlobalKeyPressCallback.
+// e.g. PANGO_CTRL + 'r', PANGO_SPECIAL + PANGO_KEY_RIGHT, etc.
+const int PANGO_SPECIAL = 128;
+const int PANGO_CTRL = -96;
+const int PANGO_OPTN = 132;
+
+// Ordinary keys
+const int PANGO_KEY_TAB       = 9;
+const int PANGO_KEY_ESCAPE    = 27;
+
+// Special Keys (same as GLUT_ defines)
+const int PANGO_KEY_F1        = 1;
+const int PANGO_KEY_F2        = 2;
+const int PANGO_KEY_F3        = 3;
+const int PANGO_KEY_F4        = 4;
+const int PANGO_KEY_F5        = 5;
+const int PANGO_KEY_F6        = 6;
+const int PANGO_KEY_F7        = 7;
+const int PANGO_KEY_F8        = 8;
+const int PANGO_KEY_F9        = 9;
+const int PANGO_KEY_F10       = 10;
+const int PANGO_KEY_F11       = 11;
+const int PANGO_KEY_F12       = 12;
+const int PANGO_KEY_LEFT      = 100;
+const int PANGO_KEY_UP        = 101;
+const int PANGO_KEY_RIGHT     = 102;
+const int PANGO_KEY_DOWN      = 103;
+const int PANGO_KEY_PAGE_UP   = 104;
+const int PANGO_KEY_PAGE_DOWN = 105;
+const int PANGO_KEY_HOME      = 106;
+const int PANGO_KEY_END       = 107;
+const int PANGO_KEY_INSERT    = 108;
+
+enum MouseButton
+{
+    MouseButtonLeft   = 1<<0,
+    MouseButtonMiddle = 1<<1,
+    MouseButtonRight  = 1<<2,
+    MouseWheelUp      = 1<<3,
+    MouseWheelDown    = 1<<4,
+    MouseWheelRight   = 1<<5,
+    MouseWheelLeft    = 1<<6,
+};
+
+enum KeyModifier
+{
+    KeyModifierShift = 1<<16,
+    KeyModifierCtrl  = 1<<17,
+    KeyModifierAlt   = 1<<18,
+    KeyModifierCmd   = 1<<19,
+    KeyModifierFnc   = 1<<20
+};
+
+enum InputSpecial
+{
+    InputSpecialScroll,
+    InputSpecialZoom,
+    InputSpecialRotate,
+    InputSpecialTablet
+};
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/include/pangolin/windowing/window.h

@@ -0,0 +1,136 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2016 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 <exception>
+#include <functional>
+#include <array>
+#include <string>
+#include <memory>
+#include <pangolin/platform.h>
+#include <pangolin/utils/signal_slot.h>
+#include <pangolin/utils/true_false_toggle.h>
+#include <pangolin/utils/uri.h>
+#include <pangolin/windowing/handler_bitsets.h>
+
+namespace pangolin
+{
+
+// CreateWindowAndBind parameter key names.
+constexpr char PARAM_DISPLAYNAME[]    = "DISPLAYNAME\0";    // std::string
+constexpr char PARAM_DOUBLEBUFFER[]   = "DOUBLEBUFFER\0";   // bool
+constexpr char PARAM_SAMPLE_BUFFERS[] = "SAMPLE_BUFFERS\0"; // int
+constexpr char PARAM_SAMPLES[]        = "SAMPLES\0";        // int
+constexpr char PARAM_HIGHRES[]        = "HIGHRES\0";        // bool
+
+struct PANGOLIN_EXPORT WindowResizeEvent
+{
+    int width;
+    int height;
+};
+
+struct PANGOLIN_EXPORT WindowInputEvent
+{
+    float x;
+    float y;
+    KeyModifierBitmask key_modifiers;
+};
+
+struct PANGOLIN_EXPORT KeyboardEvent : public WindowInputEvent
+{
+    unsigned char key;
+    bool pressed;
+};
+
+struct PANGOLIN_EXPORT MouseEvent : public WindowInputEvent
+{
+    int button;
+    bool pressed;
+};
+
+struct PANGOLIN_EXPORT MouseMotionEvent : public WindowInputEvent
+{
+};
+
+struct PANGOLIN_EXPORT SpecialInputEvent : public WindowInputEvent
+{
+    InputSpecial inType;
+    float p[4];
+};
+
+class PANGOLIN_EXPORT GlContextInterface
+{
+public:
+    virtual ~GlContextInterface() {}
+};
+
+class PANGOLIN_EXPORT WindowInterface
+{
+public:
+    virtual ~WindowInterface() {}
+
+    /// Move window to (\param x, \param y) on screen
+    /// measured in pixels.
+    virtual void Move(int x, int y) = 0;
+
+    /// Resize window to (\param x, \param y) on screen
+    /// measured in pixels
+    virtual void Resize(unsigned int w, unsigned int h) = 0;
+
+    /// If supported by this windowing system, turn on,
+    /// turn off, or toggle fullscreen mode.
+    virtual void ShowFullscreen(const TrueFalseToggle on_off) = 0;
+
+    /// Make this the active context for graphic rendering.
+    virtual void MakeCurrent() = 0;
+
+    /// Unregister this context from being the active rendering context.
+    virtual void RemoveCurrent() = 0;
+
+    /// Process all windowing events to keep window alive
+    /// and emit interaction callbacks (e.g. mouse, keyboard, resize)
+    virtual void ProcessEvents() = 0;
+
+    /// If double-buffered rendering is enabled, swap the
+    /// front and back buffers revealing the recent renders
+    /// to the back buffer.
+    virtual void SwapBuffers() = 0;
+
+    sigslot::signal<>                    CloseSignal;
+    sigslot::signal<WindowResizeEvent>   ResizeSignal;
+    sigslot::signal<KeyboardEvent> KeyboardSignal;
+    sigslot::signal<MouseEvent>    MouseSignal;
+    sigslot::signal<MouseMotionEvent> MouseMotionSignal;
+    sigslot::signal<MouseMotionEvent> PassiveMouseMotionSignal;
+    sigslot::signal<SpecialInputEvent> SpecialInputSignal;
+};
+
+//! Open Window Interface from Uri specification
+PANGOLIN_EXPORT
+std::unique_ptr<WindowInterface> ConstructWindow(const Uri& uri);
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/src/PangolinNSApplication.mm

@@ -0,0 +1,92 @@
+/* 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/platform.h>
+#include <pangolin/windowing/PangolinNSApplication.h>
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+#  define NSAnyEventMask NSEventMaskAny
+#endif
+
+////////////////////////////////////////////////////////////////////
+// PangolinNSApplication
+////////////////////////////////////////////////////////////////////
+
+@implementation PangolinNSApplication
+
++ (void)run_pre
+{
+    [[NSNotificationCenter defaultCenter]
+        postNotificationName:NSApplicationWillFinishLaunchingNotification
+        object:NSApp];
+    [[NSNotificationCenter defaultCenter]
+        postNotificationName:NSApplicationDidFinishLaunchingNotification
+        object:NSApp];
+}
+
++ (void)run_step
+{
+    NSEvent *event;
+    do{
+        event = [NSApp
+                nextEventMatchingMask:NSAnyEventMask
+                untilDate:nil
+                inMode:NSDefaultRunLoopMode
+                dequeue:YES];
+        [NSApp sendEvent:event];
+        [NSApp updateWindows];
+    }while(event != nil);
+}
+
+@end
+
+////////////////////////////////////////////////////////////////////
+// PangolinWindowDelegate
+////////////////////////////////////////////////////////////////////
+
+@implementation PangolinWindowDelegate
+
+- (BOOL)windowShouldClose:(id)sender {
+    PANGOLIN_UNUSED(sender);
+    osx_window->CloseSignal();
+    return YES;
+}
+
+@end
+
+////////////////////////////////////////////////////////////////////
+// PangolinAppDelegate
+////////////////////////////////////////////////////////////////////
+
+@implementation PangolinAppDelegate
+
+- (void)dealloc
+{
+    [super dealloc];
+}
+
+@end

third-party/DPVO/Pangolin/components/pango_windowing/src/PangolinNSGLView.mm

@@ -0,0 +1,318 @@
+#include <pangolin/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/windowing/PangolinNSGLView.h>
+#include <pangolin/windowing/handler_enums.h>
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+#  define NSDeviceIndependentModifierFlagsMask NSEventModifierFlagDeviceIndependentFlagsMask
+#  define  NSShiftKeyMask NSEventModifierFlagShift
+#  define  NSControlKeyMask NSEventModifierFlagControl
+#  define  NSAlternateKeyMask NSEventModifierFlagOption
+#  define  NSCommandKeyMask NSEventModifierFlagCommand
+#  define  NSFunctionKeyMask NSEventModifierFlagFunction
+#endif
+
+////////////////////////////////////////////////////////////////////
+// Input maps
+////////////////////////////////////////////////////////////////////
+
+inline
+int mapMouseButton(int osx_button )
+{
+    const int map[] = {0, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10};
+    return map[osx_button];
+}
+
+inline
+int mapKeymap(int osx_key)
+{
+    if(osx_key == NSUpArrowFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_UP;
+    else if(osx_key == NSDownArrowFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_DOWN;
+    else if(osx_key == NSLeftArrowFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_LEFT;
+    else if(osx_key == NSRightArrowFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_RIGHT;
+    else if(osx_key == NSPageUpFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_PAGE_UP;
+    else if(osx_key == NSPageDownFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_PAGE_DOWN;
+    else if(osx_key == NSHomeFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_HOME;
+    else if(osx_key == NSEndFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_END;
+    else if(osx_key == NSInsertFunctionKey)
+        return pangolin::PANGO_SPECIAL + pangolin::PANGO_KEY_INSERT;
+    else if(osx_key == NSDeleteCharacter )
+        return NSBackspaceCharacter;
+    else if(osx_key == NSDeleteFunctionKey)
+        return NSDeleteCharacter;
+    else {
+        return osx_key;
+    }
+}
+
+inline
+pangolin::KeyModifierBitmask GetKeyModifierBitmask(NSEvent *event)
+{
+    unsigned int flags = [event modifierFlags] & NSDeviceIndependentModifierFlagsMask;
+    pangolin::KeyModifierBitmask mask;
+    if(flags&NSShiftKeyMask) mask |=  pangolin::KeyModifierShift;
+    if(flags&NSControlKeyMask) mask |=  pangolin::KeyModifierCtrl;
+    if(flags&NSAlternateKeyMask) mask |=  pangolin::KeyModifierAlt;
+    if(flags&NSCommandKeyMask) mask |=  pangolin::KeyModifierCmd;
+    if(flags&NSFunctionKeyMask) mask |=  pangolin::KeyModifierFnc;
+    return mask;
+}
+
+////////////////////////////////////////////////////////////////////
+// PangolinNSGLView
+////////////////////////////////////////////////////////////////////
+
+@implementation PangolinNSGLView
+
+-(id)initWithFrame:(NSRect)frameRect pixelFormat:(NSOpenGLPixelFormat *)format
+{
+    self = [super initWithFrame:frameRect pixelFormat:format];
+    return(self);
+}
+
+- (void)prepareOpenGL
+{
+    [super prepareOpenGL];
+}
+
+-(void)reshape
+{
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
+    if ( [self wantsBestResolutionOpenGLSurface] && [ self.window respondsToSelector:@selector(backingScaleFactor) ] )
+        backing_scale = [self.window backingScaleFactor];
+    else
+#endif
+    backing_scale = 1.0;
+
+    const int width  = self.bounds.size.width * backing_scale;
+    const int height = self.bounds.size.height * backing_scale;
+    osx_window->ResizeSignal(pangolin::WindowResizeEvent({width, height}));
+
+    [[self openGLContext] update];
+    [super reshape];
+}
+
+-(BOOL)acceptsFirstResponder
+{
+    return(YES);
+}
+
+-(BOOL)becomeFirstResponder
+{
+    return(YES);
+}
+
+-(BOOL)resignFirstResponder
+{
+    return(YES);
+}
+
+-(BOOL)isFlipped
+{
+    return(YES);
+}
+
+-(NSPoint)_Location:(NSEvent *)event
+{
+    NSPoint location = [self convertPoint: [event locationInWindow] fromView: nil];
+    location.x *= backing_scale;
+    location.y *= backing_scale;
+    return location;
+}
+
+////////////////////////////////////////////////////////////////////
+// Keyboard
+////////////////////////////////////////////////////////////////////
+
+-(void)keyDown:(NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    NSString *str = [event characters];
+    int len = (int)[str length];
+    for(int i = 0; i < len; i++)
+    {
+        const int osx_key = [str characterAtIndex:i];
+        osx_window->KeyboardSignal(pangolin::KeyboardEvent(
+            {(float)location.x, (float)location.y,
+             GetKeyModifierBitmask(event),
+             (unsigned char)mapKeymap(osx_key), true}
+        ));
+    }
+    unsigned int flags = [event modifierFlags] & NSDeviceIndependentModifierFlagsMask;
+}
+
+-(void)keyUp:(NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    NSString *str = [event characters];
+    int len = (int)[str length];
+    for(int i = 0; i < len; i++)
+    {
+        const int osx_key = [str characterAtIndex:i];
+        osx_window->KeyboardSignal(pangolin::KeyboardEvent(
+            {(float)location.x, (float)location.y,
+             GetKeyModifierBitmask(event),
+             (unsigned char)mapKeymap(osx_key), false}
+        ));
+    }
+}
+
+////////////////////////////////////////////////////////////////////
+// Mouse Input
+////////////////////////////////////////////////////////////////////
+
+-(void)mouseDownCommon:(NSEvent *)event
+{
+    const int button = (int)[event buttonNumber];
+    const NSPoint location = [self _Location: event];
+    osx_window->MouseSignal(pangolin::MouseEvent({
+        (float)location.x, (float)location.y,
+        GetKeyModifierBitmask(event),
+        mapMouseButton(button), true
+    }));
+}
+
+-(void)mouseUpCommon:(NSEvent *)event
+{
+    const int button = (int)[event buttonNumber];
+    const NSPoint location = [self _Location: event];
+    osx_window->MouseSignal(pangolin::MouseEvent({
+        (float)location.x, (float)location.y,
+        GetKeyModifierBitmask(event),
+        mapMouseButton(button), false
+    }));
+}
+
+- (void)mouseDraggedCommon: (NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    osx_window->MouseMotionSignal(pangolin::MouseMotionEvent({
+        (float)location.x, (float)location.y,
+        GetKeyModifierBitmask(event)
+    }));
+}
+
+-(void)mouseDown:(NSEvent *)event
+{
+    [self mouseDownCommon:event];
+}
+
+-(void)mouseUp:(NSEvent *)event
+{
+    [self mouseUpCommon:event];
+}
+
+- (void)mouseDragged: (NSEvent *)event
+{
+    [self mouseDraggedCommon:event];
+}
+
+-(void)rightMouseDown:(NSEvent *)event
+{
+    [self mouseDownCommon:event];
+}
+
+-(void)rightMouseUp:(NSEvent *)event
+{
+    [self mouseUpCommon:event];
+}
+
+- (void)rightMouseDragged: (NSEvent *)event
+{
+    [self mouseDraggedCommon:event];
+}
+
+-(void)otherMouseDown:(NSEvent *)event
+{
+    [self mouseDownCommon:event];
+}
+
+-(void)otherMouseUp:(NSEvent *)event
+{
+    [self mouseUpCommon:event];
+}
+
+- (void)otherMouseDragged: (NSEvent *)event
+{
+    [self mouseDraggedCommon:event];
+}
+
+- (void)mouseMoved: (NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    osx_window->PassiveMouseMotionSignal(pangolin::MouseMotionEvent({(float)location.x, (float)location.y}));
+}
+
+- (void)scrollWheel:(NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+
+    float dx, dy;
+    if([event respondsToSelector:@selector(scrollingDeltaX)]) {
+       dx = event.scrollingDeltaX; dy = event.scrollingDeltaY;
+    } else {
+       dx = event.deltaX; dy = event.deltaY;
+    }
+
+    if(dx != 0.0f || dy != 0.0f) {
+        osx_window->SpecialInputSignal(pangolin::SpecialInputEvent({
+            (float)location.x, (float)location.y,
+            GetKeyModifierBitmask(event),
+            pangolin::InputSpecialScroll,
+            {dx, dy, 0.0f, 0.0f}
+        }));
+    }
+}
+
+- (void)magnifyWithEvent: (NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    const float dm = event.magnification;
+    if(dm != 0.0f) {
+        osx_window->SpecialInputSignal(pangolin::SpecialInputEvent({
+            (float)location.x, (float)location.y,
+            GetKeyModifierBitmask(event),
+            pangolin::InputSpecialZoom,
+            {dm, 0.0f, 0.0f, 0.0f}
+        }));
+    }
+}
+
+- (void)rotateWithEvent: (NSEvent *)event
+{
+    const NSPoint location = [self _Location: event];
+    const float dr = event.rotation;
+    if(dr != 0.0f) {
+        osx_window->SpecialInputSignal(pangolin::SpecialInputEvent({
+            (float)location.x, (float)location.y,
+            GetKeyModifierBitmask(event),
+            pangolin::InputSpecialRotate,
+            {dr, 0.0f, 0.0f, 0.0f}
+        }));
+    }
+}
+
+- (void)mouseEntered: (NSEvent *)event
+{
+    PANGOLIN_UNUSED(event);
+}
+
+- (void)mouseExited: (NSEvent *)event
+{
+    PANGOLIN_UNUSED(event);
+}
+
+-(void)dealloc
+{
+    [super dealloc];
+}
+
+@end

third-party/DPVO/Pangolin/components/pango_windowing/src/display_android.cpp

@@ -0,0 +1,1026 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Based largely on android_native_app_glue.c from Android NDK
+ *
+ * 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/gl/glinclude.h>
+#include <pangolin/display/display.h>
+#include <pangolin/display/display_internal.h>
+#include <pangolin/display/device/display_android.h>
+
+#include <poll.h>
+#include <pthread.h>
+#include <sched.h>
+#include <errno.h>
+#include <dlfcn.h>
+
+#include <android/configuration.h>
+#include <android/looper.h>
+#include <android/native_activity.h>
+#include <android/sensor.h>
+#include <android/log.h>
+#include <android/window.h>
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <iterator>
+#include <stdexcept>
+
+#include <jni.h>
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/resource.h>
+
+namespace pangolin
+{
+
+extern __thread PangolinGl* context;
+
+/**
+ * Shared state for our app.
+ */
+struct engine {
+    android_app* app;
+    ANativeActivity* activity;
+    
+    int has_focus;
+    EGLDisplay display;
+    EGLSurface surface;
+    EGLContext context;
+    int32_t width;
+    int32_t height;
+//    struct saved_state state;
+};
+
+/**
+ * Initialize an EGL context for the current display.
+ */
+static int engine_init_display(struct engine* engine) {
+    // initialize OpenGL ES and EGL
+
+    /*
+     * Here specify the attributes of the desired configuration.
+     * Below, we select an EGLConfig with at least 8 bits per color
+     * component compatible with on-screen windows
+     */
+    const EGLint attribs[] = {
+            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+            EGL_BLUE_SIZE, 8,
+            EGL_GREEN_SIZE, 8,
+            EGL_RED_SIZE, 8,
+            EGL_NONE
+    };
+    EGLint w, h, format;
+    EGLint numConfigs;
+    EGLConfig config;
+    EGLSurface surface;
+    EGLContext context;
+
+    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+
+    eglInitialize(display, 0, 0);
+
+    /* Here, the application chooses the configuration it desires. In this
+     * sample, we have a very simplified selection process, where we pick
+     * the first EGLConfig that matches our criteria */
+    eglChooseConfig(display, attribs, &config, 1, &numConfigs);
+
+    /* EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is
+     * guaranteed to be accepted by ANativeWindow_setBuffersGeometry().
+     * As soon as we picked a EGLConfig, we can safely reconfigure the
+     * ANativeWindow buffers to match, using EGL_NATIVE_VISUAL_ID. */
+    eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format);
+
+    ANativeWindow_setBuffersGeometry(engine->app->window, 0, 0, format);
+//    ANativeActivity_setWindowFlags(engine->app->activity, AWINDOW_FLAG_FULLSCREEN, 0 );
+
+    EGLint const attrib_list[] = {
+#ifdef HAVE_GLES_2
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+#endif
+        EGL_NONE
+    };
+
+    surface = eglCreateWindowSurface(display, config, engine->app->window, NULL);
+    context = eglCreateContext(display, config, NULL, attrib_list);
+
+    if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
+        LOGW("Unable to eglMakeCurrent");
+        return -1;
+    }
+
+    eglQuerySurface(display, surface, EGL_WIDTH, &w);
+    eglQuerySurface(display, surface, EGL_HEIGHT, &h);
+
+    engine->display = display;
+    engine->context = context;
+    engine->surface = surface;
+    engine->width = w;
+    engine->height = h;
+    
+    pangolin::process::Resize(engine->width,engine->height);
+
+    // Initialize GL state.
+    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
+    glEnable(GL_CULL_FACE);
+    glShadeModel(GL_SMOOTH);
+    glDisable(GL_DEPTH_TEST);
+
+    return 0;
+}
+
+/**
+ * Just the current frame in the display.
+ */
+static void engine_draw_frame(struct engine* engine) {
+    if (engine->display != NULL) {
+    }
+}
+
+/**
+ * Tear down the EGL context currently associated with the display.
+ */
+static void engine_term_display(struct engine* engine) {
+    if (engine->display != EGL_NO_DISPLAY) {
+        eglMakeCurrent(engine->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+        if (engine->context != EGL_NO_CONTEXT) {
+            eglDestroyContext(engine->display, engine->context);
+        }
+        if (engine->surface != EGL_NO_SURFACE) {
+            eglDestroySurface(engine->display, engine->surface);
+        }
+        eglTerminate(engine->display);
+    }
+    engine->has_focus = 0;
+    engine->display = EGL_NO_DISPLAY;
+    engine->context = EGL_NO_CONTEXT;
+    engine->surface = EGL_NO_SURFACE;
+}
+
+void UnpressAll(float last_x, float last_y)
+{
+    if(context->mouse_state & pangolin::MouseButtonLeft) {
+        pangolin::process::Mouse(0, 1, last_x, last_y);
+    }
+    if(context->mouse_state & pangolin::MouseButtonMiddle) {
+        pangolin::process::Mouse(1, 1, last_x, last_y);
+    }
+    if(context->mouse_state & pangolin::MouseButtonRight) {
+        pangolin::process::Mouse(2, 1, last_x, last_y);
+    }
+    if(context->mouse_state & pangolin::MouseWheelUp) {
+        pangolin::process::Mouse(3, 1, last_x, last_y);
+    }
+    if(context->mouse_state & pangolin::MouseWheelDown) {
+        pangolin::process::Mouse(4, 1, last_x, last_y);
+    }
+    context->mouse_state = 0;
+}
+
+int PangolinKeyFromAndroidKeycode(int32_t keycode, bool shift)
+{
+    if( AKEYCODE_0 <= keycode && keycode <= AKEYCODE_9) {
+        return '0' + (keycode - AKEYCODE_0);
+    }
+    
+    if( AKEYCODE_A <= keycode && keycode <= AKEYCODE_Z) {
+        return (shift ? 'A' : 'a') + (keycode - AKEYCODE_A);
+    }
+    
+    if(shift) {
+        switch (keycode) {
+        case AKEYCODE_GRAVE:     return '~';
+        default:
+            LOGI("Unknown keycode (with shift): %d", keycode);
+            return '?';
+        }
+    }else{
+        switch (keycode) {
+        case AKEYCODE_COMMA:     return ',';
+        case AKEYCODE_PERIOD:    return '.';
+        case AKEYCODE_SPACE:     return ' ';
+        case AKEYCODE_ENTER:     return '\r';
+        case AKEYCODE_TAB:       return '\t';
+        case AKEYCODE_DEL:       return '\b';
+        case AKEYCODE_SLASH:     return '/';
+        case AKEYCODE_BACKSLASH: return '\\';
+        case AKEYCODE_SEMICOLON: return ';';
+        case AKEYCODE_APOSTROPHE:return '\'';
+        case AKEYCODE_MINUS:     return '-';
+        case AKEYCODE_EQUALS:    return '=';
+        case AKEYCODE_PLUS:      return '+';
+        case AKEYCODE_AT:        return '@';
+        case AKEYCODE_GRAVE:     return '`';
+        default:
+            LOGI("Unknown keycode: %d", keycode);
+            return '?';
+        }
+    }
+}
+
+/**
+ * Process the next input event.
+ */
+static int32_t engine_handle_input(struct android_app* app, AInputEvent* event) {
+    struct engine* engine = (struct engine*)app->userData;
+
+    static float last_x = 0;
+    static float last_y = 0;
+
+    const int32_t input_type = AInputEvent_getType(event);
+    
+    if (input_type == AINPUT_EVENT_TYPE_MOTION) {
+        engine->has_focus = 1;        
+        
+
+        const float x = AMotionEvent_getX(event, 0);
+        const float y = AMotionEvent_getY(event, 0);
+        const int32_t actionAndPtr = AMotionEvent_getAction(event);
+        const int32_t action = AMOTION_EVENT_ACTION_MASK & actionAndPtr;
+//        const int32_t ptrindex = (AMOTION_EVENT_ACTION_POINTER_INDEX_MASK & actionAndPtr) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
+                
+        const size_t num_ptrs = AMotionEvent_getPointerCount(event);
+
+        switch(action)
+        {
+        case AMOTION_EVENT_ACTION_UP:
+        case AMOTION_EVENT_ACTION_POINTER_UP:
+            UnpressAll(last_x, last_y);
+            break;
+        case AMOTION_EVENT_ACTION_DOWN:
+        case AMOTION_EVENT_ACTION_POINTER_DOWN:
+            UnpressAll(last_x, last_y);
+            if(num_ptrs <=2) {
+                const int button = (num_ptrs==1) ? 0 : 2;
+                pangolin::process::Mouse(button, 0, x, y);
+            }
+            break;
+        case AMOTION_EVENT_ACTION_MOVE:
+            if(num_ptrs == 3) {
+                const double dx = x - last_x;
+                const double dy = y - last_y;
+                pangolin::process::Scroll(dx,dy);
+            }else{
+                pangolin::process::MouseMotion(x,y);
+            }
+            break;
+        default:
+            break;
+        }
+
+        last_x = x;
+        last_y = y;
+
+        return 1;
+    }else if(AINPUT_EVENT_TYPE_KEY) {
+        static bool shift = false;
+        
+        const int32_t action = AKeyEvent_getAction(event);
+        const int32_t keycode  = AKeyEvent_getKeyCode(event);
+        
+        if(keycode == AKEYCODE_SHIFT_LEFT) {
+            shift = (action == AKEY_EVENT_ACTION_DOWN);
+            return 1;
+        }
+        
+        unsigned char key = PangolinKeyFromAndroidKeycode(keycode, shift);
+        
+        if(action == AKEY_EVENT_ACTION_DOWN) {
+            pangolin::process::Keyboard(key, last_x, last_y);
+        }else{
+            pangolin::process::KeyboardUp(key, last_x, last_y);
+        }
+    }
+    return 1;
+}
+
+/**
+ * Process the next main command.
+ */
+static void engine_handle_cmd(struct android_app* app, int32_t cmd) {
+    struct engine* engine = (struct engine*)app->userData;
+    switch (cmd) {
+        case APP_CMD_SAVE_STATE:
+//            // The system has asked us to save our current state.  Do so.
+//            engine->app->savedState = malloc(sizeof(struct saved_state));
+//            *((struct saved_state*)engine->app->savedState) = engine->state;
+//            engine->app->savedStateSize = sizeof(struct saved_state);
+            break;
+        case APP_CMD_INIT_WINDOW:
+            // The window is being shown, get it ready.
+            if (engine->app->window != NULL) {
+                engine_init_display(engine);
+                engine_draw_frame(engine);
+            }
+            break;
+        case APP_CMD_TERM_WINDOW:
+            // The window is being hidden or closed, clean it up.
+            engine_term_display(engine);
+            break;
+        case APP_CMD_GAINED_FOCUS:
+            engine->has_focus = 1;            
+            break;
+        case APP_CMD_LOST_FOCUS:
+            engine->has_focus = 0;
+            break;
+    }
+}
+
+}
+
+// Define library entry point.
+extern "C" {
+
+JNIEnv* GetEnvAttachThread(JavaVM* vm)
+{
+    JNIEnv* env;
+    switch (vm->GetEnv((void**)&env, JNI_VERSION_1_6)) {
+    case JNI_OK:
+        break;
+    case JNI_EDETACHED:
+        if (vm->AttachCurrentThread(&env, NULL)!=0) {
+            LOGE("Could not attach current thread");
+            throw std::runtime_error("Could not attach current thread");
+        }
+        break;
+    case JNI_EVERSION:
+        LOGE("Invalid Java version");
+        throw std::runtime_error("Invalid Java version");
+    }
+    return env;
+}
+
+// https://groups.google.com/d/msg/android-ndk/Tk3g00wLKhk/TJQucoaE_asJ
+void displayKeyboard(android_app* app, bool pShow) {
+    jint lFlags = 0;
+    JNIEnv* env = GetEnvAttachThread(app->activity->vm);
+    if(env) {
+        // Retrieves NativeActivity. 
+        jobject lNativeActivity = app->activity->clazz; 
+        jclass ClassNativeActivity = env->GetObjectClass(lNativeActivity); 
+    
+        // Retrieves Context.INPUT_METHOD_SERVICE. 
+        jclass ClassContext = env->FindClass("android/content/Context"); 
+        jfieldID FieldINPUT_METHOD_SERVICE = env->GetStaticFieldID(ClassContext, "INPUT_METHOD_SERVICE", "Ljava/lang/String;"); 
+        jobject INPUT_METHOD_SERVICE = env->GetStaticObjectField(ClassContext, FieldINPUT_METHOD_SERVICE); 
+    //    jniCheck(INPUT_METHOD_SERVICE); 
+    
+        // lInputMethodManager = getSystemService(Context.INPUT_METHOD_SERVICE). 
+        jclass ClassInputMethodManager = env->FindClass( "android/view/inputmethod/InputMethodManager"); 
+        jmethodID MethodGetSystemService = env->GetMethodID( ClassNativeActivity, "getSystemService",  "(Ljava/lang/String;)Ljava/lang/Object;"); 
+        jobject lInputMethodManager = env->CallObjectMethod( lNativeActivity, MethodGetSystemService, INPUT_METHOD_SERVICE); 
+    
+        // lDecorView = getWindow().getDecorView(). 
+        jmethodID MethodGetWindow = env->GetMethodID( ClassNativeActivity, "getWindow",  "()Landroid/view/Window;"); 
+        jobject lWindow = env->CallObjectMethod(lNativeActivity,  MethodGetWindow); 
+        jclass ClassWindow = env->FindClass(  "android/view/Window"); 
+        jmethodID MethodGetDecorView = env->GetMethodID( ClassWindow, "getDecorView", "()Landroid/view/View;"); 
+        jobject lDecorView = env->CallObjectMethod(lWindow,  MethodGetDecorView); 
+    
+        if (pShow) { 
+            // Runs lInputMethodManager.showSoftInput(...). 
+            jmethodID MethodShowSoftInput = env->GetMethodID( ClassInputMethodManager, "showSoftInput", "(Landroid/view/View;I)Z"); 
+            /*jboolean lResult = */env->CallBooleanMethod( lInputMethodManager, MethodShowSoftInput, lDecorView, lFlags); 
+        } else { 
+            // Runs lWindow.getViewToken() 
+            jclass ClassView = env->FindClass( "android/view/View"); 
+            jmethodID MethodGetWindowToken = env->GetMethodID( ClassView, "getWindowToken", "()Landroid/os/IBinder;"); 
+            jobject lBinder = env->CallObjectMethod(lDecorView, MethodGetWindowToken); 
+    
+            // lInputMethodManager.hideSoftInput(...). 
+            jmethodID MethodHideSoftInput = env->GetMethodID( ClassInputMethodManager, "hideSoftInputFromWindow", "(Landroid/os/IBinder;I)Z"); 
+            /*jboolean lRes = */env->CallBooleanMethod( lInputMethodManager, MethodHideSoftInput, lBinder, lFlags); 
+        } 
+    
+        // Finished with the JVM. 
+        app->activity->vm->DetachCurrentThread();
+    }
+}
+
+pangolin::engine g_engine;
+
+static void free_saved_state(struct android_app* android_app) {
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->savedState != NULL) {
+        free(android_app->savedState);
+        android_app->savedState = NULL;
+        android_app->savedStateSize = 0;
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+int8_t android_app_read_cmd(struct android_app* android_app) {
+    int8_t cmd;
+    if (read(android_app->msgread, &cmd, sizeof(cmd)) == sizeof(cmd)) {
+        switch (cmd) {
+            case APP_CMD_SAVE_STATE:
+                free_saved_state(android_app);
+                break;
+        }
+        return cmd;
+    } else {
+        LOGE("No data on command pipe!");
+    }
+    return -1;
+}
+
+static void print_cur_config(struct android_app* android_app) {
+    char lang[2], country[2];
+    AConfiguration_getLanguage(android_app->config, lang);
+    AConfiguration_getCountry(android_app->config, country);
+
+    LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
+            "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
+            "modetype=%d modenight=%d",
+            AConfiguration_getMcc(android_app->config),
+            AConfiguration_getMnc(android_app->config),
+            lang[0], lang[1], country[0], country[1],
+            AConfiguration_getOrientation(android_app->config),
+            AConfiguration_getTouchscreen(android_app->config),
+            AConfiguration_getDensity(android_app->config),
+            AConfiguration_getKeyboard(android_app->config),
+            AConfiguration_getNavigation(android_app->config),
+            AConfiguration_getKeysHidden(android_app->config),
+            AConfiguration_getNavHidden(android_app->config),
+            AConfiguration_getSdkVersion(android_app->config),
+            AConfiguration_getScreenSize(android_app->config),
+            AConfiguration_getScreenLong(android_app->config),
+            AConfiguration_getUiModeType(android_app->config),
+            AConfiguration_getUiModeNight(android_app->config));
+}
+
+void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
+    switch (cmd) {
+        case APP_CMD_INPUT_CHANGED:
+            LOGV("APP_CMD_INPUT_CHANGED\n");
+            pthread_mutex_lock(&android_app->mutex);
+            if (android_app->inputQueue != NULL) {
+                AInputQueue_detachLooper(android_app->inputQueue);
+            }
+            android_app->inputQueue = android_app->pendingInputQueue;
+            if (android_app->inputQueue != NULL) {
+                LOGV("Attaching input queue to looper");
+                AInputQueue_attachLooper(android_app->inputQueue,
+                        android_app->looper, LOOPER_ID_INPUT, NULL,
+                        &android_app->inputPollSource);
+            }
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_INIT_WINDOW:
+            LOGV("APP_CMD_INIT_WINDOW\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->window = android_app->pendingWindow;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_TERM_WINDOW:
+            LOGV("APP_CMD_TERM_WINDOW\n");
+            pthread_cond_broadcast(&android_app->cond);
+            break;
+
+        case APP_CMD_RESUME:
+        case APP_CMD_START:
+        case APP_CMD_PAUSE:
+        case APP_CMD_STOP:
+            LOGV("activityState=%d\n", cmd);
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->activityState = cmd;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_CONFIG_CHANGED:
+            LOGV("APP_CMD_CONFIG_CHANGED\n");
+            AConfiguration_fromAssetManager(android_app->config,
+                    android_app->activity->assetManager);
+            print_cur_config(android_app);
+            break;
+
+        case APP_CMD_DESTROY:
+            LOGV("APP_CMD_DESTROY\n");
+            android_app->destroyRequested = 1;
+            break;
+    }
+}
+
+void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
+    switch (cmd) {
+        case APP_CMD_TERM_WINDOW:
+            LOGV("APP_CMD_TERM_WINDOW\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->window = NULL;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_SAVE_STATE:
+            LOGV("APP_CMD_SAVE_STATE\n");
+            pthread_mutex_lock(&android_app->mutex);
+            android_app->stateSaved = 1;
+            pthread_cond_broadcast(&android_app->cond);
+            pthread_mutex_unlock(&android_app->mutex);
+            break;
+
+        case APP_CMD_RESUME:
+            free_saved_state(android_app);
+            break;
+    }
+}
+
+static void android_app_destroy(struct android_app* android_app) {
+    LOGV("+android_app_destroy!");
+    free_saved_state(android_app);
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->inputQueue != NULL) {
+        AInputQueue_detachLooper(android_app->inputQueue);
+    }
+    AConfiguration_delete(android_app->config);
+    android_app->destroyed = 1;
+    pthread_cond_broadcast(&android_app->cond);
+    pthread_mutex_unlock(&android_app->mutex);
+    // Can't touch android_app object after this.
+    LOGV("-android_app_destroy!");
+}
+
+static void process_input(struct android_app* app, struct android_poll_source* source) {
+    AInputEvent* event = NULL;
+    if (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
+        
+        // HACK: Override back buttom to show / hide keyboard.
+        int type = AInputEvent_getType(event);
+        if(type == AINPUT_EVENT_TYPE_KEY) {
+            if(AKeyEvent_getAction(event) == AKEY_EVENT_ACTION_DOWN) {
+                static bool keyboard_shown = false;
+                if( AKeyEvent_getKeyCode(event) == AKEYCODE_BACK ) {
+                    displayKeyboard(app,!keyboard_shown);
+                    keyboard_shown = !keyboard_shown;
+                    AInputQueue_finishEvent(app->inputQueue, event, 1);
+                    return;
+                }
+            }
+        }    
+        
+        if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
+            return;
+        }
+        int32_t handled = 0;
+        if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
+        AInputQueue_finishEvent(app->inputQueue, event, handled);
+    } else {
+        LOGE("Failure reading next input event: %s\n", strerror(errno));
+    }
+}
+
+static void process_cmd(struct android_app* app, struct android_poll_source* source) {
+    int8_t cmd = android_app_read_cmd(app);
+    android_app_pre_exec_cmd(app, cmd);
+    if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
+    android_app_post_exec_cmd(app, cmd);
+}
+
+static void* android_app_entry(void* param) {
+    LOGV("+android_app_entry");
+    struct android_app* android_app = (struct android_app*)param;
+
+    android_app->config = AConfiguration_new();
+    AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
+
+    print_cur_config(android_app);
+
+    android_app->cmdPollSource.id = LOOPER_ID_MAIN;
+    android_app->cmdPollSource.app = android_app;
+    android_app->cmdPollSource.process = process_cmd;
+    android_app->inputPollSource.id = LOOPER_ID_INPUT;
+    android_app->inputPollSource.app = android_app;
+    android_app->inputPollSource.process = process_input;
+
+    ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
+    ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
+            &android_app->cmdPollSource);
+    android_app->looper = looper;
+
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->running = 1;
+    pthread_cond_broadcast(&android_app->cond);
+    pthread_mutex_unlock(&android_app->mutex);
+    
+    std::string sargv;
+    
+    // Load command line from ARGV parameter
+    JNIEnv *env = GetEnvAttachThread(android_app->activity->vm);
+    if(env) {
+        jobject me = android_app->activity->clazz;
+        
+        jclass acl = env->GetObjectClass(me); //class pointer of NativeActivity
+        jmethodID giid = env->GetMethodID(acl, "getIntent", "()Landroid/content/Intent;");
+        jobject intent = env->CallObjectMethod(me, giid); //Got our intent
+        
+        jclass icl = env->GetObjectClass(intent); //class pointer of Intent
+        jmethodID gseid = env->GetMethodID(icl, "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
+        
+        jstring jsARGV = (jstring)env->CallObjectMethod(intent, gseid, env->NewStringUTF("ARGV"));
+        
+        
+        if(jsARGV) {
+            const char *chARGV = env->GetStringUTFChars(jsARGV, 0);
+            if(chARGV) {
+                sargv = std::string(chARGV);
+                LOGI("ARGV: pango %s", chARGV);
+            }
+            env->ReleaseStringUTFChars(jsARGV, chARGV);    
+        }
+        
+        android_app->activity->vm->DetachCurrentThread();
+    }
+
+    // Set up argv/argc to pass to users main
+    std::vector<std::string> vargv;
+    vargv.push_back("pango");
+    
+    // Parse parameters from ARGV android intent parameter
+    std::istringstream iss(sargv);
+    std::copy(std::istream_iterator<std::string>(iss),
+             std::istream_iterator<std::string>(),
+             std::back_inserter<std::vector<std::string> >(vargv));    
+
+    char* argv[vargv.size()+1];
+    for(size_t ac = 0; ac < vargv.size(); ++ac) {
+        argv[ac] = new char[vargv[ac].size()];
+        strcpy( argv[ac], vargv[ac].c_str() );
+    }
+    argv[vargv.size()] = NULL;
+
+    // Find main symbol
+    void (*main)(int, char**);
+    *(void **) (&main) = dlsym( dlopen(android_app->application_so, RTLD_NOW), "main");
+    if (!main) {
+        LOGE( "undefined symbol main, crap" );
+        exit(1);
+    }
+    // Call users standard main entry point.
+    (*main)(vargv.size(), argv);
+    
+    // Clean up parameters
+    for(size_t ac = 0; ac < vargv.size(); ++ac) {
+        delete[] argv[ac];
+    }    
+    
+    android_app_destroy(android_app);
+    
+    LOGV("-android_app_entry");
+    
+    return NULL;
+}
+
+static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
+    if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
+        LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
+    }
+}
+
+static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->pendingInputQueue = inputQueue;
+    android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
+    while (android_app->inputQueue != android_app->pendingInputQueue) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
+    pthread_mutex_lock(&android_app->mutex);
+    if (android_app->pendingWindow != NULL) {
+        android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
+    }
+    android_app->pendingWindow = window;
+    if (window != NULL) {
+        android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
+    }
+    while (android_app->window != android_app->pendingWindow) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app_write_cmd(android_app, cmd);
+    while (android_app->activityState != cmd) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+}
+
+static void android_app_free(struct android_app* android_app) {
+    pthread_mutex_lock(&android_app->mutex);
+    android_app_write_cmd(android_app, APP_CMD_DESTROY);
+    while (!android_app->destroyed) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+    pthread_mutex_unlock(&android_app->mutex);
+
+    close(android_app->msgread);
+    close(android_app->msgwrite);
+    pthread_cond_destroy(&android_app->cond);
+    pthread_mutex_destroy(&android_app->mutex);
+    free(android_app);
+}
+
+static void onDestroy(ANativeActivity* activity) {
+    LOGV("Destroy: %p\n", activity);
+    android_app_free((struct android_app*)activity->instance);
+}
+
+static void onStart(ANativeActivity* activity) {
+    LOGV("Start: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
+}
+
+static void onResume(ANativeActivity* activity) {
+    LOGV("Resume: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
+}
+
+static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    void* savedState = NULL;
+
+    LOGV("SaveInstanceState: %p\n", activity);
+    pthread_mutex_lock(&android_app->mutex);
+    android_app->stateSaved = 0;
+    android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
+    while (!android_app->stateSaved) {
+        pthread_cond_wait(&android_app->cond, &android_app->mutex);
+    }
+
+    if (android_app->savedState != NULL) {
+        savedState = android_app->savedState;
+        *outLen = android_app->savedStateSize;
+        android_app->savedState = NULL;
+        android_app->savedStateSize = 0;
+    }
+
+    pthread_mutex_unlock(&android_app->mutex);
+
+    return savedState;
+}
+
+static void onPause(ANativeActivity* activity) {
+    LOGV("Pause: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
+}
+
+static void onStop(ANativeActivity* activity) {
+    LOGV("Stop: %p\n", activity);
+    android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
+}
+
+static void onConfigurationChanged(ANativeActivity* activity) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    LOGV("ConfigurationChanged: %p\n", activity);
+    android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
+}
+
+static void onLowMemory(ANativeActivity* activity) {
+    struct android_app* android_app = (struct android_app*)activity->instance;
+    LOGV("LowMemory: %p\n", activity);
+    android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
+}
+
+static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
+    LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
+    android_app_write_cmd((struct android_app*)activity->instance,
+            focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
+}
+
+static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
+    LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
+    android_app_set_window((struct android_app*)activity->instance, window);
+}
+
+static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
+    LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
+    android_app_set_window((struct android_app*)activity->instance, NULL);
+}
+
+static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
+    LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
+    android_app_set_input((struct android_app*)activity->instance, queue);
+}
+
+static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
+    LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
+    android_app_set_input((struct android_app*)activity->instance, NULL);
+}
+
+static void onContentRectChanged(ANativeActivity* activity, const ARect* rect) {
+    LOGV("onContentRectChanged: %p -- (%d, %d), (%d, %d)\n", activity, rect->left, rect->top, rect->right, rect->bottom);
+}
+
+void DeferredNativeActivity_onCreate(
+        ANativeActivity* activity,
+        void* savedState,
+        size_t savedStateSize,
+        const char* load_target
+    )
+{
+    activity->callbacks->onDestroy = onDestroy;
+    activity->callbacks->onStart = onStart;
+    activity->callbacks->onResume = onResume;
+    activity->callbacks->onSaveInstanceState = onSaveInstanceState;
+    activity->callbacks->onPause = onPause;
+    activity->callbacks->onStop = onStop;
+    activity->callbacks->onConfigurationChanged = onConfigurationChanged;
+    activity->callbacks->onLowMemory = onLowMemory;
+    activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
+    activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
+    activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
+    activity->callbacks->onInputQueueCreated = onInputQueueCreated;
+    activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
+    activity->callbacks->onContentRectChanged = onContentRectChanged;
+
+    // Create threaded android_app
+    android_app* app = (struct android_app*)malloc(sizeof(struct android_app));
+    memset(app, 0, sizeof(struct android_app));
+    app->activity = activity;
+    app->application_so = load_target;
+
+    pthread_mutex_init(&app->mutex, NULL);
+    pthread_cond_init(&app->cond, NULL);
+
+    if (savedState != NULL) {
+        app->savedState = malloc(savedStateSize);
+        app->savedStateSize = savedStateSize;
+        memcpy(app->savedState, savedState, savedStateSize);
+    }
+
+    int msgpipe[2];
+    if (pipe(msgpipe)) {
+        LOGE("could not create pipe: %s", strerror(errno));
+        exit(1);
+    }
+    app->msgread = msgpipe[0];
+    app->msgwrite = msgpipe[1];
+
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    pthread_create(&app->thread, &attr, android_app_entry, app);
+
+    // Wait for thread to start.
+    pthread_mutex_lock(&app->mutex);
+    while (!app->running) {
+        pthread_cond_wait(&app->cond, &app->mutex);
+    }
+    pthread_mutex_unlock(&app->mutex);
+
+    activity->instance = app;
+    
+    // Save global variables for use later
+    memset(&g_engine, 0, sizeof(pangolin::engine));
+    app->userData = &g_engine;
+    app->onAppCmd = pangolin::engine_handle_cmd;
+    app->onInputEvent = pangolin::engine_handle_input;
+    g_engine.app = app;
+    g_engine.activity = activity;
+
+//    // Load existing state if it exists
+//    if (app->savedState != NULL) {
+//        // We are starting with a previous saved state; restore from it.
+//        g_engine.state = *(struct pangolin::saved_state*)app->savedState;
+//    }
+}
+}
+
+namespace pangolin
+{
+
+void CreateAndroidWindowAndBind(std::string name)
+{
+    LOGI("*****************************************************************");
+    LOGV("+CreateAndroidWindowAndBind");
+    // Bind and Wait for GL Context
+    pangolin::BindToContext(name);
+    ProcessAndroidEvents();    
+    LOGV("-CreateAndroidWindowAndBind");    
+}
+
+void ProcessAndroidEvents()
+{
+    do {
+        // Read all pending events.
+        int ident;
+        int events;
+        struct android_poll_source* source;
+        
+        // If not animating, we will block forever waiting for events.
+        // If animating, we loop until all events are read, then continue
+        // to draw the next frame of animation.
+        while ((ident=ALooper_pollAll(g_engine.has_focus ? 0 : -1, NULL, &events,
+                (void**)&source)) >= 0) {
+    
+            // Process this event.
+            if (source != NULL) {
+                source->process(g_engine.app, source);
+            }
+        
+            // Check if we are exiting.
+            if (g_engine.app->destroyRequested != 0) {
+                engine_term_display(&g_engine);
+                context->quit = true;
+                return;
+            }
+        }
+    } while (g_engine.display == NULL);
+}
+
+void FinishAndroidFrame()
+{
+    ProcessAndroidEvents();
+    RenderViews();
+    PostRender();
+    eglSwapBuffers(g_engine.display, g_engine.surface);    
+}
+
+// Implement platform agnostic version
+void CreateWindowAndBind(std::string window_title, int /*w*/, int /*h*/, const Params& /*params*/ )
+{
+    CreateAndroidWindowAndBind(window_title);
+
+#ifdef HAVE_GLES_2
+    // Bind default compatibility shader
+    pangolin::glEngine().prog_fixed.Bind();
+#endif
+}
+
+// Implement platform agnostic version
+void FinishFrame()
+{
+    FinishAndroidFrame();
+}
+
+void SetFullscreen(bool /*fullscreen*/)
+{
+    // Do nothing
+}
+
+void PangolinPlatformInit(PangolinGl& /*context*/)
+{
+}
+
+void PangolinPlatformDeinit(PangolinGl& /*context*/)
+{
+}
+
+PANGOLIN_REGISTER_FACTORY(AndroidWindow)
+{
+  struct AndroidWindowFactory : public TypedFactoryInterface<WindowInterface> {
+    std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+        
+      const std::string window_title = uri.Get<std::string>("window_title", "window");
+      CreateAndroidWindowAndBind(window_title);
+#ifdef HAVE_GLES_2
+      // Bind default compatibility shader
+      pangolin::glEngine().prog_fixed.Bind();
+#endif
+      return NULL;
+    }
+  };
+
+  auto factory = std::make_shared<AndroidWindowFactory>();
+  FactoryRegistry<WindowInterface>::I().RegisterFactory(factory, 10, "android");
+  }
+}

third-party/DPVO/Pangolin/components/pango_windowing/src/display_emscripten.cpp

@@ -0,0 +1,324 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2018 Andrey Mnatsakanov
+ *
+ * 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/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/windowing/window.h>
+#include <pangolin/windowing/EmscriptenWindow.h>
+
+#include <mutex>
+#include <stdexcept>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdint.h>
+
+namespace pangolin
+{
+
+constexpr char em_dom_id[] = "#canvas";
+
+int spec_key(const char* key_string){
+    if(strlen(key_string)==1){
+        return -1;
+    }
+    if(strcmp(key_string, "F1")==0) return PANGO_SPECIAL + PANGO_KEY_F1;
+    if(strcmp(key_string, "F2")==0) return PANGO_SPECIAL + PANGO_KEY_F2;
+    if(strcmp(key_string, "F3")==0) return PANGO_SPECIAL + PANGO_KEY_F3;
+    if(strcmp(key_string, "F4")==0) return PANGO_SPECIAL + PANGO_KEY_F4;
+    if(strcmp(key_string, "F5")==0) return PANGO_SPECIAL + PANGO_KEY_F5;
+    if(strcmp(key_string, "F6")==0) return PANGO_SPECIAL + PANGO_KEY_F6;
+    if(strcmp(key_string, "F7")==0) return PANGO_SPECIAL + PANGO_KEY_F7;
+    if(strcmp(key_string, "F8")==0) return PANGO_SPECIAL + PANGO_KEY_F8;
+    if(strcmp(key_string, "F9")==0) return PANGO_SPECIAL + PANGO_KEY_F9;
+    if(strcmp(key_string, "F10")==0)return PANGO_SPECIAL + PANGO_KEY_F10;
+    if(strcmp(key_string, "F11")==0)return PANGO_SPECIAL + PANGO_KEY_F11;
+    if(strcmp(key_string, "F12")==0)return PANGO_SPECIAL + PANGO_KEY_F12;
+    if(strcmp(key_string, "ArrowLeft")==0)return PANGO_SPECIAL + PANGO_KEY_LEFT;
+    if(strcmp(key_string, "ArrowUp")==0)return PANGO_SPECIAL + PANGO_KEY_UP;
+    if(strcmp(key_string, "ArrowRight")==0)return PANGO_SPECIAL + PANGO_KEY_RIGHT;
+    if(strcmp(key_string, "ArrowDown")==0)return PANGO_SPECIAL + PANGO_KEY_DOWN;
+    if(strcmp(key_string, "PageUp")==0)return PANGO_SPECIAL + PANGO_KEY_PAGE_UP;
+    if(strcmp(key_string, "PageDown")==0)return PANGO_SPECIAL + PANGO_KEY_PAGE_DOWN;
+    if(strcmp(key_string, "Home")==0)return PANGO_SPECIAL + PANGO_KEY_HOME;
+    if(strcmp(key_string, "End")==0)return PANGO_SPECIAL + PANGO_KEY_END;
+    if(strcmp(key_string, "Insert")==0)return PANGO_SPECIAL + PANGO_KEY_INSERT;
+    return -1;
+}
+
+KeyModifier mod_key(const char* key_string){
+    if(strlen(key_string)==1) return KeyModifier(0);
+    if(strcmp(key_string, "Shift")==0)  return pangolin::KeyModifierShift;
+    if(strcmp(key_string, "Control")==0) return pangolin::KeyModifierCtrl;
+    if(strcmp(key_string, "Alt")==0) return pangolin::KeyModifierAlt;
+    if(strcmp(key_string, "Meta")==0) return pangolin::KeyModifierCmd;
+    return KeyModifier(0);
+}
+
+std::mutex window_mutex;
+
+pangolin::KeyModifierBitmask GetKeyModifierBitmask(const EmscriptenKeyboardEvent *event)
+{
+    pangolin::KeyModifierBitmask mask;
+    if(event->shiftKey) mask |=  pangolin::KeyModifierShift;
+    if(event->ctrlKey) mask |=  pangolin::KeyModifierCtrl;
+    if(event->altKey) mask |=  pangolin::KeyModifierAlt;
+    if(event->metaKey) mask |=  pangolin::KeyModifierCmd;
+    return mask;
+}
+
+pangolin::KeyModifierBitmask GetKeyModifierBitmask(const EmscriptenMouseEvent *event)
+{
+    pangolin::KeyModifierBitmask mask;
+    if(event->shiftKey) mask |=  pangolin::KeyModifierShift;
+    if(event->ctrlKey) mask |=  pangolin::KeyModifierCtrl;
+    if(event->altKey) mask |=  pangolin::KeyModifierAlt;
+    if(event->metaKey) mask |=  pangolin::KeyModifierCmd;
+    return mask;
+}
+
+EM_BOOL key_callback(int eventType, const EmscriptenKeyboardEvent *e, void *userData){
+    EmscriptenWindow* w=(EmscriptenWindow*)userData;
+
+    if(eventType==EMSCRIPTEN_EVENT_KEYPRESS)
+        return false;
+
+    const KeyModifier mod = mod_key(e->key);
+    if(mod == 0) {
+        // Not a modifier key
+        int key = spec_key(e->key);
+        if(key != -1){
+            w->KeyboardSignal(KeyboardEvent({
+                (float)w->x, (float)w->y, GetKeyModifierBitmask(e),
+                (uint8_t)key, eventType==EMSCRIPTEN_EVENT_KEYDOWN
+            }));
+        }
+        if(strlen(e->key)==1){
+            w->KeyboardSignal(KeyboardEvent({
+                (float)w->x, (float)w->y, GetKeyModifierBitmask(e),
+                (uint8_t)((e->ctrlKey?PANGO_CTRL:0) + e->key[0]),
+                eventType==EMSCRIPTEN_EVENT_KEYDOWN
+            }));
+        }
+    }else{
+        w->key_modifier_state.set(mod, eventType==EMSCRIPTEN_EVENT_KEYDOWN);
+    }
+    return false;
+}
+
+EM_BOOL mouse_callback(int eventType, const EmscriptenMouseEvent *e, void *userData){
+    EmscriptenWindow* w=(EmscriptenWindow*)userData;
+    w->x = e->targetX;
+    w->y = e->targetY;
+
+    switch(eventType) {
+    case EMSCRIPTEN_EVENT_MOUSEDOWN:
+    case EMSCRIPTEN_EVENT_MOUSEUP:
+        w->MouseSignal(MouseEvent({
+            (float)w->x, (float)w->y, GetKeyModifierBitmask(e),
+            e->button, eventType == EMSCRIPTEN_EVENT_MOUSEDOWN
+        }));
+        break;
+    case EMSCRIPTEN_EVENT_MOUSEMOVE:
+        if(e->buttons){
+            w->MouseMotionSignal(MouseMotionEvent({(float)w->x, (float)w->y, GetKeyModifierBitmask(e)}));
+        } else {
+            w->PassiveMouseMotionSignal(MouseMotionEvent({(float)w->x, (float)w->y, GetKeyModifierBitmask(e)}));
+        }
+        break;
+    case EMSCRIPTEN_EVENT_MOUSEOVER:
+        break;
+    case EMSCRIPTEN_EVENT_MOUSEOUT:
+        break;
+    default:
+        break;
+    }
+    return false;
+}
+
+EM_BOOL wheel_callback(int eventType, const EmscriptenWheelEvent *e, void *userData){
+    EmscriptenWindow* w=(EmscriptenWindow*)userData;
+    w->SpecialInputSignal(SpecialInputEvent({
+        (float)w->x, (float)w->y, w->key_modifier_state,
+        InputSpecialScroll,
+        (float)e->deltaX, (float)e->deltaY, 0, 0
+    }));
+    return true;
+}
+EM_BOOL uievent_callback(int eventType, const EmscriptenUiEvent *e, void *userData){
+    EmscriptenWindow* w=(EmscriptenWindow*)userData;
+    switch(eventType) {
+    case EMSCRIPTEN_EVENT_RESIZE:
+        int width, height;
+        emscripten_get_canvas_element_size(em_dom_id, &width, &height);
+        w->ResizeSignal(WindowResizeEvent({width, height}));
+        break;
+    }
+    return true;
+}
+
+#define TEST(error) if(error!=EMSCRIPTEN_RESULT_SUCCESS)std::cerr << "error: " << __FILE__<< ":" << __LINE__ << std::endl
+
+EmscriptenWindow:: EmscriptenWindow()
+    : done_init_events(false)
+{
+    EmscriptenWebGLContextAttributes attr;
+    emscripten_webgl_init_context_attributes(&attr);
+    attr.majorVersion = 2;
+    attr.minorVersion = 0;
+    attr.stencil = true;
+    attr.depth = true;
+    ctx = emscripten_webgl_create_context(em_dom_id, &attr);
+    if( ctx < 0 ) {
+        throw std::runtime_error("Pangolin Emscripten: Failed to create window." );
+    }
+    // Try to enable some extensions we'll probably need.
+    emscripten_webgl_enable_extension(ctx, "EXT_float_blend");
+
+    EMSCRIPTEN_RESULT ret;
+    ret = emscripten_set_keypress_callback(em_dom_id, this, 1, key_callback);
+    TEST(ret);
+    ret = emscripten_set_keydown_callback(em_dom_id, this, 1, key_callback);
+    TEST(ret);
+    ret = emscripten_set_keyup_callback(em_dom_id, this, 1, key_callback);
+    TEST(ret);
+    ret = emscripten_set_click_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mousedown_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mouseup_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_dblclick_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mousemove_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mouseenter_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mouseleave_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mouseover_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_mouseout_callback(em_dom_id, this, 1, mouse_callback);
+    TEST(ret);
+    ret = emscripten_set_wheel_callback(em_dom_id, this, 1, wheel_callback);
+    TEST(ret);
+    ret = emscripten_set_resize_callback(em_dom_id, this, 1, uievent_callback);
+    TEST(ret);
+
+    EM_ASM(Module['noExitRuntime'] = true);
+}
+
+#undef TEST
+
+EmscriptenWindow::~ EmscriptenWindow()
+{
+    emscripten_webgl_destroy_context(ctx);
+}
+
+void EmscriptenWindow::MakeCurrent()
+{
+    emscripten_webgl_make_context_current(ctx);
+    pangolin::glEngine().prog_fixed.Bind();
+}
+
+void EmscriptenWindow::RemoveCurrent()
+{
+    pangolin::glEngine().prog_fixed.Unbind();
+}
+
+void EmscriptenWindow::ShowFullscreen(const TrueFalseToggle)
+{
+    // Not implemented
+}
+
+void EmscriptenWindow::Move(int x, int y)
+{
+    // Not implemented
+}
+
+void EmscriptenWindow::Resize(unsigned int w, unsigned int h)
+{
+    emscripten_set_canvas_element_size(em_dom_id, w, h);
+}
+
+void EmscriptenWindow::ProcessEvents()
+{
+    // Emscripten will trigger callbacks.
+    if(!done_init_events) {
+        done_init_events = true;
+        int width, height;
+        emscripten_get_canvas_element_size(em_dom_id, &width, &height);
+        ResizeSignal(WindowResizeEvent({width, height}));
+    }
+}
+
+void  EmscriptenWindow::SwapBuffers() {
+    emscripten_sleep(10);
+}
+
+PANGOLIN_REGISTER_FACTORY(EmscriptenWindow)
+{
+    struct EmscriptenWindowFactory : public TypedFactoryInterface<WindowInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"emscripten",10},{"default",100}};
+        }
+        const char* Description() const override
+        {
+            return "Use WebGL window";
+        }
+        ParamSet Params() const override
+        {
+            return {{
+                {"window_title","-","Ignored"},
+                {"w","640","Ignored"},
+                {"h","480","Ignored"},
+            }};
+        }
+
+        std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+            // We're going to be naughty and actually ignore the title, width and height,
+            // but list them as parameters to be compatible with other windowing libs.
+            return std::unique_ptr<WindowInterface>(new EmscriptenWindow());
+        }
+    };
+    return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<EmscriptenWindowFactory>());
+}
+
+}
+
+#include <emscripten/bind.h>
+
+std::string pango_get_exception_message(intptr_t exceptionPtr) {
+    return std::string(reinterpret_cast<std::exception *>(exceptionPtr)->what());
+}
+
+EMSCRIPTEN_BINDINGS(Bindings) {
+    emscripten::function("pango_get_exception_message", &pango_get_exception_message);
+};

third-party/DPVO/Pangolin/components/pango_windowing/src/display_headless.cpp

@@ -0,0 +1,174 @@
+#include <pangolin/windowing/window.h>
+#include <pangolin/factory/factory_registry.h>
+#include <EGL/egl.h>
+
+namespace pangolin {
+
+namespace headless {
+
+class EGLDisplayHL {
+public:
+    EGLDisplayHL(const int width, const int height);
+
+    ~EGLDisplayHL();
+
+    void swap();
+
+    void makeCurrent();
+
+    void removeCurrent();
+
+private:
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+    EGLDisplay egl_display;
+
+    static constexpr EGLint attribs[] = {
+        EGL_SURFACE_TYPE    , EGL_PBUFFER_BIT,
+        EGL_RENDERABLE_TYPE , EGL_OPENGL_BIT,
+        EGL_RED_SIZE        , 8,
+        EGL_GREEN_SIZE      , 8,
+        EGL_BLUE_SIZE       , 8,
+        EGL_ALPHA_SIZE      , 8,
+        EGL_DEPTH_SIZE      , 24,
+        EGL_STENCIL_SIZE    , 8,
+        EGL_NONE
+    };
+};
+
+constexpr EGLint EGLDisplayHL::attribs[];
+
+struct HeadlessWindow : public WindowInterface {
+    HeadlessWindow(const int width, const int height);
+
+    ~HeadlessWindow() override;
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void Move(const int x, const int y) override;
+
+    void Resize(const unsigned int w, const unsigned int h) override;
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void SwapBuffers() override;
+
+    void ProcessEvents() override;
+
+    EGLDisplayHL display;
+};
+
+EGLDisplayHL::EGLDisplayHL(const int width, const int height) {
+    egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+    if(!egl_display) {
+        std::cerr << "Failed to open EGL display" << std::endl;
+    }
+
+    EGLint major, minor;
+    if(eglInitialize(egl_display, &major, &minor)==EGL_FALSE) {
+        std::cerr << "EGL init failed" << std::endl;
+    }
+
+    if(eglBindAPI(EGL_OPENGL_API)==EGL_FALSE) {
+        std::cerr << "EGL bind failed" << std::endl;
+    }
+
+    EGLint count;
+    eglGetConfigs(egl_display, nullptr, 0, &count);
+
+    std::vector<EGLConfig> egl_configs(count);
+
+    EGLint numConfigs;
+    eglChooseConfig(egl_display, attribs, egl_configs.data(), count, &numConfigs);
+
+    egl_context = eglCreateContext(egl_display, egl_configs[0], EGL_NO_CONTEXT, nullptr);
+
+    const EGLint pbufferAttribs[] = {
+        EGL_WIDTH, width,
+        EGL_HEIGHT, height,
+        EGL_NONE,
+    };
+    egl_surface = eglCreatePbufferSurface(egl_display, egl_configs[0],  pbufferAttribs);
+    if (egl_surface == EGL_NO_SURFACE) {
+        std::cerr << "Cannot create EGL surface" << std::endl;
+    }
+}
+
+EGLDisplayHL::~EGLDisplayHL() {
+    if(egl_context) eglDestroyContext(egl_display, egl_context);
+    if(egl_surface) eglDestroySurface(egl_display, egl_surface);
+    if(egl_display) eglTerminate(egl_display);
+}
+
+void EGLDisplayHL::swap() {
+    eglSwapBuffers(egl_display, egl_surface);
+}
+
+void EGLDisplayHL::makeCurrent() {
+    eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
+}
+
+void EGLDisplayHL::removeCurrent() {
+    eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+}
+
+HeadlessWindow::HeadlessWindow(const int w, const int h) : display(w, h) {
+}
+
+HeadlessWindow::~HeadlessWindow() { }
+
+void HeadlessWindow::MakeCurrent() {
+    display.makeCurrent();
+}
+
+void HeadlessWindow::RemoveCurrent() {
+    display.removeCurrent();
+}
+
+void HeadlessWindow::ShowFullscreen(const TrueFalseToggle) { }
+
+void HeadlessWindow::Move(const int /*x*/, const int /*y*/) { }
+
+void HeadlessWindow::Resize(const unsigned int /*w*/, const unsigned int /*h*/) { }
+
+void HeadlessWindow::ProcessEvents() { }
+
+void HeadlessWindow::SwapBuffers() {
+    display.swap();
+    MakeCurrent();
+}
+
+} // namespace headless
+
+PANGOLIN_REGISTER_FACTORY(HeadlessWindow) {
+struct HeadlessWindowFactory : public TypedFactoryInterface<WindowInterface> {
+    std::map<std::string,Precedence> Schemes() const override
+    {
+        return {{"egl",10}, {"nogui",10}, {"headless",10}, {"none",10}};
+    }
+    const char* Description() const override
+    {
+        return "Headless GL Buffer";
+    }
+    ParamSet Params() const override
+    {
+        return {{
+            {"w","640","Requested buffer width"},
+            {"h","480","Requested buffer height"},
+            {"window_title","main","Title (Unused)"},
+        }};
+    }
+    std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+        return std::unique_ptr<WindowInterface>(new headless::HeadlessWindow(uri.Get<int>("w", 640), uri.Get<int>("h", 480)));
+    }
+
+    virtual ~HeadlessWindowFactory() { }
+};
+
+return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<HeadlessWindowFactory>());
+}
+
+} // namespace pangolin
+

third-party/DPVO/Pangolin/components/pango_windowing/src/display_osx.mm

@@ -0,0 +1,213 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2018 Steven Lovegrove, Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+// Silence all the OSX GL deprecation messages.
+#define GL_SILENCE_DEPRECATION
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/windowing/OsxWindow.h>
+#include <pangolin/windowing/PangolinNSGLView.h>
+#include <pangolin/windowing/PangolinNSApplication.h>
+#include <memory>
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 101200
+#  define NSFullScreenWindowMask      NSWindowStyleMaskFullScreen
+#  define NSTitledWindowMask          NSWindowStyleMaskTitled
+#  define NSMiniaturizableWindowMask  NSWindowStyleMaskMiniaturizable
+#  define NSResizableWindowMask       NSWindowStyleMaskResizable
+#  define NSClosableWindowMask        NSWindowStyleMaskClosable
+#endif
+
+// Hack to fix window focus issue
+// http://www.miscdebris.net/blog/2010/03/30/solution-for-my-mac-os-x-gui-program-doesnt-get-focus-if-its-outside-an-application-bundle/
+extern "C" { void CPSEnableForegroundOperation(ProcessSerialNumber* psn); }
+inline void FixOsxFocus()
+{
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    ProcessSerialNumber psn;
+    GetCurrentProcess( &psn );
+    CPSEnableForegroundOperation( &psn );
+    SetFrontProcess( &psn );
+#pragma clang diagnostic pop
+}
+
+namespace pangolin
+{
+
+std::unique_ptr<WindowInterface> CreateOsxWindowAndBind(std::string window_title, int w, int h, const bool is_highres)
+{
+
+    OsxWindow* win = new OsxWindow(window_title, w, h, is_highres);
+
+    return std::unique_ptr<WindowInterface>(win);
+}
+
+OsxWindow::OsxWindow(
+    const std::string& title, int width, int height, bool USE_RETINA
+) {
+    ///////////////////////////////////////////////////////////////////////
+    // Make sure Application is initialised correctly.
+    // This can be run repeatedly.
+
+    [NSApplication sharedApplication];
+    PangolinAppDelegate *delegate = [[PangolinAppDelegate alloc] init];
+
+    [NSApp setDelegate:delegate];
+    [NSApp setPresentationOptions:NSFullScreenWindowMask];
+
+    [PangolinNSApplication run_pre];
+    [PangolinNSApplication run_step];
+
+    ///////////////////////////////////////////////////////////////////////
+    // Create Window
+
+    NSRect viewRect = NSMakeRect( 0.0, 0.0, width, height );
+
+    _window = [[NSWindow alloc] initWithContentRect:viewRect styleMask:NSTitledWindowMask|NSMiniaturizableWindowMask|NSResizableWindowMask|NSClosableWindowMask backing:NSBackingStoreBuffered defer:YES];
+    [_window setTitle:[NSString stringWithUTF8String:title.c_str()]];
+    [_window setOpaque:YES];
+    [_window makeKeyAndOrderFront:NSApp];
+    [_window setCollectionBehavior: NSWindowCollectionBehaviorFullScreenPrimary];
+
+    PangolinWindowDelegate *windelegate = [[PangolinWindowDelegate alloc] init];
+    [_window setDelegate:windelegate];
+    windelegate->osx_window = this;
+
+    ///////////////////////////////////////////////////////////////////////
+    // Create OpenGL View for Window
+
+    NSOpenGLPixelFormatAttribute attrs[] =
+    {
+        NSOpenGLPFADoubleBuffer,
+        NSOpenGLPFADepthSize, 32,
+        NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersionLegacy,
+        0
+    };
+
+    NSOpenGLPixelFormat *format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs];
+    view = [[PangolinNSGLView alloc] initWithFrame:_window.frame pixelFormat:format];
+    view->osx_window = this;
+
+    [format release];
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070
+    if( USE_RETINA && floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_6)
+        [view setWantsBestResolutionOpenGLSurface:YES];
+#endif /*MAC_OS_X_VERSION_MAX_ALLOWED*/
+
+    [_window setContentView:view];
+
+    glewInit();
+
+    FixOsxFocus();
+}
+
+OsxWindow::~OsxWindow()
+{
+    // Not sure how to deallocate...
+}
+
+
+void OsxWindow::ShowFullscreen(const TrueFalseToggle on_off)
+{
+    const bool is_fullscreen = ([_window styleMask] & NSFullScreenWindowMask) == NSFullScreenWindowMask;
+    if(should_toggle(on_off, is_fullscreen) ) {
+        [_window toggleFullScreen:nil];
+    }
+}
+
+void OsxWindow::Move(int x, int y)
+{
+    [_window setFrame:CGRectMake(x, y, [_window frame].size.width,
+      [_window frame].size.height) display:NO];
+}
+
+void OsxWindow::Resize(unsigned int w, unsigned int h)
+{
+    const CGFloat title_height = _window.frame.size.height -
+      [_window contentRectForFrameRect: _window.frame].size.height;
+
+    [_window setFrame:CGRectMake([_window frame].origin.x,
+      [_window frame].origin.y, w, h+title_height) display:NO];
+}
+
+void OsxWindow::MakeCurrent()
+{
+    [[view openGLContext] makeCurrentContext];
+}
+
+void OsxWindow::RemoveCurrent()
+{
+    [NSOpenGLContext clearCurrentContext];
+}
+
+void OsxWindow::SwapBuffers()
+{
+    [[view openGLContext] flushBuffer];
+}
+
+void OsxWindow::ProcessEvents()
+{
+    [PangolinNSApplication run_step];
+}
+
+PANGOLIN_REGISTER_FACTORY(OsxWindow)
+{
+  struct OsxWindowFactory : public TypedFactoryInterface<WindowInterface> {
+    std::map<std::string,Precedence> Schemes() const override
+    {
+        return {{"cocoa",10}, {"default",10}};
+    }
+    const char* Description() const override
+    {
+        return "Use MacOS native window toolkit";
+    }
+    ParamSet Params() const override
+    {
+        return {{
+            {"window_title","window","Title of application Window"},
+            {"HIGHRES","true","Use 'retina' resolution"},
+            {"w","640","Requested window width"},
+            {"h","480","Requested window height"},
+        }};
+    }
+    std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+
+      const std::string window_title = uri.Get<std::string>("window_title", "window");
+      const int w = uri.Get<int>("w", 640);
+      const int h = uri.Get<int>("h", 480);
+      const bool is_highres = uri.Get<bool>(PARAM_HIGHRES, true);
+      return std::unique_ptr<WindowInterface>(CreateOsxWindowAndBind(window_title, w, h, is_highres));
+    }
+  };
+
+  return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<OsxWindowFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/src/display_wayland.cpp

@@ -0,0 +1,1074 @@
+#include <pangolin/platform.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/gl/colour.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/windowing/window.h>
+
+#include <wayland-client.h>
+#include <wayland-egl.h>
+#include <EGL/egl.h>
+#include <xkbcommon/xkbcommon.h>
+#include <wayland-cursor.h>
+#include <linux/input.h>
+#include <sys/mman.h>
+
+#include <mutex>
+#include <string.h>
+#include <unistd.h>
+#include <cstdlib>
+
+#include <xdg-shell-client-protocol.h>
+
+#define WAYLAND_VERSION_GE(MAJ, MIN) WAYLAND_VERSION_MAJOR >= MAJ && WAYLAND_VERSION_MINOR >= MIN
+
+// The "wl_array_for_each" C macro for C++
+// https://github.com/libretro/RetroArch/blob/a9125fffaa981cab811ba6caf4d756fa6ef9a561/input/common/wayland_common.h#L50-L53
+#define WL_ARRAY_FOR_EACH(pos, array, type) \
+    for (pos = (type)(array)->data; \
+         (const char *) pos < ((const char *) (array)->data + (array)->size); \
+         (pos)++)
+
+namespace pangolin {
+
+namespace wayland {
+
+static const std::map<enum xdg_toplevel_resize_edge, std::string> resize_cursor = {
+    {XDG_TOPLEVEL_RESIZE_EDGE_NONE, "grabbing"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_TOP, "top_side"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM, "bottom_side"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_LEFT, "left_side"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT, "top_left_corner"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT, "bottom_left_corner"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_RIGHT, "right_side"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT, "top_right_corner"},
+    {XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT, "bottom_right_corner"},
+};
+
+struct ButtonSurface {
+    struct wl_surface *surface;
+    struct wl_subsurface *subsurface;
+    struct wl_egl_window *egl_window;
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+    EGLDisplay egl_display;
+    const int32_t x, y;
+    const uint width, height;
+    pangolin::Colour colour;
+
+    enum type {
+        CLOSE = 100,
+        MAXIMISE
+    } function;
+
+    ButtonSurface(wl_compositor* compositor, wl_subcompositor* subcompositor,
+                  wl_surface* source, EGLDisplay egl_display, EGLConfig config,
+                  int32_t x, int32_t y, uint width, uint height,
+                  type fnct, pangolin::Colour colour
+                  ) :
+        egl_display(egl_display),
+        x(x), y(y),
+        width(width), height(height),
+        colour(colour),
+        function(fnct)
+    {
+        surface = wl_compositor_create_surface(compositor);
+        subsurface = wl_subcompositor_get_subsurface(subcompositor, surface, source);
+        egl_context = eglCreateContext (egl_display, config, EGL_NO_CONTEXT, nullptr);
+        egl_window = wl_egl_window_create(surface, width, height);
+        egl_surface = eglCreateWindowSurface(egl_display, config, (EGLNativeWindowType)egl_window, nullptr);
+    }
+
+    ~ButtonSurface() {
+        if(egl_surface) eglDestroySurface(egl_display, egl_surface);
+        if(egl_window)  wl_egl_window_destroy(egl_window);
+        if(egl_context) eglDestroyContext(egl_display, egl_context);
+
+        if(subsurface)  wl_subsurface_destroy(subsurface);
+        if(surface)     wl_surface_destroy(surface);
+    }
+
+    void reposition(const int main_w) const {
+        wl_subsurface_set_position(subsurface, main_w-x-width, y);
+    }
+
+    void draw() const {
+        eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
+        glClearColor(colour.r, colour.g, colour.b, colour.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        switch (function) {
+        case CLOSE:
+            glLineWidth(3);
+            glColor3f(1, 1, 1);
+            glBegin(GL_LINES);
+            glVertex2f(-1, -1);
+            glVertex2f(1, 1);
+            glVertex2f(1, -1);
+            glVertex2f(-1, 1);
+            glEnd();
+            break;
+        case MAXIMISE:
+            glLineWidth(2);
+            glColor3f(0, 0, 0);
+            glBegin(GL_LINE_LOOP);
+            glVertex2f(-0.7f, -0.7f);
+            glVertex2f(0.7f, -0.7f);
+            glVertex2f(0.7f, 0.7f);
+            glVertex2f(-0.7f, 0.7f);
+            glEnd();
+            glLineWidth(3);
+            glBegin(GL_LINES);
+            glVertex2f(+0.7f, +0.7f);
+            glVertex2f(-0.7f, +0.7f);
+            glEnd();
+            break;
+        }
+        eglSwapInterval(egl_display, 0);
+        eglSwapBuffers(egl_display, egl_surface);
+    }
+};
+
+struct DecorationSurface {
+    struct wl_surface *surface;
+    struct wl_subsurface *subsurface;
+    struct wl_egl_window *egl_window;
+    EGLSurface egl_surface;
+    EGLContext egl_context;
+    EGLDisplay egl_display;
+    pangolin::Colour colour;
+    uint border_size;
+    uint title_bar_size;
+
+    enum xdg_toplevel_resize_edge function;
+
+    DecorationSurface(wl_compositor* compositor, wl_subcompositor* subcompositor,
+                      wl_surface* source, EGLDisplay egl_display, EGLConfig config,
+                      const uint _border_size, const uint _title_bar_size,
+                      enum xdg_toplevel_resize_edge type, pangolin::Colour _colour
+                      ) :
+        egl_display(egl_display),
+        colour(_colour),
+        border_size(_border_size),
+        title_bar_size(_title_bar_size),
+        function(type)
+    {
+        surface = wl_compositor_create_surface(compositor);
+        subsurface = wl_subcompositor_get_subsurface(subcompositor, surface, source);
+        egl_context = eglCreateContext(egl_display, config, EGL_NO_CONTEXT, nullptr);
+        egl_window = wl_egl_window_create(surface, 50, 50);
+        egl_surface = eglCreateWindowSurface(egl_display, config, (EGLNativeWindowType)egl_window, nullptr);
+    }
+
+    ~DecorationSurface() {
+        if(egl_surface) eglDestroySurface(egl_display, egl_surface);
+        if(egl_window)  wl_egl_window_destroy(egl_window);
+        if(egl_context) eglDestroyContext(egl_display, egl_context);
+
+        if(subsurface)  wl_subsurface_destroy(subsurface);
+        if(surface)     wl_surface_destroy(surface);
+    }
+
+    void calc_dim(const int main_w, const int main_h, int &x, int &y, int &w, int &h) const {
+        // get position and dimension from type and main surface
+        switch (function) {
+        case XDG_TOPLEVEL_RESIZE_EDGE_NONE:
+            x=0; y=-title_bar_size;
+            w=main_w; h=title_bar_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_TOP:
+            x=0; y=-title_bar_size-border_size;
+            w=main_w; h=border_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM:
+            x=0; y=main_h;
+            w=main_w; h=border_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_LEFT:
+            x=-border_size; y=-title_bar_size;
+            w=border_size; h=main_h+title_bar_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT:
+            x=-border_size; y=-border_size-title_bar_size;
+            w=border_size; h=border_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT:
+            x=-border_size; y=main_h;
+            w=border_size; h=border_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_RIGHT:
+            x=main_w; y=-title_bar_size;
+            w=border_size; h=main_h+title_bar_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT:
+            x=main_w; y=-border_size-title_bar_size;
+            w=border_size; h=border_size;
+            break;
+        case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT:
+            x=main_w; y=main_h;
+            w=border_size; h=border_size;
+            break;
+        }
+    }
+
+    void resize(const int main_w, const int main_h) const {
+        int x=0, y=0, w=0, h=0;
+        calc_dim(main_w, main_h, x, y, w, h);
+        wl_subsurface_set_position(subsurface, x, y);
+        wl_egl_window_resize(egl_window, w, h, 0, 0);
+    }
+
+    void draw() const {
+        eglMakeCurrent(egl_display, egl_surface, egl_surface, egl_context);
+        glClearColor(colour.r, colour.g, colour.b, colour.a);
+        glClear(GL_COLOR_BUFFER_BIT);
+        eglSwapInterval(egl_display, 0);
+        eglSwapBuffers(egl_display, egl_surface);
+    }
+};
+
+struct Decoration {
+    Decoration(const uint border_size,
+               const uint title_size,
+               const pangolin::Colour colour,
+               wl_compositor* compositor,
+               wl_subcompositor* subcompositor,
+               wl_surface* surface,
+               EGLDisplay egl_display,
+               EGLConfig config
+               ) :
+        border_size(border_size),
+        title_size(title_size),
+        colour(colour),
+        egl_display(egl_display),
+        compositor(compositor),
+        subcompositor(subcompositor),
+        surface(surface),
+        config(config)
+    { }
+
+    void create() {
+        // reserve memory to prevent that DecorationSurface's destructor gets
+        // called by 'emplace_back'
+        decorations.reserve(9);
+
+        // title bar, 2D movement
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_NONE, colour);
+
+        // sides, 1D resizing
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_LEFT, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_RIGHT, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_TOP, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM, colour);
+
+        // corners, 2D resizing
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT, colour);
+        decorations.emplace_back(compositor, subcompositor, surface, egl_display, config, border_size, title_size, XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT, colour);
+
+        // buttons
+        buttons.reserve(2);
+        buttons.emplace_back(compositor, subcompositor, decorations[0].surface, egl_display, config, 5, 1, button_width, button_height,  ButtonSurface::type::CLOSE, pangolin::Colour(0, 110/255.0, 182/255.0));
+        buttons.emplace_back(compositor, subcompositor, decorations[0].surface, egl_display, config, 10+button_width, 1, button_width, button_height,  ButtonSurface::type::MAXIMISE, pangolin::Colour(1.0, 204/255.0f, 0));
+    }
+
+    void destroy() {
+        decorations.clear();
+        buttons.clear();
+    }
+
+    void resize(const int32_t width, const int32_t height) {
+        for(const DecorationSurface &d : decorations) { d.resize(width, height); }
+        for(const ButtonSurface &b : buttons) { b.reposition(width); }
+    }
+
+    void draw() {
+        for(const DecorationSurface &d : decorations) { d.draw(); }
+        for(const ButtonSurface &b : buttons) { b.draw(); }
+    }
+
+    void setTypeFromSurface(const wl_surface *surface) {
+        for(const DecorationSurface &d : decorations) {
+            if(d.surface==surface) {
+                last_type = d.function;
+                return;
+            }
+        }
+        for(const ButtonSurface &b : buttons) {
+            if(b.surface==surface) {
+                last_type = b.function;
+                return;
+            }
+        }
+        // surface is not part of the window decoration
+        last_type = -1;
+    }
+
+    const std::string getCursorForCurrentSurface() const {
+        return resize_cursor.count((enum xdg_toplevel_resize_edge)last_type) ? resize_cursor.at((enum xdg_toplevel_resize_edge)last_type) : "left_ptr";
+    }
+
+    void toContentSize(const int window_w, const int window_h, int &content_w, int &content_h) {
+        content_w = window_w - (2*border_size);
+        content_h = window_h - (2*border_size + title_size);
+    }
+
+    void toWindowSize(const int content_w, const int content_h, int &window_w, int &window_h) {
+        window_w = content_w + (2*border_size);
+        window_h = content_h + (2*border_size + title_size);
+    }
+
+    std::vector<DecorationSurface> decorations;
+    int last_type;
+
+    std::vector<ButtonSurface> buttons;
+
+    const uint border_size;
+    const uint title_size;
+    const pangolin::Colour colour;
+    EGLDisplay egl_display;
+    wl_compositor* compositor;
+    wl_subcompositor* subcompositor;
+    wl_surface* surface;
+    EGLConfig config;
+
+    static const uint button_width;
+    static const uint button_height;
+};
+
+const uint Decoration::button_width = 25;
+const uint Decoration::button_height = 15;
+
+struct WaylandWindow;
+
+struct WaylandDisplay {
+    WaylandDisplay();
+
+    ~WaylandDisplay();
+
+    struct wl_display *wdisplay = nullptr;
+    struct wl_registry *wregistry = nullptr;
+    struct wl_compositor *wcompositor = nullptr;
+    struct wl_subcompositor *wsubcompositor = nullptr;
+    struct xdg_wm_base *xshell = nullptr;
+
+    struct wl_seat *wseat = nullptr;
+    struct wl_keyboard *wkeyboard = nullptr;
+    struct wl_pointer *pointer = nullptr;
+
+    // for cursor
+    struct wl_shm *shm = nullptr;
+    struct wl_cursor_theme *cursor_theme = nullptr;
+    struct wl_surface *cursor_surface = nullptr;
+
+    // xkbcommon
+    struct xkb_context *xkb_context = nullptr;
+    struct xkb_keymap *keymap = nullptr;
+    struct xkb_state *xkb_state = nullptr;
+    KeyModifierBitmask flags;
+
+    std::vector<EGLConfig> egl_configs;
+    EGLContext egl_context = nullptr;
+    EGLDisplay egl_display = nullptr;
+
+    static constexpr EGLint attribs[] = {
+        EGL_RENDERABLE_TYPE , EGL_OPENGL_BIT,
+        EGL_RED_SIZE        , 8,
+        EGL_GREEN_SIZE      , 8,
+        EGL_BLUE_SIZE       , 8,
+        EGL_DEPTH_SIZE      , 24,
+        EGL_STENCIL_SIZE    , 8,
+        EGL_NONE
+    };
+
+    // assume a single window for now
+    WaylandWindow* window;
+};
+
+constexpr EGLint WaylandDisplay::attribs[];
+
+struct WaylandWindow : public WindowInterface
+{
+public:
+    WaylandWindow(const int width, const int height, const std::string& title, std::shared_ptr<WaylandDisplay> display);
+
+    ~WaylandWindow() override;
+
+    void ShowFullscreen(const TrueFalseToggle on_off) override;
+
+    void Move(const int x, const int y) override;
+
+    void Resize(const unsigned int w, const unsigned int h) override;
+
+    void MakeCurrent() override;
+
+    void RemoveCurrent() override;
+
+    void SwapBuffers() override;
+
+    void ProcessEvents() override;
+
+//private:
+    std::shared_ptr<WaylandDisplay> display;
+
+    EGLint width, height;
+    bool is_fullscreen;
+    bool is_maximised;
+    // store floating window dimensions to restore to,
+    // when returning from maximised or fullscreen
+    int floating_width = 0, floating_height = 0;
+
+    bool pressed = false;
+    int lastx=0;
+    int lasty=0;
+
+    struct wl_surface *wsurface = nullptr;
+    struct wl_egl_window *egl_window = nullptr;
+    struct xdg_surface *xshell_surface = nullptr;
+    struct xdg_toplevel *xshell_toplevel = nullptr;
+
+    // we can only attach a buffer to a surface after it has been configured at least once
+    bool configured = false;
+
+    EGLSurface egl_surface = nullptr;
+
+    std::shared_ptr<Decoration> decoration;
+};
+
+// map wayland ids to pangolin ids
+static const std::map<uint,int> wl_button_ids = {
+    {BTN_LEFT, 0},
+    {BTN_MIDDLE, 1},
+    {BTN_RIGHT, 2},
+};
+
+static const std::map<uint,KeyModifier> wl_key_mod_ids = {
+    {KEY_LEFTSHIFT, KeyModifierShift},
+    {KEY_RIGHTSHIFT, KeyModifierShift},
+    {KEY_LEFTCTRL, KeyModifierCtrl},
+    {KEY_RIGHTCTRL, KeyModifierCtrl},
+    {KEY_LEFTALT, KeyModifierAlt},
+    {KEY_RIGHTALT, KeyModifierAlt},
+};
+
+static const std::map<uint,int> wl_key_special_ids = {
+    {KEY_F1, PANGO_KEY_F1},
+    {KEY_F2, PANGO_KEY_F2},
+    {KEY_F3, PANGO_KEY_F3},
+    {KEY_F4, PANGO_KEY_F4},
+    {KEY_F5, PANGO_KEY_F5},
+    {KEY_F6, PANGO_KEY_F6},
+    {KEY_F7, PANGO_KEY_F7},
+    {KEY_F8, PANGO_KEY_F8},
+    {KEY_F9, PANGO_KEY_F9},
+    {KEY_F10, PANGO_KEY_F10},
+    {KEY_F11, PANGO_KEY_F11},
+    {KEY_F12, PANGO_KEY_F12},
+
+    {KEY_LEFT, PANGO_KEY_LEFT},
+    {KEY_UP, PANGO_KEY_UP},
+    {KEY_RIGHT, PANGO_KEY_RIGHT},
+    {KEY_DOWN, PANGO_KEY_DOWN},
+
+    {KEY_PAGEUP, PANGO_KEY_PAGE_UP},
+    {KEY_PAGEDOWN, PANGO_KEY_PAGE_DOWN},
+    {KEY_HOME, PANGO_KEY_HOME},
+    {KEY_END, PANGO_KEY_END},
+    {KEY_INSERT, PANGO_KEY_INSERT},
+};
+
+static void handle_configure_toplevel(void *data, struct xdg_toplevel */*xdg_toplevel*/, int32_t width, int32_t height, struct wl_array *states) {
+
+    const static uint min_width = 70;
+    const static uint min_height = 70;
+
+    WaylandWindow* const w = static_cast<WaylandWindow*>(data);
+
+    // reset window states
+    w->is_maximised = w->is_fullscreen = false;
+
+    // set new window states
+    const enum xdg_toplevel_state *state;
+    WL_ARRAY_FOR_EACH(state, states, const enum xdg_toplevel_state*) {
+        switch (*state) {
+        case XDG_TOPLEVEL_STATE_MAXIMIZED:
+            w->is_maximised = true;
+            break;
+        case XDG_TOPLEVEL_STATE_FULLSCREEN:
+            w->is_fullscreen = true;
+            break;
+        default:
+            break;
+        }
+    }
+
+    // set proposed dimensions, this includes the entire window with decorations
+    int restore_w = width;
+    int restore_h = height;
+
+    // restore from stored floating state if not specified
+    if (restore_w==0) restore_w = w->floating_width;
+    if (restore_h==0) restore_h = w->floating_height;
+
+    // use initially provided dimensions if floating was never set,
+    // these are in the "content" dimensions
+    if (restore_w==0) restore_w = w->width;
+    if (restore_h==0) restore_h = w->height;
+
+    if(!w->is_fullscreen && (width!=0 && height!=0)) {
+        // has decoration
+        w->decoration->toContentSize(restore_w, restore_h, w->width, w->height);
+        w->width = std::max(w->width, int(min_width));
+        w->height = std::max(w->height, int(min_height));
+    }
+    else {
+        w->width = restore_w;
+        w->height = restore_h;
+    }
+
+    // store the current state as floating state,
+    // if we are neither maximised nor fullscreen
+    if (!w->is_maximised && !w->is_fullscreen) {
+        w->floating_width = w->width;
+        w->floating_height = w->height;
+    }
+}
+
+static void handle_configure(void *data, struct xdg_surface *xdg_surface, uint32_t serial) {
+    WaylandWindow* const w = static_cast<WaylandWindow*>(data);
+
+    // resize main surface
+    wl_egl_window_resize(w->egl_window, w->width, w->height, 0, 0);
+
+    // resize all decoration elements
+    w->decoration->resize(w->width, w->height);
+
+    // notify Panglin views about resized area
+    w->ResizeSignal(WindowResizeEvent{w->width, w->height});
+
+    xdg_surface_ack_configure(xdg_surface, serial);
+
+    w->configured = true;
+}
+
+static const struct xdg_surface_listener shell_surface_listener = {
+    handle_configure,
+};
+
+static void handle_toplevel_close(void *data, struct xdg_toplevel */*xdg_toplevel*/) {
+    static_cast<WaylandWindow*>(data)->CloseSignal();
+}
+
+static const struct xdg_toplevel_listener toplevel_listener = {
+    .configure = handle_configure_toplevel,
+    .close = handle_toplevel_close,
+};
+
+static void xdg_wm_base_ping(void */*data*/, struct xdg_wm_base *xdg_wm_base, uint32_t serial) {
+    xdg_wm_base_pong(xdg_wm_base, serial);
+}
+
+static const struct xdg_wm_base_listener shell_listener = {
+    .ping = xdg_wm_base_ping
+};
+
+static void pointer_handle_enter(void *data, struct wl_pointer *pointer, uint32_t serial, struct wl_surface *surface, wl_fixed_t /*sx*/, wl_fixed_t /*sy*/) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    WaylandWindow* const w = d->window;
+    w->decoration->setTypeFromSurface(surface);
+
+    const std::string cursor = w->decoration->getCursorForCurrentSurface();
+
+    const auto image = wl_cursor_theme_get_cursor(d->cursor_theme, cursor.c_str())->images[0];
+    wl_pointer_set_cursor(pointer, serial, d->cursor_surface, image->hotspot_x, image->hotspot_y);
+    wl_surface_attach(d->cursor_surface, wl_cursor_image_get_buffer(image), 0, 0);
+    wl_surface_damage(d->cursor_surface, 0, 0, image->width, image->height);
+    wl_surface_commit(d->cursor_surface);
+}
+
+static void pointer_handle_leave(void *data, struct wl_pointer */*pointer*/, uint32_t /*serial*/, struct wl_surface */*surface*/) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    d->window->pressed = false;
+}
+
+static void pointer_handle_motion(void *data, struct wl_pointer */*pointer*/, uint32_t /*time*/, wl_fixed_t sx, wl_fixed_t sy) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    WaylandWindow* const w = d->window;
+
+    w->lastx=wl_fixed_to_int(sx);
+    w->lasty=wl_fixed_to_int(sy);
+    if(w->pressed) {
+        w->MouseMotionSignal(MouseMotionEvent{{float(w->lastx), float(w->lasty), d->flags}});
+    }
+    else {
+        w->PassiveMouseMotionSignal(MouseMotionEvent{{float(w->lastx), float(w->lasty), d->flags}});
+    }
+}
+
+static void pointer_handle_button(void *data, struct wl_pointer */*wl_pointer*/, uint32_t serial, uint32_t /*time*/, uint32_t button, uint32_t state) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    WaylandWindow* const w = d->window;
+
+    if(w->decoration->last_type<0) {
+        // input goes to pangoling view
+        if(!wl_button_ids.count(button))
+            return;
+
+        w->pressed = (state==WL_POINTER_BUTTON_STATE_PRESSED);
+        w->MouseSignal(MouseEvent{{float(w->lastx), float(w->lasty), d->flags}, wl_button_ids.at(button), w->pressed});
+    }
+    else {
+        // input goes to window decoration
+        // resizing using window decoration
+        if((button==BTN_LEFT) && (state==WL_POINTER_BUTTON_STATE_PRESSED)) {
+            switch (w->decoration->last_type) {
+            case XDG_TOPLEVEL_RESIZE_EDGE_NONE:
+                xdg_toplevel_move(w->xshell_toplevel, d->wseat, serial);
+                break;
+            case XDG_TOPLEVEL_RESIZE_EDGE_TOP:
+            case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM:
+            case XDG_TOPLEVEL_RESIZE_EDGE_LEFT:
+            case XDG_TOPLEVEL_RESIZE_EDGE_TOP_LEFT:
+            case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_LEFT:
+            case XDG_TOPLEVEL_RESIZE_EDGE_RIGHT:
+            case XDG_TOPLEVEL_RESIZE_EDGE_TOP_RIGHT:
+            case XDG_TOPLEVEL_RESIZE_EDGE_BOTTOM_RIGHT:
+                xdg_toplevel_resize(w->xshell_toplevel, d->wseat, serial, w->decoration->last_type);
+                break;
+            case ButtonSurface::type::CLOSE:
+                w->CloseSignal();
+                break;
+            case ButtonSurface::type::MAXIMISE:
+                if(w->is_maximised) {
+                    xdg_toplevel_unset_maximized(w->xshell_toplevel);
+                }
+                else {
+                    xdg_toplevel_set_maximized(w->xshell_toplevel);
+                }
+
+                break;
+            }
+        }
+    }
+}
+
+static void pointer_handle_axis(void *data, struct wl_pointer */*wl_pointer*/, uint32_t /*time*/, uint32_t axis, wl_fixed_t value) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    WaylandWindow* const w = d->window;
+
+    const float v = wl_fixed_to_double(value);
+    float dx = 0, dy = 0;
+
+    switch (axis) {
+    case REL_X: dy = v; break;   // up, down
+    case REL_Y: dx = v; break;   // left, right
+    }
+
+    w->SpecialInputSignal(SpecialInputEvent({
+        {float(w->lastx), float(w->lasty), d->flags},
+        InputSpecialScroll, {dx, dy, 0, 0}
+    }));
+}
+
+#if WAYLAND_VERSION_GE(1,12)
+
+static void pointer_handle_frame(void */*data*/, struct wl_pointer */*wl_pointer*/) { }
+
+static void pointer_handle_axis_source(void */*data*/, struct wl_pointer */*wl_pointer*/, uint32_t /*axis_source*/) { }
+
+static void pointer_handle_axis_stop(void */*data*/, struct wl_pointer */*wl_pointer*/, uint32_t /*time*/, uint32_t /*axis*/) { }
+
+static void pointer_handle_axis_discrete(void */*data*/, struct wl_pointer */*wl_pointer*/, uint32_t /*axis*/, int32_t /*discrete*/) { }
+
+#endif
+
+static const struct wl_pointer_listener pointer_listener = {
+    pointer_handle_enter,
+    pointer_handle_leave,
+    pointer_handle_motion,
+    pointer_handle_button,
+    pointer_handle_axis,
+#if WAYLAND_VERSION_GE(1,12)
+    pointer_handle_frame,
+    pointer_handle_axis_source,
+    pointer_handle_axis_stop,
+    pointer_handle_axis_discrete,
+#endif
+};
+
+static void keyboard_handle_keymap(void *data, struct wl_keyboard */*keyboard*/, uint32_t format, int fd, uint32_t size) {
+    if ((!data) || (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)) {
+        std::cerr << "wrong keymap format, got " << format << ", expected WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1" << std::endl;
+        close(fd);
+        return;
+    }
+
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+
+    char *keymap_string = static_cast<char*>(mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0));
+    if (keymap_string == MAP_FAILED) {
+        std::cerr << "keymap mmap failed: " << std::string(std::strerror(errno)) << std::endl;
+        close(fd);
+        return;
+    }
+    xkb_keymap_unref(d->keymap);
+    d->keymap = xkb_keymap_new_from_string(d->xkb_context, keymap_string, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
+    munmap(keymap_string, size);
+    close(fd);
+    xkb_state_unref(d->xkb_state);
+    d->xkb_state = xkb_state_new(d->keymap);
+}
+
+static void keyboard_handle_enter(void *data, struct wl_keyboard */*keyboard*/, uint32_t /*serial*/, struct wl_surface */*surface*/, struct wl_array */*keys*/) {
+    static_cast<WaylandDisplay*>(data)->flags = {};
+}
+
+static void keyboard_handle_leave(void */*data*/, struct wl_keyboard */*keyboard*/, uint32_t /*serial*/, struct wl_surface */*surface*/) { }
+
+static void keyboard_handle_key(void *data, struct wl_keyboard */*keyboard*/, uint32_t /*serial*/, uint32_t /*time*/, uint32_t key, uint32_t state) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+    WaylandWindow* const w = d->window;
+
+    // modifier keys
+    if(wl_key_mod_ids.count(key)) {
+        if(state==WL_KEYBOARD_KEY_STATE_PRESSED) {
+            d->flags |= wl_key_mod_ids.at(key);
+        }
+        else if (state==WL_KEYBOARD_KEY_STATE_RELEASED) {
+            // NOTE: "d->flags &= ~wl_key_mod_ids.at(key);" does not work here
+            d->flags.set(wl_key_mod_ids.at(key), false);
+        }
+        return;
+    }
+
+    // character and special keys
+    int pango_key = -1;
+    if(wl_key_special_ids.count(key)) {
+        // special keys
+        pango_key = PANGO_SPECIAL + wl_key_special_ids.at(key);
+    }
+    else {
+        // character keys
+        const uint32_t utf32 = xkb_state_key_get_utf32(d->xkb_state, key+8);
+        // filter non-ASCII
+        if(utf32>0 && utf32<=127) {
+            pango_key = int(utf32);
+        }
+    }
+
+    if(pango_key>0) {
+        w->KeyboardSignal(KeyboardEvent{{float(w->lastx), float(w->lasty), d->flags}, uint8_t(pango_key), state==WL_KEYBOARD_KEY_STATE_PRESSED});
+    }
+}
+
+static void keyboard_handle_modifiers(void *data, struct wl_keyboard */*keyboard*/, uint32_t /*serial*/, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) {
+    WaylandDisplay* const d = static_cast<WaylandDisplay*>(data);
+
+    xkb_state_update_mask(d->xkb_state, mods_depressed, mods_latched, mods_locked, 0, 0, group);
+}
+
+#if WAYLAND_VERSION_GE(1,12)
+
+static void keyboard_handle_repeat_info(void */*data*/, struct wl_keyboard */*wl_keyboard*/, int32_t /*rate*/, int32_t /*delay*/) { }
+
+#endif
+
+static const struct wl_keyboard_listener keyboard_listener = {
+    keyboard_handle_keymap,
+    keyboard_handle_enter,
+    keyboard_handle_leave,
+    keyboard_handle_key,
+    keyboard_handle_modifiers,
+#if WAYLAND_VERSION_GE(1,12)
+    keyboard_handle_repeat_info,
+#endif
+};
+
+static void seat_handle_capabilities(void *data, struct wl_seat *seat, uint32_t caps1) {
+    WaylandDisplay* const w = static_cast<WaylandDisplay*>(data);
+
+    enum wl_seat_capability caps;
+    caps = (enum wl_seat_capability)caps1;
+    if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
+        w->wkeyboard = wl_seat_get_keyboard(seat);
+        wl_keyboard_add_listener(w->wkeyboard, &keyboard_listener, data);
+    } else {
+        wl_keyboard_destroy(w->wkeyboard);
+        w->wkeyboard = nullptr;
+    }
+    if (caps & WL_SEAT_CAPABILITY_POINTER) {
+        w->pointer = wl_seat_get_pointer(seat);
+        w->cursor_surface = wl_compositor_create_surface(w->wcompositor);
+        wl_pointer_add_listener(w->pointer, &pointer_listener, data);
+    } else {
+        wl_pointer_destroy(w->pointer);
+        w->pointer = nullptr;
+    }
+}
+
+static void seat_handle_name(void */*data*/, struct wl_seat */*wl_seat*/, const char */*name*/) { }
+
+static const struct wl_seat_listener seat_listener = {
+    seat_handle_capabilities,
+    seat_handle_name,
+};
+
+static void global_registry_handler(void *data, struct wl_registry *registry, uint32_t id, const char *interface, uint32_t version) {
+    WaylandDisplay* const w = static_cast<WaylandDisplay*>(data);
+
+    if (strcmp(interface, wl_compositor_interface.name) == 0) {
+        w->wcompositor = reinterpret_cast<wl_compositor*> (wl_registry_bind(registry, id, &wl_compositor_interface, std::min<uint32_t>(version,4)));
+    }
+    else if (strcmp(interface, wl_subcompositor_interface.name) == 0) {
+        w->wsubcompositor = static_cast<wl_subcompositor*>(wl_registry_bind(registry, id, &wl_subcompositor_interface, std::min<uint32_t>(version,1)));
+    }
+    else if (strcmp(interface, xdg_wm_base_interface.name) == 0) {
+        w->xshell = reinterpret_cast<xdg_wm_base*> (wl_registry_bind(registry, id, &xdg_wm_base_interface, std::min<uint32_t>(version,3)));
+    }
+    else if (strcmp(interface, wl_seat_interface.name) == 0) {
+        w->wseat = reinterpret_cast<wl_seat*>(wl_registry_bind(registry, id, &wl_seat_interface, std::min<uint32_t>(version,5)));
+        wl_seat_add_listener(w->wseat, &seat_listener, data);
+    }
+    else if (strcmp(interface, wl_shm_interface.name) == 0) {
+        w->shm = static_cast<wl_shm*>(wl_registry_bind(registry, id, &wl_shm_interface, std::min<uint32_t>(version,1)));
+        w->cursor_theme = wl_cursor_theme_load(nullptr, 16, w->shm);
+    }
+}
+
+static void global_registry_remover(void */*data*/, struct wl_registry */*registry*/, uint32_t /*id*/) { }
+
+static const struct wl_registry_listener wregistry_listener = {
+    global_registry_handler,
+    global_registry_remover
+};
+
+WaylandDisplay::WaylandDisplay() {
+    xkb_context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+
+    wdisplay = wl_display_connect(nullptr);
+    if (wdisplay == nullptr) {
+        throw std::runtime_error("Cannot connect to Wayland compositor!");
+    }
+
+    wregistry = wl_display_get_registry(wdisplay);
+    wl_registry_add_listener(wregistry, &wregistry_listener, this);
+
+    wl_display_roundtrip(wdisplay);
+
+    egl_display = eglGetDisplay((EGLNativeDisplayType)wdisplay);
+    if(!egl_display) {
+        std::cerr << "Failed to open EGL display" << std::endl;
+    }
+
+    EGLint major, minor;
+    if(eglInitialize(egl_display, &major, &minor)==EGL_FALSE) {
+        std::cerr << "EGL init failed" << std::endl;
+    }
+
+    if(eglBindAPI(EGL_OPENGL_API)==EGL_FALSE) {
+        std::cerr << "EGL bind failed" << std::endl;
+    }
+
+    EGLint count;
+    eglGetConfigs(egl_display, nullptr, 0, &count);
+
+    egl_configs.resize(count);
+
+    EGLint numConfigs;
+    eglChooseConfig(egl_display, attribs, egl_configs.data(), count, &numConfigs);
+
+    egl_context = eglCreateContext(egl_display, egl_configs[0], EGL_NO_CONTEXT, nullptr);
+
+    if(xshell==nullptr) {
+        throw std::runtime_error("No Wayland shell available!");
+    }
+
+    xdg_wm_base_add_listener(xshell, &shell_listener, this);
+
+    wl_display_roundtrip(wdisplay);
+}
+
+WaylandDisplay::~WaylandDisplay() {
+    // cleanup EGL
+    if(egl_context) eglDestroyContext(egl_display, egl_context);
+    if(egl_display) eglTerminate(egl_display);
+
+    // cleanup Wayland
+    if(wkeyboard)       wl_keyboard_destroy(wkeyboard);
+    if(pointer)         wl_pointer_destroy(pointer);
+    if(cursor_surface)  wl_surface_destroy(cursor_surface);
+    if(cursor_theme)    wl_cursor_theme_destroy(cursor_theme);
+    if(shm)             wl_shm_destroy(shm);
+    if(wseat)           wl_seat_destroy(wseat);
+    if(xshell)          xdg_wm_base_destroy(xshell);
+    if(wsubcompositor)  wl_subcompositor_destroy(wsubcompositor);
+    if(wcompositor)     wl_compositor_destroy(wcompositor);
+    if(wregistry)       wl_registry_destroy(wregistry);
+    if(wdisplay)        wl_display_disconnect(wdisplay);
+
+    if(xkb_context) xkb_context_unref(xkb_context);
+    if(xkb_state)   xkb_state_unref(xkb_state);
+    if(keymap)      xkb_keymap_unref(keymap);
+}
+
+WaylandWindow::WaylandWindow(const int w, const int h,
+                             const std::string& title,
+                             std::shared_ptr<WaylandDisplay> display)
+    : display(display)
+{
+    wsurface = wl_compositor_create_surface(display->wcompositor);
+
+    display->window = this;
+
+    width = w;
+    height = h;
+
+    egl_window = wl_egl_window_create(wsurface, w, h);
+    if(!egl_window) {
+        std::cerr << "Cannot create EGL window" << std::endl;
+    }
+
+    egl_surface = eglCreateWindowSurface(display->egl_display, display->egl_configs[0], (EGLNativeWindowType)egl_window, nullptr);
+    if (egl_surface == EGL_NO_SURFACE) {
+        std::cerr << "Cannot create EGL surface" << std::endl;
+    }
+
+    xshell_surface = xdg_wm_base_get_xdg_surface(display->xshell, wsurface);
+    xdg_surface_add_listener(xshell_surface, &shell_surface_listener, this);
+    xshell_toplevel = xdg_surface_get_toplevel(xshell_surface);
+    xdg_toplevel_add_listener(xshell_toplevel, &toplevel_listener, this);
+    xdg_toplevel_set_title(xshell_toplevel, title.c_str());
+    xdg_toplevel_set_app_id(xshell_toplevel, title.c_str());
+
+    // construct window decoration
+    const pangolin::Colour grey(0.5f, 0.5f, 0.5f);
+    decoration = std::unique_ptr<Decoration>(new Decoration(5, 20, grey, display->wcompositor, display->wsubcompositor, wsurface, display->egl_display, display->egl_configs[0]));
+    decoration->create();
+    decoration->resize(width, height);
+
+    wl_surface_commit(wsurface);
+
+    wl_display_roundtrip(display->wdisplay);
+    wl_display_roundtrip(display->wdisplay);
+
+    // wait for the first configure event
+    while (!configured) {
+        wl_display_dispatch(display->wdisplay);
+    }
+}
+
+WaylandWindow::~WaylandWindow() {
+    if(decoration)  decoration->destroy();
+
+    // cleanup EGL
+    if(egl_surface) eglDestroySurface(display->egl_display, egl_surface);
+    if(egl_window)  wl_egl_window_destroy(egl_window);
+
+    // cleanup Wayland
+    if(xshell_surface)  xdg_surface_destroy(xshell_surface);
+    if(xshell_toplevel) xdg_toplevel_destroy(xshell_toplevel);
+
+    if(wsurface)        wl_surface_destroy(wsurface);
+}
+
+void WaylandWindow::MakeCurrent() {
+    eglMakeCurrent(display->egl_display, egl_surface, egl_surface, display->egl_context);
+}
+
+void WaylandWindow::RemoveCurrent() {
+    eglMakeCurrent(display->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+}
+
+void WaylandWindow::ShowFullscreen(const TrueFalseToggle on_off) {
+    switch (on_off) {
+    case TrueFalseToggle::False:
+        decoration->create();
+        xdg_toplevel_unset_fullscreen(xshell_toplevel);
+        break;
+    case TrueFalseToggle::True:
+        decoration->destroy();
+        xdg_toplevel_set_fullscreen(xshell_toplevel, nullptr);
+        break;
+    case TrueFalseToggle::Toggle:
+        ShowFullscreen(TrueFalseToggle(!is_fullscreen));
+        break;
+    }
+
+    wl_display_sync(display->wdisplay);
+}
+
+void WaylandWindow::Move(const int /*x*/, const int /*y*/) { }
+
+void WaylandWindow::Resize(const unsigned int /*w*/, const unsigned int /*h*/) { }
+
+void WaylandWindow::ProcessEvents() { }
+
+void WaylandWindow::SwapBuffers() {
+    eglSwapBuffers(display->egl_display, egl_surface);
+
+    // draw all decoration elements
+    decoration->draw();
+
+    MakeCurrent();
+
+    wl_display_dispatch(display->wdisplay);
+}
+
+
+std::unique_ptr<WindowInterface> CreateWaylandWindowAndBind(const std::string window_title, const int w, const int h, const std::string /*display_name*/, const bool /*double_buffered*/, const int /*sample_buffers*/, const int /*samples*/) {
+
+    try{
+        return std::make_unique<WaylandWindow>(w, h, window_title, std::make_shared<WaylandDisplay>());
+    }
+    catch(const std::runtime_error&) {
+        // return null pointer for fallback to X11
+        return nullptr;
+    }
+}
+
+} // namespace wayland
+
+PANGOLIN_REGISTER_FACTORY(WaylandWindow)
+{
+  struct WaylandWindowFactory : public TypedFactoryInterface<WindowInterface> {
+    std::map<std::string,Precedence> Schemes() const override
+    {
+      return {{"wayland",10}, {"linux",9}, {"default",90}};
+    }
+
+    const char* Description() const override
+    {
+      return "Use X11 native window";
+    }
+
+    ParamSet Params() const override
+    {
+      return {{
+          {"window_title","window","Title of application Window"},
+          {"w","640","Requested window width"},
+          {"h","480","Requested window height"},
+          {"display_name","","The display name to open the window on"},
+          {"double_buffered","true","Whether the window should be double buffered"},
+          {"sample_buffers","1",""},
+          {"samples","1",""},
+      }};
+    }
+
+    std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+
+      const std::string window_title = uri.Get<std::string>("window_title", "window");
+      const int w = uri.Get<int>("w", 640);
+      const int h = uri.Get<int>("h", 480);
+      const std::string display_name = uri.Get<std::string>("display_name", "");
+      const bool double_buffered = uri.Get<bool>("double_buffered", true);
+      const int sample_buffers = uri.Get<int>("sample_buffers", 1);
+      const int samples = uri.Get<int>("samples", 1);
+      return std::unique_ptr<WindowInterface>(wayland::CreateWaylandWindowAndBind(window_title, w, h, display_name, double_buffered, sample_buffers, samples));
+    }
+
+    virtual ~WaylandWindowFactory() { }
+  };
+
+    return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<WaylandWindowFactory>());
+}
+
+} // namespace pangolin

third-party/DPVO/Pangolin/components/pango_windowing/src/display_win.cpp

@@ -0,0 +1,631 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2018 Steven Lovegrove, Andrey Mnatsakanov
+ *
+ * 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/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/windowing/WinWindow.h>
+#include <memory>
+
+#define CheckWGLDieOnError() pangolin::_CheckWLDieOnError( __FILE__, __LINE__ );
+namespace pangolin {
+inline void _CheckWLDieOnError( const char *sFile, const int nLine )
+{
+    DWORD errorCode = GetLastError();
+    if(errorCode!=0) {
+        LPVOID lpMsgBuf;
+        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+            NULL, errorCode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),(LPTSTR) &lpMsgBuf, 0, NULL);
+        // MessageBox( NULL, (LPCTSTR)lpMsgBuf, ("Error "+std::to_string(errorCode)).c_str(), MB_OK | MB_ICONINFORMATION );
+        pango_print_error("Error %i: %ws", errorCode, (WCHAR *)lpMsgBuf);
+        pango_print_error("In: %s, line %d\n", sFile, nLine);
+        // exit(EXIT_FAILURE);
+    }
+}
+}
+
+namespace pangolin
+{
+
+const char *className = "Pangolin";
+
+////////////////////////////////////////////////////////////////////////
+// Utils
+////////////////////////////////////////////////////////////////////////
+
+unsigned char GetPangoKey(WPARAM wParam, LPARAM lParam)
+{
+    switch (wParam)
+    {
+    case VK_F1: return PANGO_SPECIAL + PANGO_KEY_F1;
+    case VK_F2: return PANGO_SPECIAL + PANGO_KEY_F2;
+    case VK_F3: return PANGO_SPECIAL + PANGO_KEY_F3;
+    case VK_F4: return PANGO_SPECIAL + PANGO_KEY_F4;
+    case VK_F5: return PANGO_SPECIAL + PANGO_KEY_F5;
+    case VK_F6: return PANGO_SPECIAL + PANGO_KEY_F6;
+    case VK_F7: return PANGO_SPECIAL + PANGO_KEY_F7;
+    case VK_F8: return PANGO_SPECIAL + PANGO_KEY_F8;
+    case VK_F9: return PANGO_SPECIAL + PANGO_KEY_F9;
+    case VK_F10: return PANGO_SPECIAL + PANGO_KEY_F10;
+    case VK_F11: return PANGO_SPECIAL + PANGO_KEY_F11;
+    case VK_F12: return PANGO_SPECIAL + PANGO_KEY_F12;
+    case VK_LEFT: return PANGO_SPECIAL + PANGO_KEY_LEFT;
+    case VK_UP: return PANGO_SPECIAL + PANGO_KEY_UP;
+    case VK_RIGHT: return PANGO_SPECIAL + PANGO_KEY_RIGHT;
+    case VK_DOWN: return PANGO_SPECIAL + PANGO_KEY_DOWN;
+    case VK_HOME: return PANGO_SPECIAL + PANGO_KEY_HOME;
+    case VK_END: return PANGO_SPECIAL + PANGO_KEY_END;
+    case VK_INSERT: return PANGO_SPECIAL + PANGO_KEY_INSERT;
+    case VK_DELETE: return 127;
+    default:
+        const int lBufferSize = 2;
+        WCHAR lBuffer[lBufferSize];
+
+        BYTE State[256];
+        GetKeyboardState(State);
+
+        const UINT scanCode = (lParam >> 8) & 0xFFFFFF00;
+        if( ToUnicode((UINT)wParam, scanCode, State, lBuffer, lBufferSize, 0) >=1 ) {
+            return (unsigned char)lBuffer[0];
+        }
+    }
+    return 0;
+}
+
+KeyModifierBitmask GetMouseModifierKey(WPARAM wParam)
+{
+    KeyModifierBitmask mask;
+    if (wParam & MK_SHIFT) mask |= KeyModifierShift;
+    if (wParam & MK_CONTROL) mask |= KeyModifierCtrl;
+    if (HIBYTE(GetKeyState(VK_MENU))) mask |= KeyModifierCmd;
+    return mask;
+}
+
+////////////////////////////////////////////////////////////////////////
+// WinWindow Implementation
+////////////////////////////////////////////////////////////////////////
+
+void WinWindow::SetupPixelFormat(HDC hDC)
+{
+    PIXELFORMATDESCRIPTOR pfd = {
+        sizeof(PIXELFORMATDESCRIPTOR),  /* size */
+        1,                              /* version */
+        PFD_SUPPORT_OPENGL |
+        PFD_DRAW_TO_WINDOW |
+        PFD_DOUBLEBUFFER,               /* support double-buffering */
+        PFD_TYPE_RGBA,                  /* color type */
+        24,                             /* prefered color depth */
+        0, 0, 0, 0, 0, 0,               /* color bits (ignored) */
+        8,                              /* alpha bits */
+        0,                              /* alpha shift (ignored) */
+        0,                              /* no accumulation buffer */
+        0, 0, 0, 0,                     /* accum bits (ignored) */
+        32,                             /* depth buffer */
+        0,                              /* no stencil buffer */
+        0,                              /* no auxiliary buffers */
+        PFD_MAIN_PLANE,                 /* main layer */
+        0,                              /* reserved */
+        0, 0, 0,                        /* no layer, visible, damage masks */
+    };
+    int pixelFormat;
+
+    pixelFormat = ChoosePixelFormat(hDC, &pfd);
+    if (pixelFormat == 0) {
+        MessageBoxA(WindowFromDC(hDC), "ChoosePixelFormat failed.", "Error", MB_ICONERROR | MB_OK);
+        CheckWGLDieOnError();
+        exit(1);
+    }
+
+    if (SetPixelFormat(hDC, pixelFormat, &pfd) != TRUE) {
+        MessageBoxA(WindowFromDC(hDC), "SetPixelFormat failed.", "Error", MB_ICONERROR | MB_OK);
+        CheckWGLDieOnError();
+        exit(1);
+    }
+}
+
+void WinWindow::SetupPalette(HDC hDC)
+{
+    int pixelFormat = GetPixelFormat(hDC);
+    if(!pixelFormat) {
+        std::cerr << "GetPixelFormat() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    PIXELFORMATDESCRIPTOR pfd;
+    LOGPALETTE* pPal;
+    int paletteSize;
+
+    if(!DescribePixelFormat(hDC, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd)) {
+        std::cerr << "DescribePixelFormat() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    if (pfd.dwFlags & PFD_NEED_PALETTE) {
+        paletteSize = 1 << pfd.cColorBits;
+    }
+    else {
+        return;
+    }
+
+    pPal = (LOGPALETTE*) malloc(sizeof(LOGPALETTE) + paletteSize * sizeof(PALETTEENTRY));
+    pPal->palVersion = 0x300;
+    pPal->palNumEntries = paletteSize;
+
+    /* build a simple RGB color palette */
+    {
+        int redMask = (1 << pfd.cRedBits) - 1;
+        int greenMask = (1 << pfd.cGreenBits) - 1;
+        int blueMask = (1 << pfd.cBlueBits) - 1;
+        int i;
+
+        for (i = 0; i<paletteSize; ++i) {
+            pPal->palPalEntry[i].peRed =
+                (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
+            pPal->palPalEntry[i].peGreen =
+                (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
+            pPal->palPalEntry[i].peBlue =
+                (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
+            pPal->palPalEntry[i].peFlags = 0;
+        }
+    }
+
+    hPalette = CreatePalette(pPal);
+    free(pPal);
+
+    if (hPalette) {
+        SelectPalette(hDC, hPalette, FALSE);
+        RealizePalette(hDC);
+    }
+    else {
+        std::cerr << "CreatePalette() failed" << std::endl;
+    }
+}
+
+WinWindow::WinWindow(
+    const std::string& window_title, int width, int height
+) : hWnd(0), bIsFullscreen(false)
+{
+    const HMODULE hCurrentInst = GetModuleHandleA(nullptr);
+    if(hCurrentInst==NULL) {
+        std::cerr << "GetModuleHandle() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    RegisterThisClass(hCurrentInst);
+
+    HWND thishwnd = CreateWindowA(
+        className, window_title.c_str(),
+        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+        0, 0, width, height,
+        NULL, NULL, hCurrentInst, this);
+    if(thishwnd==NULL) {
+        std::cerr << "CreateWindow() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    if( thishwnd != hWnd ) {
+        throw std::runtime_error("Pangolin Window Creation Failed.");
+    }
+
+    // Display Window
+    ShowWindow(hWnd, SW_SHOW);
+}
+
+WinWindow::~WinWindow()
+{
+    if(IsWindow(hWnd) && !DestroyWindow(hWnd)) {
+        std::cerr << "DestroyWindow() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+void WinWindow::RegisterThisClass(HMODULE hCurrentInst)
+{
+    WNDCLASSA wndClass;
+    wndClass.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
+    wndClass.lpfnWndProc = WinWindow::WndProc;
+    wndClass.cbClsExtra = 0;
+    wndClass.cbWndExtra = 0;
+    wndClass.hInstance = hCurrentInst;
+    wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+    wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
+    wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
+    wndClass.lpszMenuName = NULL;
+    wndClass.lpszClassName = className;
+    if(!RegisterClassA(&wndClass)) {
+        std::cerr << "RegisterClass() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+LRESULT APIENTRY
+WinWindow::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    WinWindow* self = 0;
+
+    if (uMsg == WM_NCCREATE) {
+        auto lpcs = reinterpret_cast<LPCREATESTRUCTA>(lParam);
+        self = reinterpret_cast<WinWindow*>(lpcs->lpCreateParams);
+        if(self) {
+            self->hWnd = hwnd;
+            SetWindowLongPtrA(hwnd, GWLP_USERDATA, reinterpret_cast<LPARAM>(self));
+        }
+    } else {
+        self = reinterpret_cast<WinWindow*>(GetWindowLongPtrA(hwnd, GWLP_USERDATA));
+    }
+
+    if (self) {
+        return self->HandleWinMessages(uMsg, wParam, lParam);
+    } else {
+        return DefWindowProcA(hwnd, uMsg, wParam, lParam);
+    }
+}
+
+LRESULT WinWindow::HandleWinMessages(UINT message, WPARAM wParam, LPARAM lParam)
+{
+    switch (message) {
+    case WM_CREATE:
+        /* initialize OpenGL rendering */
+        hDC = GetDC(hWnd);
+        if(hDC==NULL) {
+            std::cerr << "WM_CREATE GetDC() failed" << std::endl;
+        }
+        SetupPixelFormat(hDC);
+        SetupPalette(hDC);
+        hGLRC = wglCreateContext(hDC);
+        if(!hGLRC) {
+            std::cerr << "WM_CREATE wglCreateContext() failed" << std::endl;
+            CheckWGLDieOnError();
+        }
+        if(!wglMakeCurrent(hDC, hGLRC)) {
+            std::cerr << "WM_CREATE wglMakeCurrent() failed" << std::endl;
+            CheckWGLDieOnError();
+        }
+        return 0;
+    case WM_CLOSE:
+    case WM_QUIT:
+        if(!DestroyWindow(hWnd)) {
+            std::cerr << "DestroyWindow() failed" << std::endl;
+            CheckWGLDieOnError();
+        }
+        return 0;
+    case WM_DESTROY:
+        /* finish OpenGL rendering */
+        if (hGLRC) {
+            if(!wglMakeCurrent(NULL, NULL)) {
+                std::cerr << "WM_DESTROY wglMakeCurrent() failed" << std::endl;
+                CheckWGLDieOnError();
+            }
+            if(!wglDeleteContext(hGLRC)) {
+                std::cerr << "WM_DESTROY wglDeleteContext() failed" << std::endl;
+                CheckWGLDieOnError();
+            }
+        }
+        if (hPalette) {
+            DeleteObject(hPalette);
+        }
+        ReleaseDC(hWnd, hDC);
+        PostQuitMessage(0);
+        return 0;
+    case WM_SIZE:
+        ResizeSignal(WindowResizeEvent({(int)LOWORD(lParam), (int)HIWORD(lParam)}));
+        return 0;
+    case WM_PALETTECHANGED:
+        /* realize palette if this is *not* the current window */
+        if (hGLRC && hPalette && (HWND)wParam != hWnd) {
+            if(!UnrealizeObject(hPalette)) {
+                std::cerr << "WM_PALETTECHANGED UnrealizeObject() failed" << std::endl;
+            }
+            if(!SelectPalette(hDC, hPalette, FALSE)) {
+                std::cerr << "WM_PALETTECHANGED SelectPalette() failed" << std::endl;
+            }
+            if(RealizePalette(hDC)==GDI_ERROR) {
+                std::cerr << "WM_PALETTECHANGED RealizePalette() failed" << std::endl;
+            }
+            //redraw();
+            break;
+        }
+        break;
+    case WM_QUERYNEWPALETTE:
+        /* realize palette if this is the current window */
+        if (hGLRC && hPalette) {
+            if(!UnrealizeObject(hPalette)) {
+                std::cerr << "WM_QUERYNEWPALETTE UnrealizeObject() failed" << std::endl;
+            }
+            if(!SelectPalette(hDC, hPalette, FALSE)) {
+                std::cerr << "WM_QUERYNEWPALETTE SelectPalette() failed" << std::endl;
+            }
+            if(RealizePalette(hDC)==GDI_ERROR) {
+                std::cerr << "WM_QUERYNEWPALETTE RealizePalette() failed" << std::endl;
+            }
+            return TRUE;
+        }
+        break;
+    case WM_PAINT:
+        break;
+    case WM_KEYDOWN:
+    case WM_KEYUP:
+    {
+        unsigned char key = GetPangoKey(wParam, lParam);
+        if(key > 0) {
+            KeyboardSignal(KeyboardEvent({
+                afLastMousePos[0], afLastMousePos[1],
+                KeyModifierBitmask(),
+                (unsigned char)key, message == WM_KEYDOWN
+            }));
+        }
+        return 0;
+    }
+    case WM_LBUTTONDOWN:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 0, true
+        }));
+        return 0;
+    case WM_MBUTTONDOWN:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 1, true
+        }));
+        return 0;
+    case WM_RBUTTONDOWN:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 2, true
+        }));
+        return 0;
+    case WM_LBUTTONUP:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 0, false
+        }));
+        return 0;
+    case WM_MBUTTONUP:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 1, false
+        }));
+        return 0;
+    case WM_RBUTTONUP:
+        MouseSignal(MouseEvent({
+            (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+            GetMouseModifierKey(wParam), 2, false
+        }));
+        return 0;
+    case WM_MOUSEMOVE:
+        if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON) ) {
+            MouseMotionSignal(MouseMotionEvent({
+                (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+                GetMouseModifierKey(wParam),
+            }));
+        } else{
+            PassiveMouseMotionSignal(MouseMotionEvent({
+                (float)GET_X_LPARAM(lParam), (float)GET_Y_LPARAM(lParam),
+                GetMouseModifierKey(wParam),
+            }));
+        }
+        afLastMousePos[0] = (float)GET_X_LPARAM(lParam);
+        afLastMousePos[1] = (float)GET_Y_LPARAM(lParam); 
+        return 0;
+    case WM_MOUSEWHEEL:
+        SpecialInputSignal(SpecialInputEvent({
+            afLastMousePos[0], afLastMousePos[1],
+            GetMouseModifierKey(wParam), InputSpecialScroll,
+            {0.0f, GET_WHEEL_DELTA_WPARAM(wParam) / 5.0f, 0.0f, 0.0f }
+        }));
+        return 0;
+    case WM_MOUSEHWHEEL:
+        SpecialInputSignal(SpecialInputEvent({
+            afLastMousePos[0], afLastMousePos[1],
+            GetMouseModifierKey(wParam), InputSpecialScroll,
+            {GET_WHEEL_DELTA_WPARAM(wParam) / 5.0f, 0.0f, 0.0f, 0.0f }
+        }));
+        return 0;
+    default:
+        break;
+    }
+    return DefWindowProcA(hWnd, message, wParam, lParam);
+}
+
+void WinWindow::StartFullScreen() {
+    LONG dwExStyle = GetWindowLongA(hWnd, GWL_EXSTYLE)
+        & ~(WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE | WS_EX_STATICEDGE);
+    if(dwExStyle==0) {
+        std::cerr << "GetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    LONG dwStyle = GetWindowLongA(hWnd, GWL_STYLE)
+        & ~(WS_CAPTION | WS_THICKFRAME | WS_MINIMIZE | WS_MAXIMIZE | WS_SYSMENU);
+    if(dwStyle==0) {
+        std::cerr << "GetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    if(!SetWindowLongA(hWnd, GWL_EXSTYLE, dwExStyle)) {
+        std::cerr << "SetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    if(!SetWindowLongA(hWnd, GWL_STYLE, dwStyle)) {
+        std::cerr << "SetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    // Save windowed size so that we can un-fullscreen to
+    // to this dimension
+    GetWindowRect(hWnd, &cWindowedRect);
+    ShowWindow(hWnd, SW_SHOWMAXIMIZED);
+}
+
+void WinWindow::StopFullScreen() {
+    ChangeDisplaySettings(NULL, 0);
+    ShowCursor(TRUE);
+
+    LONG dwExStyle = GetWindowLongA(hWnd, GWL_EXSTYLE) | WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
+    LONG dwStyle = GetWindowLongA(hWnd, GWL_STYLE) | WS_OVERLAPPEDWINDOW;
+
+    if(dwExStyle==0) {
+        std::cerr << "GetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    if(dwStyle==0) {
+        std::cerr << "GetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    if(!SetWindowLongA(hWnd, GWL_EXSTYLE, dwExStyle)) {
+        std::cerr << "SetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    if(!SetWindowLongA(hWnd, GWL_STYLE, dwStyle)) {
+        std::cerr << "SetWindowLongA() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    // Restore previous size
+    Resize(cWindowedRect.right-cWindowedRect.left, cWindowedRect.bottom-cWindowedRect.top);
+    Move(cWindowedRect.left, cWindowedRect.top);
+}
+
+void WinWindow::ShowFullscreen(const TrueFalseToggle on_off)
+{
+    const bool target = to_bool(on_off, bIsFullscreen);
+    if(target != bIsFullscreen) {
+        if(target) {
+            StartFullScreen();
+        }else{
+            StopFullScreen();
+        }
+    }
+    bIsFullscreen = target;
+}
+
+void WinWindow::Move(int x, int y)
+{
+    if( !SetWindowPos(hWnd, 0, x, y, 0, 0, SWP_NOSIZE) ) {
+        std::cerr << "WinWindow::Move failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+void WinWindow::Resize(unsigned int w, unsigned int h)
+{
+    if( !SetWindowPos(hWnd, 0, 0, 0, w, h, SWP_NOMOVE) ) {
+        std::cerr << "WinWindow::Resize failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+void WinWindow::MakeCurrent()
+{
+    if(wglMakeCurrent(hDC, hGLRC)==FALSE) {
+        std::cerr << "wglMakeCurrent() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+
+    RECT rect;
+    if(!GetWindowRect(hWnd, &rect)) {
+        std::cerr << "GetWindowRect() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+    Resize(rect.right - rect.left, rect.bottom - rect.top);
+}
+
+void WinWindow::RemoveCurrent()
+{
+    if(wglMakeCurrent(NULL, NULL)==0) {
+        std::cerr << "wglMakeCurrent() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+void WinWindow::SwapBuffers()
+{
+    if(!::SwapBuffers(hDC)) {
+        std::cerr << "SwapBuffers() failed" << std::endl;
+        CheckWGLDieOnError();
+    }
+}
+
+void WinWindow::ProcessEvents()
+{
+    static bool needs_init = true;
+    if(needs_init) {
+        RECT cRect;
+        GetClientRect(hWnd, &cRect);
+        ResizeSignal(WindowResizeEvent({cRect.right, cRect.bottom}));
+        needs_init = false;
+    }
+
+    MSG msg;
+    while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
+        if (msg.message == WM_QUIT) {
+            CloseSignal();
+            break;
+        }
+        TranslateMessage(&msg);
+        DispatchMessageA(&msg);
+    }
+}
+
+std::unique_ptr<WindowInterface> CreateWinWindowAndBind(std::string window_title, int w, int h)
+{
+    WinWindow* win = new WinWindow(window_title, w, h);
+
+    return std::unique_ptr<WindowInterface>(win);
+}
+
+PANGOLIN_REGISTER_FACTORY(WinWindow)
+{
+  struct WinWindowFactory : public TypedFactoryInterface<WindowInterface> {
+      std::map<std::string,Precedence> Schemes() const override
+      {
+          return {{"winapi",10}, {"default",100}};
+      }
+      const char* Description() const override
+      {
+          return "Use Windows native window";
+      }
+      ParamSet Params() const override
+      {
+          return {{
+              {"window_title","window","Title of application Window"},
+              {"w","640","Requested window width"},
+              {"h","480","Requested window height"}
+          }};
+      }
+    std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+
+      const std::string window_title = uri.Get<std::string>("window_title", "window");
+      const int w = uri.Get<int>("w", 640);
+      const int h = uri.Get<int>("h", 480);
+      return std::unique_ptr<WindowInterface>(CreateWinWindowAndBind(window_title, w, h));
+    }
+  };
+
+  return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<WinWindowFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_windowing/src/display_x11.cpp

@@ -0,0 +1,548 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2018 Steven Lovegrove, Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+
+// Code based on public domain sample at
+// https://www.opengl.org/wiki/Tutorial:_OpenGL_3.0_Context_Creation_%28GLX%29
+
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/windowing/X11Window.h>
+
+#include <mutex>
+#include <stdexcept>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <GL/glx.h>
+
+namespace pangolin
+{
+
+std::mutex window_mutex;
+std::weak_ptr<X11GlContext> global_gl_context;
+
+const long EVENT_MASKS = ButtonPressMask|ButtonReleaseMask|StructureNotifyMask|ButtonMotionMask|PointerMotionMask|KeyPressMask|KeyReleaseMask|FocusChangeMask;
+
+#define GLX_CONTEXT_MAJOR_VERSION_ARB       0x2091
+#define GLX_CONTEXT_MINOR_VERSION_ARB       0x2092
+typedef GLXContext (*glXCreateContextAttribsARBProc)(::Display*, ::GLXFBConfig, ::GLXContext, Bool, const int*);
+
+// Adapted from: http://www.opengl.org/resources/features/OGLextensions/
+bool isExtensionSupported(const char *extList, const char *extension)
+{
+    /* Extension names should not have spaces. */
+    const char* where = strchr(extension, ' ');
+    if (where || *extension == '\0') {
+        return false;
+    }
+
+    for(const char* start=extList;;) {
+        where = strstr(start, extension);
+        if (!where) {
+            break;
+        }
+
+        const char *terminator = where + strlen(extension);
+
+        if ( where == start || *(where - 1) == ' ' ) {
+            if ( *terminator == ' ' || *terminator == '\0' ) {
+                return true;
+            }
+        }
+
+        start = terminator;
+    }
+
+    return false;
+}
+
+::GLXFBConfig ChooseFrameBuffer(
+    ::Display *display, bool glx_doublebuffer,
+    int glx_sample_buffers, int glx_samples
+) {
+    // Desired attributes
+    int visual_attribs[] =
+    {
+        GLX_X_RENDERABLE    , True,
+        GLX_DRAWABLE_TYPE   , GLX_WINDOW_BIT,
+        GLX_RENDER_TYPE     , GLX_RGBA_BIT,
+        GLX_X_VISUAL_TYPE   , GLX_TRUE_COLOR,
+        GLX_RED_SIZE        , 8,
+        GLX_GREEN_SIZE      , 8,
+        GLX_BLUE_SIZE       , 8,
+        GLX_ALPHA_SIZE      , 8,
+        GLX_DEPTH_SIZE      , 24,
+        GLX_STENCIL_SIZE    , 8,
+        GLX_DOUBLEBUFFER    , glx_doublebuffer ? True : False,
+        None
+    };
+
+    int fbcount;
+    GLXFBConfig* fbc = glXChooseFBConfig(display, DefaultScreen(display), visual_attribs, &fbcount);
+    if (!fbc) {
+        throw std::runtime_error("Pangolin X11: Unable to retrieve framebuffer options");
+    }
+
+    int best_fbc = -1;
+    int worst_fbc = -1;
+    int best_num_samp = -1;
+    int worst_num_samp = 999;
+
+    // Enumerate framebuffer options, storing the best and worst that match our attribs
+    for (int i=0; i<fbcount; ++i)
+    {
+        XVisualInfo *vi = glXGetVisualFromFBConfig( display, fbc[i] );
+        if ( vi )
+        {
+            int samp_buf, samples;
+            glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf );
+            glXGetFBConfigAttrib( display, fbc[i], GLX_SAMPLES       , &samples  );
+
+            // Filter for the best available.
+            if ( samples > best_num_samp ) {
+                best_fbc = i;
+                best_num_samp = samples;
+            }
+
+            // Filter lowest settings which match minimum user requirement.
+            if ( samp_buf >= glx_sample_buffers && samples >= glx_samples && samples < worst_num_samp ) {
+                worst_fbc = i;
+                worst_num_samp = samples;
+            }
+        }
+        XFree( vi );
+    }
+
+    // Select the minimum suitable option. The 'best' is often too slow.
+    int chosen_fbc_id = worst_fbc;
+
+    // If minimum requested isn't available, return the best that is.
+    if(chosen_fbc_id < 0) {
+        pango_print_warn("Framebuffer with requested attributes not available. Using available framebuffer. You may see visual artifacts.");
+        chosen_fbc_id = best_fbc;
+    }
+
+    ::GLXFBConfig chosenFbc = fbc[ chosen_fbc_id ];
+    XFree( fbc );
+    return chosenFbc;
+}
+
+static bool ctxErrorOccurred = false;
+static int ctxErrorHandler( ::Display * /*dpy*/, ::XErrorEvent * ev )
+{
+    const int buffer_size = 10240;
+    char buffer[buffer_size];
+    XGetErrorText(ev->display, ev->error_code, buffer, buffer_size );
+    pango_print_error("X11 Error: %s\n", buffer);
+    ctxErrorOccurred = true;
+    return 0;
+}
+
+GLXContext CreateGlContext(::Display *display, ::GLXFBConfig chosenFbc, GLXContext share_context = 0)
+{
+    int glx_major, glx_minor;
+    if ( !glXQueryVersion( display, &glx_major, &glx_minor ) ||
+         ( ( glx_major == 1 ) && ( glx_minor < 3 ) ) || ( glx_major < 1 ) )
+    {
+        throw std::runtime_error("Pangolin X11: Invalid GLX version. Require GLX >= 1.3");
+    }
+
+    GLXContext new_ctx;
+
+    // Get the default screen's GLX extension list
+    const char *glxExts = glXQueryExtensionsString( display, DefaultScreen( display ) );
+
+    glXCreateContextAttribsARBProc glXCreateContextAttribsARB =
+            (glXCreateContextAttribsARBProc) glXGetProcAddressARB(
+                (const GLubyte *) "glXCreateContextAttribsARB"
+            );
+
+    // Install an X error handler so the application won't exit if GL 3.0
+    // context allocation fails. Handler is global and shared across all threads.
+    ctxErrorOccurred = false;
+    int (*oldHandler)(::Display*, ::XErrorEvent*) = XSetErrorHandler(&ctxErrorHandler);
+
+    if ( isExtensionSupported( glxExts, "GLX_ARB_create_context" ) && glXCreateContextAttribsARB )
+    {
+        int context_attribs[] = {
+            GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
+            GLX_CONTEXT_MINOR_VERSION_ARB, 0,
+            //GLX_CONTEXT_FLAGS_ARB        , GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+            None
+        };
+
+        new_ctx = glXCreateContextAttribsARB( display, chosenFbc, share_context, True, context_attribs );
+
+        // Sync to ensure any errors generated are processed.
+        XSync( display, False );
+        if ( ctxErrorOccurred || !new_ctx ) {
+            ctxErrorOccurred = false;
+            // Fall back to old-style 2.x context. Implementations will return the newest
+            // context version compatible with OpenGL versions less than version 3.0.
+            context_attribs[1] = 1;  // GLX_CONTEXT_MAJOR_VERSION_ARB = 1
+            context_attribs[3] = 0;  // GLX_CONTEXT_MINOR_VERSION_ARB = 0
+            new_ctx = glXCreateContextAttribsARB( display, chosenFbc, share_context, True, context_attribs );
+        }
+    } else {
+        // Fallback to GLX 1.3 Context
+        new_ctx = glXCreateNewContext( display, chosenFbc, GLX_RGBA_TYPE, share_context, True );
+    }
+
+    // Sync to ensure any errors generated are processed.
+    XSync( display, False );
+
+    // Restore the original error handler
+    XSetErrorHandler( oldHandler );
+
+    if ( ctxErrorOccurred || !new_ctx ) {
+        throw std::runtime_error("Pangolin X11: Failed to create an OpenGL context");
+    }
+
+    // Verifying that context is a direct context
+    if ( ! glXIsDirect ( display, new_ctx ) ) {
+        pango_print_warn("Pangolin X11: Indirect GLX rendering context obtained\n");
+    }
+
+    return new_ctx;
+}
+
+X11GlContext::X11GlContext(std::shared_ptr<X11Display>& d, ::GLXFBConfig chosenFbc, std::shared_ptr<X11GlContext> shared_context)
+    : display(d), shared_context(shared_context)
+{
+    // prevent chained sharing
+    while(shared_context && shared_context->shared_context) {
+        shared_context = shared_context->shared_context;
+    }
+
+    // Contexts can't be shared across different displays.
+    if(shared_context && shared_context->display != d) {
+        shared_context.reset();
+    }
+
+    glcontext = CreateGlContext(display->display, chosenFbc, shared_context ? shared_context->glcontext : 0);
+}
+
+X11GlContext::~X11GlContext()
+{
+    glXDestroyContext( display->display, glcontext );
+}
+
+X11Window::X11Window(
+    const std::string& title, int width, int height,
+    std::shared_ptr<X11Display>& display, ::GLXFBConfig chosenFbc
+) : display(display), glcontext(0), win(0), cmap(0)
+{
+    // Get a visual
+    XVisualInfo *vi = glXGetVisualFromFBConfig( display->display, chosenFbc );
+
+    // Create colourmap
+    XSetWindowAttributes swa;
+    swa.background_pixmap = None;
+    swa.border_pixel    = 0;
+    swa.event_mask      = StructureNotifyMask;
+    swa.colormap = cmap = XCreateColormap( display->display,
+                                           RootWindow( display->display, vi->screen ),
+                                           vi->visual, AllocNone );
+
+    // Create window
+    win = XCreateWindow( display->display, RootWindow( display->display, vi->screen ),
+                         0, 0, width, height, 0, vi->depth, InputOutput,
+                         vi->visual,
+                         CWBorderPixel|CWColormap|CWEventMask, &swa );
+
+    XFree( vi );
+
+    if ( !win ) {
+        throw std::runtime_error("Pangolin X11: Failed to create window." );
+    }
+
+    // set name in window switching (alt-tab) list
+    {
+      XClassHint class_hint;
+      class_hint.res_class = const_cast<char*>(title.c_str());
+      class_hint.res_name = const_cast<char*>("");
+      XSetClassHint( display->display, win, &class_hint );
+    }
+
+    // set window title
+    XStoreName( display->display, win, title.c_str() );
+    XMapWindow( display->display, win );
+
+    // Request to be notified of these events
+    XSelectInput(display->display, win, EVENT_MASKS );
+
+    delete_message = XInternAtom(display->display, "WM_DELETE_WINDOW", False);
+    XSetWMProtocols(display->display, win, &delete_message, 1);
+}
+
+X11Window::~X11Window()
+{
+    glXMakeCurrent( display->display, 0, 0 );
+    XDestroyWindow( display->display, win );
+    XFreeColormap( display->display, cmap );
+}
+
+void X11Window::MakeCurrent(GLXContext ctx)
+{
+    glXMakeCurrent( display->display, win, ctx );
+}
+
+void X11Window::MakeCurrent()
+{
+    MakeCurrent(glcontext ? glcontext->glcontext : global_gl_context.lock()->glcontext);
+}
+
+void X11Window::RemoveCurrent()
+{
+    glXMakeCurrent(display->display, 0, nullptr);
+}
+
+void X11Window::ShowFullscreen(const TrueFalseToggle true_false)
+{
+    const Atom _NET_WM_STATE_FULLSCREEN = XInternAtom(display->display, "_NET_WM_STATE_FULLSCREEN", True);
+    const Atom _NET_WM_STATE = XInternAtom(display->display, "_NET_WM_STATE", True);
+    XEvent e;
+    e.xclient.type         = ClientMessage;
+    e.xclient.window       = win;
+    e.xclient.message_type = _NET_WM_STATE;
+    e.xclient.format       = 32;
+    e.xclient.data.l[0]    = (int)true_false;  // Toggle
+    e.xclient.data.l[1]    = _NET_WM_STATE_FULLSCREEN;
+    e.xclient.data.l[2]    = 0;
+    e.xclient.data.l[3]    = 1;
+    e.xclient.data.l[4]    = 0;
+
+    XSendEvent(display->display, DefaultRootWindow(display->display), False, SubstructureRedirectMask | SubstructureNotifyMask, &e);
+//    XMoveResizeWindow(display->display, win, 0, 0, windowed_size[0], windowed_size[1]);
+}
+
+void X11Window::Move(int x, int y)
+{
+    XMoveWindow(display->display, win, x, y);
+}
+
+void X11Window::Resize(unsigned int w, unsigned int h)
+{
+    XResizeWindow(display->display, win, w, h);
+}
+
+KeyModifierBitmask GetEventFlagsFromXState(unsigned int state) {
+  KeyModifierBitmask flags;
+
+  if (state & ShiftMask)
+    flags |= KeyModifierShift;
+  if (state & ControlMask)
+    flags |= KeyModifierCtrl;
+  if (state & Mod1Mask)
+    flags |= KeyModifierAlt;
+  if (state & Mod4Mask)
+    flags |= KeyModifierCmd;
+  if (state & Mod5Mask) // altgr
+    flags |= KeyModifierAlt;
+//  if (state & LockMask) // capslock
+//  if (state & Mod2Mask) // numlock
+//  if (state & Mod3Mask) // mod3
+//  if (state & Button1Mask) // LEFT_MOUSE_BUTTON;
+//  if (state & Button2Mask) // MIDDLE_MOUSE_BUTTON;
+//  if (state & Button3Mask) // RIGHT_MOUSE_BUTTON;
+  return flags;
+}
+
+void X11Window::ProcessEvents()
+{
+    XEvent ev;
+    while(XPending(display->display) > 0)
+    {
+        XNextEvent(display->display, &ev);
+
+
+        switch(ev.type){
+        case ConfigureNotify:
+            ResizeSignal(WindowResizeEvent{ev.xconfigure.width, ev.xconfigure.height});
+            break;
+        case ClientMessage:
+            // We've only registered to receive WM_DELETE_WINDOW, so no further checks needed.
+            CloseSignal();
+            break;
+        case ButtonPress:
+        case ButtonRelease:
+        {
+            const int button = ev.xbutton.button-1;
+            MouseSignal(MouseEvent{
+               (float)ev.xbutton.x, (float)ev.xbutton.y,
+               GetEventFlagsFromXState(ev.xkey.state),
+               button, ev.xbutton.type == ButtonPress
+           });
+           break;
+        }
+        case FocusOut:
+            break;
+        case MotionNotify:
+            if(ev.xmotion.state & (Button1Mask|Button2Mask|Button3Mask) ) {
+                MouseMotionSignal(MouseMotionEvent{
+                    (float)ev.xbutton.x, (float)ev.xbutton.y,
+                    GetEventFlagsFromXState(ev.xkey.state),
+                });
+            }else{
+                PassiveMouseMotionSignal(MouseMotionEvent{
+                    (float)ev.xbutton.x, (float)ev.xbutton.y,
+                    GetEventFlagsFromXState(ev.xkey.state)
+                });
+            }
+            break;
+        case KeyPress:
+        case KeyRelease:
+            int key;
+            char ch;
+            KeySym sym;
+
+            if( XLookupString(&ev.xkey,&ch,1,&sym,0) == 0) {
+                switch (sym) {
+                case XK_F1:        key = PANGO_SPECIAL + PANGO_KEY_F1         ; break;
+                case XK_F2:        key = PANGO_SPECIAL + PANGO_KEY_F2         ; break;
+                case XK_F3:        key = PANGO_SPECIAL + PANGO_KEY_F3         ; break;
+                case XK_F4:        key = PANGO_SPECIAL + PANGO_KEY_F4         ; break;
+                case XK_F5:        key = PANGO_SPECIAL + PANGO_KEY_F5         ; break;
+                case XK_F6:        key = PANGO_SPECIAL + PANGO_KEY_F6         ; break;
+                case XK_F7:        key = PANGO_SPECIAL + PANGO_KEY_F7         ; break;
+                case XK_F8:        key = PANGO_SPECIAL + PANGO_KEY_F8         ; break;
+                case XK_F9:        key = PANGO_SPECIAL + PANGO_KEY_F9         ; break;
+                case XK_F10:       key = PANGO_SPECIAL + PANGO_KEY_F10        ; break;
+                case XK_F11:       key = PANGO_SPECIAL + PANGO_KEY_F11        ; break;
+                case XK_F12:       key = PANGO_SPECIAL + PANGO_KEY_F12        ; break;
+                case XK_Left:      key = PANGO_SPECIAL + PANGO_KEY_LEFT       ; break;
+                case XK_Up:        key = PANGO_SPECIAL + PANGO_KEY_UP         ; break;
+                case XK_Right:     key = PANGO_SPECIAL + PANGO_KEY_RIGHT      ; break;
+                case XK_Down:      key = PANGO_SPECIAL + PANGO_KEY_DOWN       ; break;
+                case XK_Page_Up:   key = PANGO_SPECIAL + PANGO_KEY_PAGE_UP    ; break;
+                case XK_Page_Down: key = PANGO_SPECIAL + PANGO_KEY_PAGE_DOWN  ; break;
+                case XK_Home:      key = PANGO_SPECIAL + PANGO_KEY_HOME       ; break;
+                case XK_End:       key = PANGO_SPECIAL + PANGO_KEY_END        ; break;
+                case XK_Insert:    key = PANGO_SPECIAL + PANGO_KEY_INSERT     ; break;
+                case XK_Shift_L:
+                case XK_Shift_R:
+                case XK_Control_L:
+                case XK_Control_R:
+                case XK_Alt_L:
+                case XK_Alt_R:
+                case XK_Super_L:
+                case XK_Super_R:
+                default:
+                    key = -1;
+                    break;
+                }
+            }else{
+                key = ch;
+            }
+
+            if(key >=0) {
+                KeyboardSignal(KeyboardEvent{
+                    (float)ev.xkey.x, (float)ev.xkey.y,
+                    GetEventFlagsFromXState(ev.xkey.state),
+                    (unsigned char)key, ev.type == KeyPress
+                });
+            }
+
+            break;
+        }
+    }
+}
+
+void X11Window::SwapBuffers() {
+    glXSwapBuffers(display->display, win);
+}
+
+std::unique_ptr<WindowInterface> CreateX11WindowAndBind(const std::string& window_title, const int w, const int h, const std::string& display_name, const bool double_buffered, const int  sample_buffers, const int  samples)
+{
+    std::shared_ptr<X11Display> newdisplay = std::make_shared<X11Display>(display_name.empty() ? NULL : display_name.c_str() );
+    if (!newdisplay) {
+        throw std::runtime_error("Pangolin X11: Failed to open X display");
+    }
+    ::GLXFBConfig newfbc = ChooseFrameBuffer(newdisplay->display, double_buffered, sample_buffers, samples);
+
+    window_mutex.lock();
+    std::shared_ptr<X11GlContext> newglcontext = std::make_shared<X11GlContext>(
+        newdisplay, newfbc, global_gl_context.lock()
+    );
+
+    if(!global_gl_context.lock()) {
+        global_gl_context = newglcontext;
+    }
+    window_mutex.unlock();
+
+    X11Window* win = new X11Window(window_title, w, h, newdisplay, newfbc);
+    win->glcontext = newglcontext;
+
+    return std::unique_ptr<WindowInterface>(win);
+}
+
+PANGOLIN_REGISTER_FACTORY(X11Window)
+{
+  struct X11WindowFactory : public TypedFactoryInterface<WindowInterface> {
+      std::map<std::string,Precedence> Schemes() const override
+      {
+          return {{"x11",10}, {"linux",10}, {"default",100}};
+      }
+      const char* Description() const override
+      {
+          return "Use X11 native window";
+      }
+      ParamSet Params() const override
+      {
+          return {{
+              {"window_title","window","Title of application Window"},
+              {"w","640","Requested window width"},
+              {"h","480","Requested window height"},
+              {"display_name","","The display name to open the window on"},
+              {"double_buffered","true","Whether the window should be double buffered"},
+              {"sample_buffers","1",""},
+              {"samples","1",""},
+          }};
+      }
+
+      std::unique_ptr<WindowInterface> Open(const Uri& uri) override {
+          
+      const std::string window_title = uri.Get<std::string>("window_title", "window");
+      const int w = uri.Get<int>("w", 640);
+      const int h = uri.Get<int>("h", 480);
+      const std::string display_name = uri.Get<std::string>("display_name", "");
+      const bool double_buffered = uri.Get<bool>("double_buffered", true);
+      const int sample_buffers = uri.Get<int>("sample_buffers", 1);
+      const int samples = uri.Get<int>("samples", 1);
+      return std::unique_ptr<WindowInterface>(CreateX11WindowAndBind(window_title, w, h, display_name, double_buffered, sample_buffers, samples));
+    }
+  };
+
+  return FactoryRegistry::I()->RegisterFactory<WindowInterface>(std::make_shared<X11WindowFactory>());
+}
+
+}
+

third-party/DPVO/Pangolin/components/pango_windowing/src/window.cpp

@@ -0,0 +1,14 @@
+#include <pangolin/windowing/window.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/factory/RegisterFactoriesWindowInterface.h>
+
+namespace pangolin
+{
+
+std::unique_ptr<WindowInterface> ConstructWindow(const Uri& uri)
+{
+    RegisterFactoriesWindowInterface();
+    return FactoryRegistry::I()->Construct<WindowInterface>(uri);
+}
+
+}

third-party/DPVO/Pangolin/components/tinyobj/CMakeLists.txt

@@ -0,0 +1,11 @@
+set(COMPONENT tinyobj)
+
+target_sources( ${COMPONENT} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/src/tinyobj.cpp")
+set_property(TARGET ${COMPONENT} PROPERTY CXX_STANDARD 11)
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include"
+  DESTINATION ${CMAKE_INSTALL_PREFIX}
+)

third-party/DPVO/Pangolin/components/tinyobj/include/tinyobj/tiny_obj_loader.h

@@ -0,0 +1,2547 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2012-2018 Syoyo Fujita and many contributors.
+
+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.
+*/
+
+//
+// version 1.3.1 : Make ParseTextureNameAndOption API public
+// version 1.3.0 : Separate warning and error message(breaking API of LoadObj)
+// version 1.2.3 : Added color space extension('-colorspace') to tex opts.
+// version 1.2.2 : Parse multiple group names.
+// version 1.2.1 : Added initial support for line('l') primitive(PR #178)
+// version 1.2.0 : Hardened implementation(#175)
+// version 1.1.1 : Support smoothing groups(#162)
+// version 1.1.0 : Support parsing vertex color(#144)
+// version 1.0.8 : Fix parsing `g` tag just after `usemtl`(#138)
+// version 1.0.7 : Support multiple tex options(#126)
+// version 1.0.6 : Add TINYOBJLOADER_USE_DOUBLE option(#124)
+// version 1.0.5 : Ignore `Tr` when `d` exists in MTL(#43)
+// version 1.0.4 : Support multiple filenames for 'mtllib'(#112)
+// version 1.0.3 : Support parsing texture options(#85)
+// version 1.0.2 : Improve parsing speed by about a factor of 2 for large
+// files(#105)
+// version 1.0.1 : Fixes a shape is lost if obj ends with a 'usemtl'(#104)
+// version 1.0.0 : Change data structure. Change license from BSD to MIT.
+//
+
+//
+// Use this in *one* .cc
+//   #define TINYOBJLOADER_IMPLEMENTATION
+//   #include "tiny_obj_loader.h"
+//
+
+#ifndef TINY_OBJ_LOADER_H_
+#define TINY_OBJ_LOADER_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace tinyobj {
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#if __has_warning("-Wzero-as-null-pointer-constant")
+#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#pragma clang diagnostic ignored "-Wpadded"
+
+#endif
+
+// https://en.wikipedia.org/wiki/Wavefront_.obj_file says ...
+//
+//  -blendu on | off                       # set horizontal texture blending
+//  (default on)
+//  -blendv on | off                       # set vertical texture blending
+//  (default on)
+//  -boost real_value                      # boost mip-map sharpness
+//  -mm base_value gain_value              # modify texture map values (default
+//  0 1)
+//                                         #     base_value = brightness,
+//                                         gain_value = contrast
+//  -o u [v [w]]                           # Origin offset             (default
+//  0 0 0)
+//  -s u [v [w]]                           # Scale                     (default
+//  1 1 1)
+//  -t u [v [w]]                           # Turbulence                (default
+//  0 0 0)
+//  -texres resolution                     # texture resolution to create
+//  -clamp on | off                        # only render texels in the clamped
+//  0-1 range (default off)
+//                                         #   When unclamped, textures are
+//                                         repeated across a surface,
+//                                         #   when clamped, only texels which
+//                                         fall within the 0-1
+//                                         #   range are rendered.
+//  -bm mult_value                         # bump multiplier (for bump maps
+//  only)
+//
+//  -imfchan r | g | b | m | l | z         # specifies which channel of the file
+//  is used to
+//                                         # create a scalar or bump texture.
+//                                         r:red, g:green,
+//                                         # b:blue, m:matte, l:luminance,
+//                                         z:z-depth..
+//                                         # (the default for bump is 'l' and
+//                                         for decal is 'm')
+//  bump -imfchan r bumpmap.tga            # says to use the red channel of
+//  bumpmap.tga as the bumpmap
+//
+// For reflection maps...
+//
+//   -type sphere                           # specifies a sphere for a "refl"
+//   reflection map
+//   -type cube_top    | cube_bottom |      # when using a cube map, the texture
+//   file for each
+//         cube_front  | cube_back   |      # side of the cube is specified
+//         separately
+//         cube_left   | cube_right
+//
+// TinyObjLoader extension.
+//
+//   -colorspace SPACE                      # Color space of the texture. e.g.
+//   'sRGB` or 'linear'
+//
+
+#ifdef TINYOBJLOADER_USE_DOUBLE
+//#pragma message "using double"
+typedef double real_t;
+#else
+//#pragma message "using float"
+typedef float real_t;
+#endif
+
+typedef enum {
+  TEXTURE_TYPE_NONE,  // default
+  TEXTURE_TYPE_SPHERE,
+  TEXTURE_TYPE_CUBE_TOP,
+  TEXTURE_TYPE_CUBE_BOTTOM,
+  TEXTURE_TYPE_CUBE_FRONT,
+  TEXTURE_TYPE_CUBE_BACK,
+  TEXTURE_TYPE_CUBE_LEFT,
+  TEXTURE_TYPE_CUBE_RIGHT
+} texture_type_t;
+
+typedef struct {
+  texture_type_t type;      // -type (default TEXTURE_TYPE_NONE)
+  real_t sharpness;         // -boost (default 1.0?)
+  real_t brightness;        // base_value in -mm option (default 0)
+  real_t contrast;          // gain_value in -mm option (default 1)
+  real_t origin_offset[3];  // -o u [v [w]] (default 0 0 0)
+  real_t scale[3];          // -s u [v [w]] (default 1 1 1)
+  real_t turbulence[3];     // -t u [v [w]] (default 0 0 0)
+  // int   texture_resolution; // -texres resolution (default = ?) TODO
+  bool clamp;    // -clamp (default false)
+  char imfchan;  // -imfchan (the default for bump is 'l' and for decal is 'm')
+  bool blendu;   // -blendu (default on)
+  bool blendv;   // -blendv (default on)
+  real_t bump_multiplier;  // -bm (for bump maps only, default 1.0)
+
+  // extension
+  std::string colorspace;  // Explicitly specify color space of stored value.
+                           // Usually `sRGB` or `linear` (default empty).
+} texture_option_t;
+
+typedef struct {
+  std::string name;
+
+  real_t ambient[3];
+  real_t diffuse[3];
+  real_t specular[3];
+  real_t transmittance[3];
+  real_t emission[3];
+  real_t shininess;
+  real_t ior;       // index of refraction
+  real_t dissolve;  // 1 == opaque; 0 == fully transparent
+  // illumination model (see http://www.fileformat.info/format/material/)
+  int illum;
+
+  int dummy;  // Suppress padding warning.
+
+  std::string ambient_texname;             // map_Ka
+  std::string diffuse_texname;             // map_Kd
+  std::string specular_texname;            // map_Ks
+  std::string specular_highlight_texname;  // map_Ns
+  std::string bump_texname;                // map_bump, map_Bump, bump
+  std::string displacement_texname;        // disp
+  std::string alpha_texname;               // map_d
+  std::string reflection_texname;          // refl
+
+  texture_option_t ambient_texopt;
+  texture_option_t diffuse_texopt;
+  texture_option_t specular_texopt;
+  texture_option_t specular_highlight_texopt;
+  texture_option_t bump_texopt;
+  texture_option_t displacement_texopt;
+  texture_option_t alpha_texopt;
+  texture_option_t reflection_texopt;
+
+  // PBR extension
+  // http://exocortex.com/blog/extending_wavefront_mtl_to_support_pbr
+  real_t roughness;            // [0, 1] default 0
+  real_t metallic;             // [0, 1] default 0
+  real_t sheen;                // [0, 1] default 0
+  real_t clearcoat_thickness;  // [0, 1] default 0
+  real_t clearcoat_roughness;  // [0, 1] default 0
+  real_t anisotropy;           // aniso. [0, 1] default 0
+  real_t anisotropy_rotation;  // anisor. [0, 1] default 0
+  real_t pad0;
+  std::string roughness_texname;  // map_Pr
+  std::string metallic_texname;   // map_Pm
+  std::string sheen_texname;      // map_Ps
+  std::string emissive_texname;   // map_Ke
+  std::string normal_texname;     // norm. For normal mapping.
+
+  texture_option_t roughness_texopt;
+  texture_option_t metallic_texopt;
+  texture_option_t sheen_texopt;
+  texture_option_t emissive_texopt;
+  texture_option_t normal_texopt;
+
+  int pad2;
+
+  std::map<std::string, std::string> unknown_parameter;
+} material_t;
+
+typedef struct {
+  std::string name;
+
+  std::vector<int> intValues;
+  std::vector<real_t> floatValues;
+  std::vector<std::string> stringValues;
+} tag_t;
+
+// Index struct to support different indices for vtx/normal/texcoord.
+// -1 means not used.
+typedef struct {
+  int vertex_index;
+  int normal_index;
+  int texcoord_index;
+} index_t;
+
+typedef struct {
+  std::vector<index_t> indices;
+  std::vector<unsigned char> num_face_vertices;  // The number of vertices per
+                                                 // face. 3 = polygon, 4 = quad,
+                                                 // ... Up to 255.
+  std::vector<int> material_ids;                 // per-face material ID
+  std::vector<unsigned int> smoothing_group_ids;  // per-face smoothing group
+                                                  // ID(0 = off. positive value
+                                                  // = group id)
+  std::vector<tag_t> tags;                        // SubD tag
+} mesh_t;
+
+typedef struct {
+  std::vector<int> indices;  // pairs of indices for lines
+} path_t;
+
+typedef struct {
+  std::string name;
+  mesh_t mesh;
+  path_t path;
+} shape_t;
+
+// Vertex attributes
+typedef struct {
+  std::vector<real_t> vertices;   // 'v'
+  std::vector<real_t> normals;    // 'vn'
+  std::vector<real_t> texcoords;  // 'vt'
+  std::vector<real_t> colors;     // extension: vertex colors
+} attrib_t;
+
+typedef struct callback_t_ {
+  // W is optional and set to 1 if there is no `w` item in `v` line
+  void (*vertex_cb)(void *user_data, real_t x, real_t y, real_t z, real_t w);
+  void (*normal_cb)(void *user_data, real_t x, real_t y, real_t z);
+
+  // y and z are optional and set to 0 if there is no `y` and/or `z` item(s) in
+  // `vt` line.
+  void (*texcoord_cb)(void *user_data, real_t x, real_t y, real_t z);
+
+  // called per 'f' line. num_indices is the number of face indices(e.g. 3 for
+  // triangle, 4 for quad)
+  // 0 will be passed for undefined index in index_t members.
+  void (*index_cb)(void *user_data, index_t *indices, int num_indices);
+  // `name` material name, `material_id` = the array index of material_t[]. -1
+  // if
+  // a material not found in .mtl
+  void (*usemtl_cb)(void *user_data, const char *name, int material_id);
+  // `materials` = parsed material data.
+  void (*mtllib_cb)(void *user_data, const material_t *materials,
+                    int num_materials);
+  // There may be multiple group names
+  void (*group_cb)(void *user_data, const char **names, int num_names);
+  void (*object_cb)(void *user_data, const char *name);
+
+  callback_t_()
+      : vertex_cb(NULL),
+        normal_cb(NULL),
+        texcoord_cb(NULL),
+        index_cb(NULL),
+        usemtl_cb(NULL),
+        mtllib_cb(NULL),
+        group_cb(NULL),
+        object_cb(NULL) {}
+} callback_t;
+
+class MaterialReader {
+ public:
+  MaterialReader() {}
+  virtual ~MaterialReader();
+
+  virtual bool operator()(const std::string &matId,
+                          std::vector<material_t> *materials,
+                          std::map<std::string, int> *matMap, std::string *warn,
+                          std::string *err) = 0;
+};
+
+class MaterialFileReader : public MaterialReader {
+ public:
+  explicit MaterialFileReader(const std::string &mtl_basedir)
+      : m_mtlBaseDir(mtl_basedir) {}
+  virtual ~MaterialFileReader() {}
+  virtual bool operator()(const std::string &matId,
+                          std::vector<material_t> *materials,
+                          std::map<std::string, int> *matMap, std::string *warn,
+                          std::string *err);
+
+ private:
+  std::string m_mtlBaseDir;
+};
+
+class MaterialStreamReader : public MaterialReader {
+ public:
+  explicit MaterialStreamReader(std::istream &inStream)
+      : m_inStream(inStream) {}
+  virtual ~MaterialStreamReader() {}
+  virtual bool operator()(const std::string &matId,
+                          std::vector<material_t> *materials,
+                          std::map<std::string, int> *matMap, std::string *warn,
+                          std::string *err);
+
+ private:
+  std::istream &m_inStream;
+};
+
+/// Loads .obj from a file.
+/// 'attrib', 'shapes' and 'materials' will be filled with parsed shape data
+/// 'shapes' will be filled with parsed shape data
+/// Returns true when loading .obj become success.
+/// Returns warning message into `warn`, and error message into `err`
+/// 'mtl_basedir' is optional, and used for base directory for .mtl file.
+/// In default(`NULL'), .mtl file is searched from an application's working
+/// directory.
+/// 'triangulate' is optional, and used whether triangulate polygon face in .obj
+/// or not.
+/// Option 'default_vcols_fallback' specifies whether vertex colors should
+/// always be defined, even if no colors are given (fallback to white).
+bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
+             std::vector<material_t> *materials, std::string *warn,
+             std::string *err, const char *filename,
+             const char *mtl_basedir = NULL, bool triangulate = true,
+             bool default_vcols_fallback = true);
+
+/// Loads .obj from a file with custom user callback.
+/// .mtl is loaded as usual and parsed material_t data will be passed to
+/// `callback.mtllib_cb`.
+/// Returns true when loading .obj/.mtl become success.
+/// Returns warning message into `warn`, and error message into `err`
+/// See `examples/callback_api/` for how to use this function.
+bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback,
+                         void *user_data = NULL,
+                         MaterialReader *readMatFn = NULL,
+                         std::string *warn = NULL, std::string *err = NULL);
+
+/// Loads object from a std::istream, uses GetMtlIStreamFn to retrieve
+/// std::istream for materials.
+/// Returns true when loading .obj become success.
+/// Returns warning and error message into `err`
+bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
+             std::vector<material_t> *materials, std::string *warn,
+             std::string *err, std::istream *inStream,
+             MaterialReader *readMatFn = NULL, bool triangulate = true,
+             bool default_vcols_fallback = true);
+
+/// Loads materials into std::map
+void LoadMtl(std::map<std::string, int> *material_map,
+             std::vector<material_t> *materials, std::istream *inStream,
+             std::string *warning, std::string *err);
+
+///
+/// Parse texture name and texture option for custom texture parameter through material::unknown_parameter
+///
+/// @param[out] texname Parsed texture name
+/// @param[out] texopt Parsed texopt
+/// @param[in] linebuf Input string
+/// @param[in] is_bump Is this texture bump/normal?
+///
+bool ParseTextureNameAndOption(std::string *texname,
+                               texture_option_t *texopt,
+                               const char *linebuf,
+                               const bool is_bump);
+}  // namespace tinyobj
+
+#endif  // TINY_OBJ_LOADER_H_
+
+#ifdef TINYOBJLOADER_IMPLEMENTATION
+#include <cassert>
+#include <cctype>
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <utility>
+
+#include <fstream>
+#include <sstream>
+
+namespace tinyobj {
+
+MaterialReader::~MaterialReader() {}
+
+struct vertex_index_t {
+  int v_idx, vt_idx, vn_idx;
+  vertex_index_t() : v_idx(-1), vt_idx(-1), vn_idx(-1) {}
+  explicit vertex_index_t(int idx) : v_idx(idx), vt_idx(idx), vn_idx(idx) {}
+  vertex_index_t(int vidx, int vtidx, int vnidx)
+      : v_idx(vidx), vt_idx(vtidx), vn_idx(vnidx) {}
+};
+
+// Internal data structure for face representation
+// index + smoothing group.
+struct face_t {
+  unsigned int
+      smoothing_group_id;  // smoothing group id. 0 = smoothing groupd is off.
+  int pad_;
+  std::vector<vertex_index_t> vertex_indices;  // face vertex indices.
+
+  face_t() : smoothing_group_id(0) {}
+};
+
+struct line_t {
+  int idx0;
+  int idx1;
+};
+
+struct tag_sizes {
+  tag_sizes() : num_ints(0), num_reals(0), num_strings(0) {}
+  int num_ints;
+  int num_reals;
+  int num_strings;
+};
+
+struct obj_shape {
+  std::vector<real_t> v;
+  std::vector<real_t> vn;
+  std::vector<real_t> vt;
+};
+
+// See
+// http://stackoverflow.com/questions/6089231/getting-std-ifstream-to-handle-lf-cr-and-crlf
+static std::istream &safeGetline(std::istream &is, std::string &t) {
+  t.clear();
+
+  // The characters in the stream are read one-by-one using a std::streambuf.
+  // That is faster than reading them one-by-one using the std::istream.
+  // Code that uses streambuf this way must be guarded by a sentry object.
+  // The sentry object performs various tasks,
+  // such as thread synchronization and updating the stream state.
+
+  std::istream::sentry se(is, true);
+  std::streambuf *sb = is.rdbuf();
+
+  if (se) {
+    for (;;) {
+      int c = sb->sbumpc();
+      switch (c) {
+        case '\n':
+          return is;
+        case '\r':
+          if (sb->sgetc() == '\n') sb->sbumpc();
+          return is;
+        case EOF:
+          // Also handle the case when the last line has no line ending
+          if (t.empty()) is.setstate(std::ios::eofbit);
+          return is;
+        default:
+          t += static_cast<char>(c);
+      }
+    }
+  }
+
+  return is;
+}
+
+#define IS_SPACE(x) (((x) == ' ') || ((x) == '\t'))
+#define IS_DIGIT(x) \
+  (static_cast<unsigned int>((x) - '0') < static_cast<unsigned int>(10))
+#define IS_NEW_LINE(x) (((x) == '\r') || ((x) == '\n') || ((x) == '\0'))
+
+// Make index zero-base, and also support relative index.
+static inline bool fixIndex(int idx, int n, int *ret) {
+  if (!ret) {
+    return false;
+  }
+
+  if (idx > 0) {
+    (*ret) = idx - 1;
+    return true;
+  }
+
+  if (idx == 0) {
+    // zero is not allowed according to the spec.
+    return false;
+  }
+
+  if (idx < 0) {
+    (*ret) = n + idx;  // negative value = relative
+    return true;
+  }
+
+  return false;  // never reach here.
+}
+
+static inline std::string parseString(const char **token) {
+  std::string s;
+  (*token) += strspn((*token), " \t");
+  size_t e = strcspn((*token), " \t\r");
+  s = std::string((*token), &(*token)[e]);
+  (*token) += e;
+  return s;
+}
+
+static inline int parseInt(const char **token) {
+  (*token) += strspn((*token), " \t");
+  int i = atoi((*token));
+  (*token) += strcspn((*token), " \t\r");
+  return i;
+}
+
+// Tries to parse a floating point number located at s.
+//
+// s_end should be a location in the string where reading should absolutely
+// stop. For example at the end of the string, to prevent buffer overflows.
+//
+// Parses the following EBNF grammar:
+//   sign    = "+" | "-" ;
+//   END     = ? anything not in digit ?
+//   digit   = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+//   integer = [sign] , digit , {digit} ;
+//   decimal = integer , ["." , integer] ;
+//   float   = ( decimal , END ) | ( decimal , ("E" | "e") , integer , END ) ;
+//
+//  Valid strings are for example:
+//   -0  +3.1417e+2  -0.0E-3  1.0324  -1.41   11e2
+//
+// If the parsing is a success, result is set to the parsed value and true
+// is returned.
+//
+// The function is greedy and will parse until any of the following happens:
+//  - a non-conforming character is encountered.
+//  - s_end is reached.
+//
+// The following situations triggers a failure:
+//  - s >= s_end.
+//  - parse failure.
+//
+static bool tryParseDouble(const char *s, const char *s_end, double *result) {
+  if (s >= s_end) {
+    return false;
+  }
+
+  double mantissa = 0.0;
+  // This exponent is base 2 rather than 10.
+  // However the exponent we parse is supposed to be one of ten,
+  // thus we must take care to convert the exponent/and or the
+  // mantissa to a * 2^E, where a is the mantissa and E is the
+  // exponent.
+  // To get the final double we will use ldexp, it requires the
+  // exponent to be in base 2.
+  int exponent = 0;
+
+  // NOTE: THESE MUST BE DECLARED HERE SINCE WE ARE NOT ALLOWED
+  // TO JUMP OVER DEFINITIONS.
+  char sign = '+';
+  char exp_sign = '+';
+  char const *curr = s;
+
+  // How many characters were read in a loop.
+  int read = 0;
+  // Tells whether a loop terminated due to reaching s_end.
+  bool end_not_reached = false;
+
+  /*
+          BEGIN PARSING.
+  */
+
+  // Find out what sign we've got.
+  if (*curr == '+' || *curr == '-') {
+    sign = *curr;
+    curr++;
+  } else if (IS_DIGIT(*curr)) { /* Pass through. */
+  } else {
+    goto fail;
+  }
+
+  // Read the integer part.
+  end_not_reached = (curr != s_end);
+  while (end_not_reached && IS_DIGIT(*curr)) {
+    mantissa *= 10;
+    mantissa += static_cast<int>(*curr - 0x30);
+    curr++;
+    read++;
+    end_not_reached = (curr != s_end);
+  }
+
+  // We must make sure we actually got something.
+  if (read == 0) goto fail;
+  // We allow numbers of form "#", "###" etc.
+  if (!end_not_reached) goto assemble;
+
+  // Read the decimal part.
+  if (*curr == '.') {
+    curr++;
+    read = 1;
+    end_not_reached = (curr != s_end);
+    while (end_not_reached && IS_DIGIT(*curr)) {
+      static const double pow_lut[] = {
+          1.0, 0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001,
+      };
+      const int lut_entries = sizeof pow_lut / sizeof pow_lut[0];
+
+      // NOTE: Don't use powf here, it will absolutely murder precision.
+      mantissa += static_cast<int>(*curr - 0x30) *
+                  (read < lut_entries ? pow_lut[read] : std::pow(10.0, -read));
+      read++;
+      curr++;
+      end_not_reached = (curr != s_end);
+    }
+  } else if (*curr == 'e' || *curr == 'E') {
+  } else {
+    goto assemble;
+  }
+
+  if (!end_not_reached) goto assemble;
+
+  // Read the exponent part.
+  if (*curr == 'e' || *curr == 'E') {
+    curr++;
+    // Figure out if a sign is present and if it is.
+    end_not_reached = (curr != s_end);
+    if (end_not_reached && (*curr == '+' || *curr == '-')) {
+      exp_sign = *curr;
+      curr++;
+    } else if (IS_DIGIT(*curr)) { /* Pass through. */
+    } else {
+      // Empty E is not allowed.
+      goto fail;
+    }
+
+    read = 0;
+    end_not_reached = (curr != s_end);
+    while (end_not_reached && IS_DIGIT(*curr)) {
+      exponent *= 10;
+      exponent += static_cast<int>(*curr - 0x30);
+      curr++;
+      read++;
+      end_not_reached = (curr != s_end);
+    }
+    exponent *= (exp_sign == '+' ? 1 : -1);
+    if (read == 0) goto fail;
+  }
+
+assemble:
+  *result = (sign == '+' ? 1 : -1) *
+            (exponent ? std::ldexp(mantissa * std::pow(5.0, exponent), exponent)
+                      : mantissa);
+  return true;
+fail:
+  return false;
+}
+
+static inline real_t parseReal(const char **token, double default_value = 0.0) {
+  (*token) += strspn((*token), " \t");
+  const char *end = (*token) + strcspn((*token), " \t\r");
+  double val = default_value;
+  tryParseDouble((*token), end, &val);
+  real_t f = static_cast<real_t>(val);
+  (*token) = end;
+  return f;
+}
+
+static inline bool parseReal(const char **token, real_t *out) {
+  (*token) += strspn((*token), " \t");
+  const char *end = (*token) + strcspn((*token), " \t\r");
+  double val;
+  bool ret = tryParseDouble((*token), end, &val);
+  if (ret) {
+    real_t f = static_cast<real_t>(val);
+    (*out) = f;
+  }
+  (*token) = end;
+  return ret;
+}
+
+static inline void parseReal2(real_t *x, real_t *y, const char **token,
+                              const double default_x = 0.0,
+                              const double default_y = 0.0) {
+  (*x) = parseReal(token, default_x);
+  (*y) = parseReal(token, default_y);
+}
+
+static inline void parseReal3(real_t *x, real_t *y, real_t *z,
+                              const char **token, const double default_x = 0.0,
+                              const double default_y = 0.0,
+                              const double default_z = 0.0) {
+  (*x) = parseReal(token, default_x);
+  (*y) = parseReal(token, default_y);
+  (*z) = parseReal(token, default_z);
+}
+
+static inline void parseV(real_t *x, real_t *y, real_t *z, real_t *w,
+                          const char **token, const double default_x = 0.0,
+                          const double default_y = 0.0,
+                          const double default_z = 0.0,
+                          const double default_w = 1.0) {
+  (*x) = parseReal(token, default_x);
+  (*y) = parseReal(token, default_y);
+  (*z) = parseReal(token, default_z);
+  (*w) = parseReal(token, default_w);
+}
+
+// Extension: parse vertex with colors(6 items)
+static inline bool parseVertexWithColor(real_t *x, real_t *y, real_t *z,
+                                        real_t *r, real_t *g, real_t *b,
+                                        const char **token,
+                                        const double default_x = 0.0,
+                                        const double default_y = 0.0,
+                                        const double default_z = 0.0) {
+  (*x) = parseReal(token, default_x);
+  (*y) = parseReal(token, default_y);
+  (*z) = parseReal(token, default_z);
+
+  const bool found_color =
+      parseReal(token, r) && parseReal(token, g) && parseReal(token, b);
+
+  if (!found_color) {
+    (*r) = (*g) = (*b) = 1.0;
+  }
+
+  return found_color;
+}
+
+static inline bool parseOnOff(const char **token, bool default_value = true) {
+  (*token) += strspn((*token), " \t");
+  const char *end = (*token) + strcspn((*token), " \t\r");
+
+  bool ret = default_value;
+  if ((0 == strncmp((*token), "on", 2))) {
+    ret = true;
+  } else if ((0 == strncmp((*token), "off", 3))) {
+    ret = false;
+  }
+
+  (*token) = end;
+  return ret;
+}
+
+static inline texture_type_t parseTextureType(
+    const char **token, texture_type_t default_value = TEXTURE_TYPE_NONE) {
+  (*token) += strspn((*token), " \t");
+  const char *end = (*token) + strcspn((*token), " \t\r");
+  texture_type_t ty = default_value;
+
+  if ((0 == strncmp((*token), "cube_top", strlen("cube_top")))) {
+    ty = TEXTURE_TYPE_CUBE_TOP;
+  } else if ((0 == strncmp((*token), "cube_bottom", strlen("cube_bottom")))) {
+    ty = TEXTURE_TYPE_CUBE_BOTTOM;
+  } else if ((0 == strncmp((*token), "cube_left", strlen("cube_left")))) {
+    ty = TEXTURE_TYPE_CUBE_LEFT;
+  } else if ((0 == strncmp((*token), "cube_right", strlen("cube_right")))) {
+    ty = TEXTURE_TYPE_CUBE_RIGHT;
+  } else if ((0 == strncmp((*token), "cube_front", strlen("cube_front")))) {
+    ty = TEXTURE_TYPE_CUBE_FRONT;
+  } else if ((0 == strncmp((*token), "cube_back", strlen("cube_back")))) {
+    ty = TEXTURE_TYPE_CUBE_BACK;
+  } else if ((0 == strncmp((*token), "sphere", strlen("sphere")))) {
+    ty = TEXTURE_TYPE_SPHERE;
+  }
+
+  (*token) = end;
+  return ty;
+}
+
+static tag_sizes parseTagTriple(const char **token) {
+  tag_sizes ts;
+
+  (*token) += strspn((*token), " \t");
+  ts.num_ints = atoi((*token));
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    return ts;
+  }
+
+  (*token)++;  // Skip '/'
+
+  (*token) += strspn((*token), " \t");
+  ts.num_reals = atoi((*token));
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    return ts;
+  }
+  (*token)++;  // Skip '/'
+
+  ts.num_strings = parseInt(token);
+
+  return ts;
+}
+
+// Parse triples with index offsets: i, i/j/k, i//k, i/j
+static bool parseTriple(const char **token, int vsize, int vnsize, int vtsize,
+                        vertex_index_t *ret) {
+  if (!ret) {
+    return false;
+  }
+
+  vertex_index_t vi(-1);
+
+  if (!fixIndex(atoi((*token)), vsize, &(vi.v_idx))) {
+    return false;
+  }
+
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    (*ret) = vi;
+    return true;
+  }
+  (*token)++;
+
+  // i//k
+  if ((*token)[0] == '/') {
+    (*token)++;
+    if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) {
+      return false;
+    }
+    (*token) += strcspn((*token), "/ \t\r");
+    (*ret) = vi;
+    return true;
+  }
+
+  // i/j/k or i/j
+  if (!fixIndex(atoi((*token)), vtsize, &(vi.vt_idx))) {
+    return false;
+  }
+
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    (*ret) = vi;
+    return true;
+  }
+
+  // i/j/k
+  (*token)++;  // skip '/'
+  if (!fixIndex(atoi((*token)), vnsize, &(vi.vn_idx))) {
+    return false;
+  }
+  (*token) += strcspn((*token), "/ \t\r");
+
+  (*ret) = vi;
+
+  return true;
+}
+
+// Parse raw triples: i, i/j/k, i//k, i/j
+static vertex_index_t parseRawTriple(const char **token) {
+  vertex_index_t vi(static_cast<int>(0));  // 0 is an invalid index in OBJ
+
+  vi.v_idx = atoi((*token));
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    return vi;
+  }
+  (*token)++;
+
+  // i//k
+  if ((*token)[0] == '/') {
+    (*token)++;
+    vi.vn_idx = atoi((*token));
+    (*token) += strcspn((*token), "/ \t\r");
+    return vi;
+  }
+
+  // i/j/k or i/j
+  vi.vt_idx = atoi((*token));
+  (*token) += strcspn((*token), "/ \t\r");
+  if ((*token)[0] != '/') {
+    return vi;
+  }
+
+  // i/j/k
+  (*token)++;  // skip '/'
+  vi.vn_idx = atoi((*token));
+  (*token) += strcspn((*token), "/ \t\r");
+  return vi;
+}
+
+bool ParseTextureNameAndOption(std::string *texname,
+                                      texture_option_t *texopt,
+                                      const char *linebuf, const bool is_bump) {
+  // @todo { write more robust lexer and parser. }
+  bool found_texname = false;
+  std::string texture_name;
+
+  // Fill with default value for texopt.
+  if (is_bump) {
+    texopt->imfchan = 'l';
+  } else {
+    texopt->imfchan = 'm';
+  }
+  texopt->bump_multiplier = static_cast<real_t>(1.0);
+  texopt->clamp = false;
+  texopt->blendu = true;
+  texopt->blendv = true;
+  texopt->sharpness = static_cast<real_t>(1.0);
+  texopt->brightness = static_cast<real_t>(0.0);
+  texopt->contrast = static_cast<real_t>(1.0);
+  texopt->origin_offset[0] = static_cast<real_t>(0.0);
+  texopt->origin_offset[1] = static_cast<real_t>(0.0);
+  texopt->origin_offset[2] = static_cast<real_t>(0.0);
+  texopt->scale[0] = static_cast<real_t>(1.0);
+  texopt->scale[1] = static_cast<real_t>(1.0);
+  texopt->scale[2] = static_cast<real_t>(1.0);
+  texopt->turbulence[0] = static_cast<real_t>(0.0);
+  texopt->turbulence[1] = static_cast<real_t>(0.0);
+  texopt->turbulence[2] = static_cast<real_t>(0.0);
+  texopt->type = TEXTURE_TYPE_NONE;
+
+  const char *token = linebuf;  // Assume line ends with NULL
+
+  while (!IS_NEW_LINE((*token))) {
+    token += strspn(token, " \t");  // skip space
+    if ((0 == strncmp(token, "-blendu", 7)) && IS_SPACE((token[7]))) {
+      token += 8;
+      texopt->blendu = parseOnOff(&token, /* default */ true);
+    } else if ((0 == strncmp(token, "-blendv", 7)) && IS_SPACE((token[7]))) {
+      token += 8;
+      texopt->blendv = parseOnOff(&token, /* default */ true);
+    } else if ((0 == strncmp(token, "-clamp", 6)) && IS_SPACE((token[6]))) {
+      token += 7;
+      texopt->clamp = parseOnOff(&token, /* default */ true);
+    } else if ((0 == strncmp(token, "-boost", 6)) && IS_SPACE((token[6]))) {
+      token += 7;
+      texopt->sharpness = parseReal(&token, 1.0);
+    } else if ((0 == strncmp(token, "-bm", 3)) && IS_SPACE((token[3]))) {
+      token += 4;
+      texopt->bump_multiplier = parseReal(&token, 1.0);
+    } else if ((0 == strncmp(token, "-o", 2)) && IS_SPACE((token[2]))) {
+      token += 3;
+      parseReal3(&(texopt->origin_offset[0]), &(texopt->origin_offset[1]),
+                 &(texopt->origin_offset[2]), &token);
+    } else if ((0 == strncmp(token, "-s", 2)) && IS_SPACE((token[2]))) {
+      token += 3;
+      parseReal3(&(texopt->scale[0]), &(texopt->scale[1]), &(texopt->scale[2]),
+                 &token, 1.0, 1.0, 1.0);
+    } else if ((0 == strncmp(token, "-t", 2)) && IS_SPACE((token[2]))) {
+      token += 3;
+      parseReal3(&(texopt->turbulence[0]), &(texopt->turbulence[1]),
+                 &(texopt->turbulence[2]), &token);
+    } else if ((0 == strncmp(token, "-type", 5)) && IS_SPACE((token[5]))) {
+      token += 5;
+      texopt->type = parseTextureType((&token), TEXTURE_TYPE_NONE);
+    } else if ((0 == strncmp(token, "-imfchan", 8)) && IS_SPACE((token[8]))) {
+      token += 9;
+      token += strspn(token, " \t");
+      const char *end = token + strcspn(token, " \t\r");
+      if ((end - token) == 1) {  // Assume one char for -imfchan
+        texopt->imfchan = (*token);
+      }
+      token = end;
+    } else if ((0 == strncmp(token, "-mm", 3)) && IS_SPACE((token[3]))) {
+      token += 4;
+      parseReal2(&(texopt->brightness), &(texopt->contrast), &token, 0.0, 1.0);
+    } else if ((0 == strncmp(token, "-colorspace", 11)) &&
+               IS_SPACE((token[11]))) {
+      token += 12;
+      texopt->colorspace = parseString(&token);
+    } else {
+// Assume texture filename
+#if 0
+      size_t len = strcspn(token, " \t\r");  // untile next space
+      texture_name = std::string(token, token + len);
+      token += len;
+
+      token += strspn(token, " \t");  // skip space
+#else
+      // Read filename until line end to parse filename containing whitespace
+      // TODO(syoyo): Support parsing texture option flag after the filename.
+      texture_name = std::string(token);
+      token += texture_name.length();
+#endif
+
+      found_texname = true;
+    }
+  }
+
+  if (found_texname) {
+    (*texname) = texture_name;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static void InitMaterial(material_t *material) {
+  material->name = "";
+  material->ambient_texname = "";
+  material->diffuse_texname = "";
+  material->specular_texname = "";
+  material->specular_highlight_texname = "";
+  material->bump_texname = "";
+  material->displacement_texname = "";
+  material->reflection_texname = "";
+  material->alpha_texname = "";
+  for (int i = 0; i < 3; i++) {
+    material->ambient[i] = static_cast<real_t>(0.0);
+    material->diffuse[i] = static_cast<real_t>(0.0);
+    material->specular[i] = static_cast<real_t>(0.0);
+    material->transmittance[i] = static_cast<real_t>(0.0);
+    material->emission[i] = static_cast<real_t>(0.0);
+  }
+  material->illum = 0;
+  material->dissolve = static_cast<real_t>(1.0);
+  material->shininess = static_cast<real_t>(1.0);
+  material->ior = static_cast<real_t>(1.0);
+
+  material->roughness = static_cast<real_t>(0.0);
+  material->metallic = static_cast<real_t>(0.0);
+  material->sheen = static_cast<real_t>(0.0);
+  material->clearcoat_thickness = static_cast<real_t>(0.0);
+  material->clearcoat_roughness = static_cast<real_t>(0.0);
+  material->anisotropy_rotation = static_cast<real_t>(0.0);
+  material->anisotropy = static_cast<real_t>(0.0);
+  material->roughness_texname = "";
+  material->metallic_texname = "";
+  material->sheen_texname = "";
+  material->emissive_texname = "";
+  material->normal_texname = "";
+
+  material->unknown_parameter.clear();
+}
+
+// code from https://wrf.ecse.rpi.edu//Research/Short_Notes/pnpoly.html
+template <typename T>
+static int pnpoly(int nvert, T *vertx, T *verty, T testx, T testy) {
+  int i, j, c = 0;
+  for (i = 0, j = nvert - 1; i < nvert; j = i++) {
+    if (((verty[i] > testy) != (verty[j] > testy)) &&
+        (testx <
+         (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) +
+             vertx[i]))
+      c = !c;
+  }
+  return c;
+}
+
+// TODO(syoyo): refactor function.
+static bool exportGroupsToShape(shape_t *shape,
+                                const std::vector<face_t> &faceGroup,
+                                std::vector<int> &lineGroup,
+                                const std::vector<tag_t> &tags,
+                                const int material_id, const std::string &name,
+                                bool triangulate,
+                                const std::vector<real_t> &v) {
+  if (faceGroup.empty() && lineGroup.empty()) {
+    return false;
+  }
+
+  if (!faceGroup.empty()) {
+    // Flatten vertices and indices
+    for (size_t i = 0; i < faceGroup.size(); i++) {
+      const face_t &face = faceGroup[i];
+
+      size_t npolys = face.vertex_indices.size();
+
+      if (npolys < 3) {
+        // Face must have 3+ vertices.
+        continue;
+      }
+
+      vertex_index_t i0 = face.vertex_indices[0];
+      vertex_index_t i1(-1);
+      vertex_index_t i2 = face.vertex_indices[1];
+
+      if (triangulate) {
+        // find the two axes to work in
+        size_t axes[2] = {1, 2};
+        for (size_t k = 0; k < npolys; ++k) {
+          i0 = face.vertex_indices[(k + 0) % npolys];
+          i1 = face.vertex_indices[(k + 1) % npolys];
+          i2 = face.vertex_indices[(k + 2) % npolys];
+          size_t vi0 = size_t(i0.v_idx);
+          size_t vi1 = size_t(i1.v_idx);
+          size_t vi2 = size_t(i2.v_idx);
+
+          if (((3 * vi0 + 2) >= v.size()) || ((3 * vi1 + 2) >= v.size()) ||
+              ((3 * vi2 + 2) >= v.size())) {
+            // Invalid triangle.
+            // FIXME(syoyo): Is it ok to simply skip this invalid triangle?
+            continue;
+          }
+          real_t v0x = v[vi0 * 3 + 0];
+          real_t v0y = v[vi0 * 3 + 1];
+          real_t v0z = v[vi0 * 3 + 2];
+          real_t v1x = v[vi1 * 3 + 0];
+          real_t v1y = v[vi1 * 3 + 1];
+          real_t v1z = v[vi1 * 3 + 2];
+          real_t v2x = v[vi2 * 3 + 0];
+          real_t v2y = v[vi2 * 3 + 1];
+          real_t v2z = v[vi2 * 3 + 2];
+          real_t e0x = v1x - v0x;
+          real_t e0y = v1y - v0y;
+          real_t e0z = v1z - v0z;
+          real_t e1x = v2x - v1x;
+          real_t e1y = v2y - v1y;
+          real_t e1z = v2z - v1z;
+          real_t cx = std::fabs(e0y * e1z - e0z * e1y);
+          real_t cy = std::fabs(e0z * e1x - e0x * e1z);
+          real_t cz = std::fabs(e0x * e1y - e0y * e1x);
+          const real_t epsilon = std::numeric_limits<real_t>::epsilon();
+          if (cx > epsilon || cy > epsilon || cz > epsilon) {
+            // found a corner
+            if (cx > cy && cx > cz) {
+            } else {
+              axes[0] = 0;
+              if (cz > cx && cz > cy) axes[1] = 1;
+            }
+            break;
+          }
+        }
+
+        real_t area = 0;
+        for (size_t k = 0; k < npolys; ++k) {
+          i0 = face.vertex_indices[(k + 0) % npolys];
+          i1 = face.vertex_indices[(k + 1) % npolys];
+          size_t vi0 = size_t(i0.v_idx);
+          size_t vi1 = size_t(i1.v_idx);
+          if (((vi0 * 3 + axes[0]) >= v.size()) ||
+              ((vi0 * 3 + axes[1]) >= v.size()) ||
+              ((vi1 * 3 + axes[0]) >= v.size()) ||
+              ((vi1 * 3 + axes[1]) >= v.size())) {
+            // Invalid index.
+            continue;
+          }
+          real_t v0x = v[vi0 * 3 + axes[0]];
+          real_t v0y = v[vi0 * 3 + axes[1]];
+          real_t v1x = v[vi1 * 3 + axes[0]];
+          real_t v1y = v[vi1 * 3 + axes[1]];
+          area += (v0x * v1y - v0y * v1x) * static_cast<real_t>(0.5);
+        }
+
+        int maxRounds = 10;  // arbitrary max loop count to protect against
+                             // unexpected errors
+
+        face_t remainingFace = face;  // copy
+        size_t guess_vert = 0;
+        vertex_index_t ind[3];
+        real_t vx[3];
+        real_t vy[3];
+        while (remainingFace.vertex_indices.size() > 3 && maxRounds > 0) {
+          npolys = remainingFace.vertex_indices.size();
+          if (guess_vert >= npolys) {
+            maxRounds -= 1;
+            guess_vert -= npolys;
+          }
+          for (size_t k = 0; k < 3; k++) {
+            ind[k] = remainingFace.vertex_indices[(guess_vert + k) % npolys];
+            size_t vi = size_t(ind[k].v_idx);
+            if (((vi * 3 + axes[0]) >= v.size()) ||
+                ((vi * 3 + axes[1]) >= v.size())) {
+              // ???
+              vx[k] = static_cast<real_t>(0.0);
+              vy[k] = static_cast<real_t>(0.0);
+            } else {
+              vx[k] = v[vi * 3 + axes[0]];
+              vy[k] = v[vi * 3 + axes[1]];
+            }
+          }
+          real_t e0x = vx[1] - vx[0];
+          real_t e0y = vy[1] - vy[0];
+          real_t e1x = vx[2] - vx[1];
+          real_t e1y = vy[2] - vy[1];
+          real_t cross = e0x * e1y - e0y * e1x;
+          // if an internal angle
+          if (cross * area < static_cast<real_t>(0.0)) {
+            guess_vert += 1;
+            continue;
+          }
+
+          // check all other verts in case they are inside this triangle
+          bool overlap = false;
+          for (size_t otherVert = 3; otherVert < npolys; ++otherVert) {
+            size_t idx = (guess_vert + otherVert) % npolys;
+
+            if (idx >= remainingFace.vertex_indices.size()) {
+              // ???
+              continue;
+            }
+
+            size_t ovi = size_t(remainingFace.vertex_indices[idx].v_idx);
+
+            if (((ovi * 3 + axes[0]) >= v.size()) ||
+                ((ovi * 3 + axes[1]) >= v.size())) {
+              // ???
+              continue;
+            }
+            real_t tx = v[ovi * 3 + axes[0]];
+            real_t ty = v[ovi * 3 + axes[1]];
+            if (pnpoly(3, vx, vy, tx, ty)) {
+              overlap = true;
+              break;
+            }
+          }
+
+          if (overlap) {
+            guess_vert += 1;
+            continue;
+          }
+
+          // this triangle is an ear
+          {
+            index_t idx0, idx1, idx2;
+            idx0.vertex_index = ind[0].v_idx;
+            idx0.normal_index = ind[0].vn_idx;
+            idx0.texcoord_index = ind[0].vt_idx;
+            idx1.vertex_index = ind[1].v_idx;
+            idx1.normal_index = ind[1].vn_idx;
+            idx1.texcoord_index = ind[1].vt_idx;
+            idx2.vertex_index = ind[2].v_idx;
+            idx2.normal_index = ind[2].vn_idx;
+            idx2.texcoord_index = ind[2].vt_idx;
+
+            shape->mesh.indices.push_back(idx0);
+            shape->mesh.indices.push_back(idx1);
+            shape->mesh.indices.push_back(idx2);
+
+            shape->mesh.num_face_vertices.push_back(3);
+            shape->mesh.material_ids.push_back(material_id);
+            shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id);
+          }
+
+          // remove v1 from the list
+          size_t removed_vert_index = (guess_vert + 1) % npolys;
+          while (removed_vert_index + 1 < npolys) {
+            remainingFace.vertex_indices[removed_vert_index] =
+                remainingFace.vertex_indices[removed_vert_index + 1];
+            removed_vert_index += 1;
+          }
+          remainingFace.vertex_indices.pop_back();
+        }
+
+        if (remainingFace.vertex_indices.size() == 3) {
+          i0 = remainingFace.vertex_indices[0];
+          i1 = remainingFace.vertex_indices[1];
+          i2 = remainingFace.vertex_indices[2];
+          {
+            index_t idx0, idx1, idx2;
+            idx0.vertex_index = i0.v_idx;
+            idx0.normal_index = i0.vn_idx;
+            idx0.texcoord_index = i0.vt_idx;
+            idx1.vertex_index = i1.v_idx;
+            idx1.normal_index = i1.vn_idx;
+            idx1.texcoord_index = i1.vt_idx;
+            idx2.vertex_index = i2.v_idx;
+            idx2.normal_index = i2.vn_idx;
+            idx2.texcoord_index = i2.vt_idx;
+
+            shape->mesh.indices.push_back(idx0);
+            shape->mesh.indices.push_back(idx1);
+            shape->mesh.indices.push_back(idx2);
+
+            shape->mesh.num_face_vertices.push_back(3);
+            shape->mesh.material_ids.push_back(material_id);
+            shape->mesh.smoothing_group_ids.push_back(face.smoothing_group_id);
+          }
+        }
+      } else {
+        for (size_t k = 0; k < npolys; k++) {
+          index_t idx;
+          idx.vertex_index = face.vertex_indices[k].v_idx;
+          idx.normal_index = face.vertex_indices[k].vn_idx;
+          idx.texcoord_index = face.vertex_indices[k].vt_idx;
+          shape->mesh.indices.push_back(idx);
+        }
+
+        shape->mesh.num_face_vertices.push_back(
+            static_cast<unsigned char>(npolys));
+        shape->mesh.material_ids.push_back(material_id);  // per face
+        shape->mesh.smoothing_group_ids.push_back(
+            face.smoothing_group_id);  // per face
+      }
+    }
+
+    shape->name = name;
+    shape->mesh.tags = tags;
+  }
+
+  if (!lineGroup.empty()) {
+    shape->path.indices.swap(lineGroup);
+  }
+
+  return true;
+}
+
+// Split a string with specified delimiter character.
+// http://stackoverflow.com/questions/236129/split-a-string-in-c
+static void SplitString(const std::string &s, char delim,
+                        std::vector<std::string> &elems) {
+  std::stringstream ss;
+  ss.str(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    elems.push_back(item);
+  }
+}
+
+void LoadMtl(std::map<std::string, int> *material_map,
+             std::vector<material_t> *materials, std::istream *inStream,
+             std::string *warning, std::string *err) {
+  (void)err;
+
+  // Create a default material anyway.
+  material_t material;
+  InitMaterial(&material);
+
+  // Issue 43. `d` wins against `Tr` since `Tr` is not in the MTL specification.
+  bool has_d = false;
+  bool has_tr = false;
+
+  std::stringstream warn_ss;
+
+  size_t line_no = 0;
+  std::string linebuf;
+  while (inStream->peek() != -1) {
+    safeGetline(*inStream, linebuf);
+      line_no++;
+
+    // Trim trailing whitespace.
+    if (linebuf.size() > 0) {
+      linebuf = linebuf.substr(0, linebuf.find_last_not_of(" \t") + 1);
+    }
+
+    // Trim newline '\r\n' or '\n'
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\n')
+        linebuf.erase(linebuf.size() - 1);
+    }
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\r')
+        linebuf.erase(linebuf.size() - 1);
+    }
+
+    // Skip if empty line.
+    if (linebuf.empty()) {
+      continue;
+    }
+
+    // Skip leading space.
+    const char *token = linebuf.c_str();
+    token += strspn(token, " \t");
+
+    assert(token);
+    if (token[0] == '\0') continue;  // empty line
+
+    if (token[0] == '#') continue;  // comment line
+
+    // new mtl
+    if ((0 == strncmp(token, "newmtl", 6)) && IS_SPACE((token[6]))) {
+      // flush previous material.
+      if (!material.name.empty()) {
+        material_map->insert(std::pair<std::string, int>(
+            material.name, static_cast<int>(materials->size())));
+        materials->push_back(material);
+      }
+
+      // initial temporary material
+      InitMaterial(&material);
+
+      has_d = false;
+      has_tr = false;
+
+      // set new mtl name
+      token += 7;
+      {
+        std::stringstream sstr;
+        sstr << token;
+        material.name = sstr.str();
+      }
+      continue;
+    }
+
+    // ambient
+    if (token[0] == 'K' && token[1] == 'a' && IS_SPACE((token[2]))) {
+      token += 2;
+      real_t r, g, b;
+      parseReal3(&r, &g, &b, &token);
+      material.ambient[0] = r;
+      material.ambient[1] = g;
+      material.ambient[2] = b;
+      continue;
+    }
+
+    // diffuse
+    if (token[0] == 'K' && token[1] == 'd' && IS_SPACE((token[2]))) {
+      token += 2;
+      real_t r, g, b;
+      parseReal3(&r, &g, &b, &token);
+      material.diffuse[0] = r;
+      material.diffuse[1] = g;
+      material.diffuse[2] = b;
+      continue;
+    }
+
+    // specular
+    if (token[0] == 'K' && token[1] == 's' && IS_SPACE((token[2]))) {
+      token += 2;
+      real_t r, g, b;
+      parseReal3(&r, &g, &b, &token);
+      material.specular[0] = r;
+      material.specular[1] = g;
+      material.specular[2] = b;
+      continue;
+    }
+
+    // transmittance
+    if ((token[0] == 'K' && token[1] == 't' && IS_SPACE((token[2]))) ||
+        (token[0] == 'T' && token[1] == 'f' && IS_SPACE((token[2])))) {
+      token += 2;
+      real_t r, g, b;
+      parseReal3(&r, &g, &b, &token);
+      material.transmittance[0] = r;
+      material.transmittance[1] = g;
+      material.transmittance[2] = b;
+      continue;
+    }
+
+    // ior(index of refraction)
+    if (token[0] == 'N' && token[1] == 'i' && IS_SPACE((token[2]))) {
+      token += 2;
+      material.ior = parseReal(&token);
+      continue;
+    }
+
+    // emission
+    if (token[0] == 'K' && token[1] == 'e' && IS_SPACE(token[2])) {
+      token += 2;
+      real_t r, g, b;
+      parseReal3(&r, &g, &b, &token);
+      material.emission[0] = r;
+      material.emission[1] = g;
+      material.emission[2] = b;
+      continue;
+    }
+
+    // shininess
+    if (token[0] == 'N' && token[1] == 's' && IS_SPACE(token[2])) {
+      token += 2;
+      material.shininess = parseReal(&token);
+      continue;
+    }
+
+    // illum model
+    if (0 == strncmp(token, "illum", 5) && IS_SPACE(token[5])) {
+      token += 6;
+      material.illum = parseInt(&token);
+      continue;
+    }
+
+    // dissolve
+    if ((token[0] == 'd' && IS_SPACE(token[1]))) {
+      token += 1;
+      material.dissolve = parseReal(&token);
+
+      if (has_tr) {
+        warn_ss << "Both `d` and `Tr` parameters defined for \""
+                << material.name << "\". Use the value of `d` for dissolve (line "
+                << line_no << " in .mtl.)"
+                << std::endl;
+      }
+      has_d = true;
+      continue;
+    }
+    if (token[0] == 'T' && token[1] == 'r' && IS_SPACE(token[2])) {
+      token += 2;
+      if (has_d) {
+        // `d` wins. Ignore `Tr` value.
+        warn_ss << "Both `d` and `Tr` parameters defined for \""
+                << material.name << "\". Use the value of `d` for dissolve (line "
+                << line_no << " in .mtl.)"
+                << std::endl;
+      } else {
+        // We invert value of Tr(assume Tr is in range [0, 1])
+        // NOTE: Interpretation of Tr is application(exporter) dependent. For
+        // some application(e.g. 3ds max obj exporter), Tr = d(Issue 43)
+        material.dissolve = static_cast<real_t>(1.0) - parseReal(&token);
+      }
+      has_tr = true;
+      continue;
+    }
+
+    // PBR: roughness
+    if (token[0] == 'P' && token[1] == 'r' && IS_SPACE(token[2])) {
+      token += 2;
+      material.roughness = parseReal(&token);
+      continue;
+    }
+
+    // PBR: metallic
+    if (token[0] == 'P' && token[1] == 'm' && IS_SPACE(token[2])) {
+      token += 2;
+      material.metallic = parseReal(&token);
+      continue;
+    }
+
+    // PBR: sheen
+    if (token[0] == 'P' && token[1] == 's' && IS_SPACE(token[2])) {
+      token += 2;
+      material.sheen = parseReal(&token);
+      continue;
+    }
+
+    // PBR: clearcoat thickness
+    if (token[0] == 'P' && token[1] == 'c' && IS_SPACE(token[2])) {
+      token += 2;
+      material.clearcoat_thickness = parseReal(&token);
+      continue;
+    }
+
+    // PBR: clearcoat roughness
+    if ((0 == strncmp(token, "Pcr", 3)) && IS_SPACE(token[3])) {
+      token += 4;
+      material.clearcoat_roughness = parseReal(&token);
+      continue;
+    }
+
+    // PBR: anisotropy
+    if ((0 == strncmp(token, "aniso", 5)) && IS_SPACE(token[5])) {
+      token += 6;
+      material.anisotropy = parseReal(&token);
+      continue;
+    }
+
+    // PBR: anisotropy rotation
+    if ((0 == strncmp(token, "anisor", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      material.anisotropy_rotation = parseReal(&token);
+      continue;
+    }
+
+    // ambient texture
+    if ((0 == strncmp(token, "map_Ka", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.ambient_texname),
+                                &(material.ambient_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // diffuse texture
+    if ((0 == strncmp(token, "map_Kd", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.diffuse_texname),
+                                &(material.diffuse_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // specular texture
+    if ((0 == strncmp(token, "map_Ks", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.specular_texname),
+                                &(material.specular_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // specular highlight texture
+    if ((0 == strncmp(token, "map_Ns", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.specular_highlight_texname),
+                                &(material.specular_highlight_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // bump texture
+    if ((0 == strncmp(token, "map_bump", 8)) && IS_SPACE(token[8])) {
+      token += 9;
+      ParseTextureNameAndOption(&(material.bump_texname),
+                                &(material.bump_texopt), token,
+                                /* is_bump */ true);
+      continue;
+    }
+
+    // bump texture
+    if ((0 == strncmp(token, "map_Bump", 8)) && IS_SPACE(token[8])) {
+      token += 9;
+      ParseTextureNameAndOption(&(material.bump_texname),
+                                &(material.bump_texopt), token,
+                                /* is_bump */ true);
+      continue;
+    }
+
+    // bump texture
+    if ((0 == strncmp(token, "bump", 4)) && IS_SPACE(token[4])) {
+      token += 5;
+      ParseTextureNameAndOption(&(material.bump_texname),
+                                &(material.bump_texopt), token,
+                                /* is_bump */ true);
+      continue;
+    }
+
+    // alpha texture
+    if ((0 == strncmp(token, "map_d", 5)) && IS_SPACE(token[5])) {
+      token += 6;
+      material.alpha_texname = token;
+      ParseTextureNameAndOption(&(material.alpha_texname),
+                                &(material.alpha_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // displacement texture
+    if ((0 == strncmp(token, "disp", 4)) && IS_SPACE(token[4])) {
+      token += 5;
+      ParseTextureNameAndOption(&(material.displacement_texname),
+                                &(material.displacement_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // reflection map
+    if ((0 == strncmp(token, "refl", 4)) && IS_SPACE(token[4])) {
+      token += 5;
+      ParseTextureNameAndOption(&(material.reflection_texname),
+                                &(material.reflection_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // PBR: roughness texture
+    if ((0 == strncmp(token, "map_Pr", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.roughness_texname),
+                                &(material.roughness_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // PBR: metallic texture
+    if ((0 == strncmp(token, "map_Pm", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.metallic_texname),
+                                &(material.metallic_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // PBR: sheen texture
+    if ((0 == strncmp(token, "map_Ps", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.sheen_texname),
+                                &(material.sheen_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // PBR: emissive texture
+    if ((0 == strncmp(token, "map_Ke", 6)) && IS_SPACE(token[6])) {
+      token += 7;
+      ParseTextureNameAndOption(&(material.emissive_texname),
+                                &(material.emissive_texopt), token,
+                                /* is_bump */ false);
+      continue;
+    }
+
+    // PBR: normal map texture
+    if ((0 == strncmp(token, "norm", 4)) && IS_SPACE(token[4])) {
+      token += 5;
+      ParseTextureNameAndOption(
+          &(material.normal_texname), &(material.normal_texopt), token,
+          /* is_bump */ false);  // @fixme { is_bump will be true? }
+      continue;
+    }
+
+    // unknown parameter
+    const char *_space = strchr(token, ' ');
+    if (!_space) {
+      _space = strchr(token, '\t');
+    }
+    if (_space) {
+      std::ptrdiff_t len = _space - token;
+      std::string key(token, static_cast<size_t>(len));
+      std::string value = _space + 1;
+      material.unknown_parameter.insert(
+          std::pair<std::string, std::string>(key, value));
+    }
+  }
+  // flush last material.
+  material_map->insert(std::pair<std::string, int>(
+      material.name, static_cast<int>(materials->size())));
+  materials->push_back(material);
+
+  if (warning) {
+    (*warning) = warn_ss.str();
+  }
+}
+
+bool MaterialFileReader::operator()(const std::string &matId,
+                                    std::vector<material_t> *materials,
+                                    std::map<std::string, int> *matMap,
+                                    std::string *warn, std::string *err) {
+  std::string filepath;
+
+  if (!m_mtlBaseDir.empty()) {
+    filepath = std::string(m_mtlBaseDir) + matId;
+  } else {
+    filepath = matId;
+  }
+
+  std::ifstream matIStream(filepath.c_str());
+  if (!matIStream) {
+    std::stringstream ss;
+    ss << "Material file [ " << filepath << " ] not found." << std::endl;
+    if (warn) {
+      (*warn) += ss.str();
+    }
+    return false;
+  }
+
+  LoadMtl(matMap, materials, &matIStream, warn, err);
+
+  return true;
+}
+
+bool MaterialStreamReader::operator()(const std::string &matId,
+                                      std::vector<material_t> *materials,
+                                      std::map<std::string, int> *matMap,
+                                      std::string *warn, std::string *err) {
+  (void)err;
+  (void)matId;
+  if (!m_inStream) {
+    std::stringstream ss;
+    ss << "Material stream in error state. " << std::endl;
+    if (warn) {
+      (*warn) += ss.str();
+    }
+    return false;
+  }
+
+  LoadMtl(matMap, materials, &m_inStream, warn, err);
+
+  return true;
+}
+
+bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
+             std::vector<material_t> *materials, std::string *warn,
+             std::string *err, const char *filename, const char *mtl_basedir,
+             bool trianglulate, bool default_vcols_fallback) {
+  attrib->vertices.clear();
+  attrib->normals.clear();
+  attrib->texcoords.clear();
+  attrib->colors.clear();
+  shapes->clear();
+
+  std::stringstream errss;
+
+  std::ifstream ifs(filename);
+  if (!ifs) {
+    errss << "Cannot open file [" << filename << "]" << std::endl;
+    if (err) {
+      (*err) = errss.str();
+    }
+    return false;
+  }
+
+  std::string baseDir = mtl_basedir ? mtl_basedir : "";
+  if (!baseDir.empty()) {
+#ifndef _WIN32
+    const char dirsep = '/';
+#else
+    const char dirsep = '\\';
+#endif
+    if (baseDir[baseDir.length() - 1] != dirsep) baseDir += dirsep;
+  }
+  MaterialFileReader matFileReader(baseDir);
+
+  return LoadObj(attrib, shapes, materials, warn, err, &ifs, &matFileReader,
+                 trianglulate, default_vcols_fallback);
+}
+
+bool LoadObj(attrib_t *attrib, std::vector<shape_t> *shapes,
+             std::vector<material_t> *materials, std::string *warn,
+             std::string *err, std::istream *inStream,
+             MaterialReader *readMatFn /*= NULL*/, bool triangulate,
+             bool default_vcols_fallback) {
+  std::stringstream errss;
+
+  std::vector<real_t> v;
+  std::vector<real_t> vn;
+  std::vector<real_t> vt;
+  std::vector<real_t> vc;
+  std::vector<tag_t> tags;
+  std::vector<face_t> faceGroup;
+  std::vector<int> lineGroup;
+  std::string name;
+
+  // material
+  std::map<std::string, int> material_map;
+  int material = -1;
+
+  // smoothing group id
+  unsigned int current_smoothing_id =
+      0;  // Initial value. 0 means no smoothing.
+
+  int greatest_v_idx = -1;
+  int greatest_vn_idx = -1;
+  int greatest_vt_idx = -1;
+
+  shape_t shape;
+
+  bool found_all_colors = true;
+
+  size_t line_num = 0;
+  std::string linebuf;
+  while (inStream->peek() != -1) {
+    safeGetline(*inStream, linebuf);
+
+    line_num++;
+
+    // Trim newline '\r\n' or '\n'
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\n')
+        linebuf.erase(linebuf.size() - 1);
+    }
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\r')
+        linebuf.erase(linebuf.size() - 1);
+    }
+
+    // Skip if empty line.
+    if (linebuf.empty()) {
+      continue;
+    }
+
+    // Skip leading space.
+    const char *token = linebuf.c_str();
+    token += strspn(token, " \t");
+
+    assert(token);
+    if (token[0] == '\0') continue;  // empty line
+
+    if (token[0] == '#') continue;  // comment line
+
+    // vertex
+    if (token[0] == 'v' && IS_SPACE((token[1]))) {
+      token += 2;
+      real_t x, y, z;
+      real_t r, g, b;
+
+      found_all_colors &= parseVertexWithColor(&x, &y, &z, &r, &g, &b, &token);
+
+      v.push_back(x);
+      v.push_back(y);
+      v.push_back(z);
+
+      if (found_all_colors || default_vcols_fallback) {
+        vc.push_back(r);
+        vc.push_back(g);
+        vc.push_back(b);
+      }
+
+      continue;
+    }
+
+    // normal
+    if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) {
+      token += 3;
+      real_t x, y, z;
+      parseReal3(&x, &y, &z, &token);
+      vn.push_back(x);
+      vn.push_back(y);
+      vn.push_back(z);
+      continue;
+    }
+
+    // texcoord
+    if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) {
+      token += 3;
+      real_t x, y;
+      parseReal2(&x, &y, &token);
+      vt.push_back(x);
+      vt.push_back(y);
+      continue;
+    }
+
+    // line
+    if (token[0] == 'l' && IS_SPACE((token[1]))) {
+      token += 2;
+
+      line_t line_cache;
+      bool end_line_bit = 0;
+      while (!IS_NEW_LINE(token[0])) {
+        // get index from string
+        int idx = 0;
+        fixIndex(parseInt(&token), 0, &idx);
+
+        size_t n = strspn(token, " \t\r");
+        token += n;
+
+        if (!end_line_bit) {
+          line_cache.idx0 = idx;
+        } else {
+          line_cache.idx1 = idx;
+          lineGroup.push_back(line_cache.idx0);
+          lineGroup.push_back(line_cache.idx1);
+          line_cache = line_t();
+        }
+        end_line_bit = !end_line_bit;
+      }
+
+      continue;
+    }
+    // face
+    if (token[0] == 'f' && IS_SPACE((token[1]))) {
+      token += 2;
+      token += strspn(token, " \t");
+
+      face_t face;
+
+      face.smoothing_group_id = current_smoothing_id;
+      face.vertex_indices.reserve(3);
+
+      while (!IS_NEW_LINE(token[0])) {
+        vertex_index_t vi;
+        if (!parseTriple(&token, static_cast<int>(v.size() / 3),
+                         static_cast<int>(vn.size() / 3),
+                         static_cast<int>(vt.size() / 2), &vi)) {
+          if (err) {
+            std::stringstream ss;
+            ss <<  "Failed parse `f' line(e.g. zero value for face index. line " << line_num << ".)\n";
+            (*err) += ss.str();
+          }
+          return false;
+        }
+
+        greatest_v_idx = greatest_v_idx > vi.v_idx ? greatest_v_idx : vi.v_idx;
+        greatest_vn_idx =
+            greatest_vn_idx > vi.vn_idx ? greatest_vn_idx : vi.vn_idx;
+        greatest_vt_idx =
+            greatest_vt_idx > vi.vt_idx ? greatest_vt_idx : vi.vt_idx;
+
+        face.vertex_indices.push_back(vi);
+        size_t n = strspn(token, " \t\r");
+        token += n;
+      }
+
+      // replace with emplace_back + std::move on C++11
+      faceGroup.push_back(face);
+
+      continue;
+    }
+
+    // use mtl
+    if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) {
+      token += 7;
+      std::stringstream ss;
+      ss << token;
+      std::string namebuf = ss.str();
+
+      int newMaterialId = -1;
+      if (material_map.find(namebuf) != material_map.end()) {
+        newMaterialId = material_map[namebuf];
+      } else {
+        // { error!! material not found }
+      }
+
+      if (newMaterialId != material) {
+        // Create per-face material. Thus we don't add `shape` to `shapes` at
+        // this time.
+        // just clear `faceGroup` after `exportGroupsToShape()` call.
+        exportGroupsToShape(&shape, faceGroup, lineGroup, tags, material, name,
+                            triangulate, v);
+        faceGroup.clear();
+        material = newMaterialId;
+      }
+
+      continue;
+    }
+
+    // load mtl
+    if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
+      if (readMatFn) {
+        token += 7;
+
+        std::vector<std::string> filenames;
+        SplitString(std::string(token), ' ', filenames);
+
+        if (filenames.empty()) {
+          if (warn) {
+            std::stringstream ss;
+            ss << "Looks like empty filename for mtllib. Use default "
+                "material (line " << line_num << ".)\n";
+
+            (*warn) += ss.str();
+          }
+        } else {
+          bool found = false;
+          for (size_t s = 0; s < filenames.size(); s++) {
+            std::string warn_mtl;
+            std::string err_mtl;
+            bool ok = (*readMatFn)(filenames[s].c_str(), materials,
+                                   &material_map, &warn_mtl, &err_mtl);
+            if (warn && (!warn_mtl.empty())) {
+              (*warn) += warn_mtl;
+            }
+
+            if (err && (!err_mtl.empty())) {
+              (*err) += err_mtl;
+            }
+
+            if (ok) {
+              found = true;
+              break;
+            }
+          }
+
+          if (!found) {
+            if (warn) {
+              (*warn) +=
+                  "Failed to load material file(s). Use default "
+                  "material.\n";
+            }
+          }
+        }
+      }
+
+      continue;
+    }
+
+    // group name
+    if (token[0] == 'g' && IS_SPACE((token[1]))) {
+      // flush previous face group.
+      bool ret = exportGroupsToShape(&shape, faceGroup, lineGroup, tags,
+                                     material, name, triangulate, v);
+      (void)ret;  // return value not used.
+
+      if (shape.mesh.indices.size() > 0) {
+        shapes->push_back(shape);
+      }
+
+      shape = shape_t();
+
+      // material = -1;
+      faceGroup.clear();
+
+      std::vector<std::string> names;
+
+      while (!IS_NEW_LINE(token[0])) {
+        std::string str = parseString(&token);
+        names.push_back(str);
+        token += strspn(token, " \t\r");  // skip tag
+      }
+
+      // names[0] must be 'g'
+
+      if (names.size() < 2) {
+        // 'g' with empty names
+        if (warn) {
+          std::stringstream ss;
+          ss << "Empty group name. line: " << line_num << "\n";
+          (*warn) += ss.str();
+          name = "";
+        }
+      } else {
+        std::stringstream ss;
+        ss << names[1];
+
+        // tinyobjloader does not support multiple groups for a primitive.
+        // Currently we concatinate multiple group names with a space to get
+        // single group name.
+
+        for (size_t i = 2; i < names.size(); i++) {
+          ss << " " << names[i];
+        }
+
+        name = ss.str();
+      }
+
+      continue;
+    }
+
+    // object name
+    if (token[0] == 'o' && IS_SPACE((token[1]))) {
+      // flush previous face group.
+      bool ret = exportGroupsToShape(&shape, faceGroup, lineGroup, tags,
+                                     material, name, triangulate, v);
+      if (ret) {
+        shapes->push_back(shape);
+      }
+
+      // material = -1;
+      faceGroup.clear();
+      shape = shape_t();
+
+      // @todo { multiple object name? }
+      token += 2;
+      std::stringstream ss;
+      ss << token;
+      name = ss.str();
+
+      continue;
+    }
+
+    if (token[0] == 't' && IS_SPACE(token[1])) {
+      const int max_tag_nums = 8192;  // FIXME(syoyo): Parameterize.
+      tag_t tag;
+
+      token += 2;
+
+      tag.name = parseString(&token);
+
+      tag_sizes ts = parseTagTriple(&token);
+
+      if (ts.num_ints < 0) {
+        ts.num_ints = 0;
+      }
+      if (ts.num_ints > max_tag_nums) {
+        ts.num_ints = max_tag_nums;
+      }
+
+      if (ts.num_reals < 0) {
+        ts.num_reals = 0;
+      }
+      if (ts.num_reals > max_tag_nums) {
+        ts.num_reals = max_tag_nums;
+      }
+
+      if (ts.num_strings < 0) {
+        ts.num_strings = 0;
+      }
+      if (ts.num_strings > max_tag_nums) {
+        ts.num_strings = max_tag_nums;
+      }
+
+      tag.intValues.resize(static_cast<size_t>(ts.num_ints));
+
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_ints); ++i) {
+        tag.intValues[i] = parseInt(&token);
+      }
+
+      tag.floatValues.resize(static_cast<size_t>(ts.num_reals));
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_reals); ++i) {
+        tag.floatValues[i] = parseReal(&token);
+      }
+
+      tag.stringValues.resize(static_cast<size_t>(ts.num_strings));
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) {
+        tag.stringValues[i] = parseString(&token);
+      }
+
+      tags.push_back(tag);
+
+      continue;
+    }
+
+    if (token[0] == 's' && IS_SPACE(token[1])) {
+      // smoothing group id
+      token += 2;
+
+      // skip space.
+      token += strspn(token, " \t");  // skip space
+
+      if (token[0] == '\0') {
+        continue;
+      }
+
+      if (token[0] == '\r' || token[1] == '\n') {
+        continue;
+      }
+
+      if (strlen(token) >= 3) {
+        if (token[0] == 'o' && token[1] == 'f' && token[2] == 'f') {
+          current_smoothing_id = 0;
+        }
+      } else {
+        // assume number
+        int smGroupId = parseInt(&token);
+        if (smGroupId < 0) {
+          // parse error. force set to 0.
+          // FIXME(syoyo): Report warning.
+          current_smoothing_id = 0;
+        } else {
+          current_smoothing_id = static_cast<unsigned int>(smGroupId);
+        }
+      }
+
+      continue;
+    }  // smoothing group id
+
+    // Ignore unknown command.
+  }
+
+  // not all vertices have colors, no default colors desired? -> clear colors
+  if (!found_all_colors && !default_vcols_fallback) {
+    vc.clear();
+  }
+
+  if (greatest_v_idx >= static_cast<int>(v.size() / 3)) {
+    if (warn) {
+      std::stringstream ss;
+      ss << "Vertex indices out of bounds (line " << line_num << ".)\n" << std::endl;
+      (*warn) += ss.str();
+    }
+  }
+  if (greatest_vn_idx >= static_cast<int>(vn.size() / 3)) {
+    if (warn) {
+      std::stringstream ss;
+      ss << "Vertex normal indices out of bounds (line " << line_num << ".)\n" << std::endl;
+      (*warn) += ss.str();
+    }
+  }
+  if (greatest_vt_idx >= static_cast<int>(vt.size() / 2)) {
+    if (warn) {
+      std::stringstream ss;
+      ss << "Vertex texcoord indices out of bounds (line " << line_num << ".)\n" << std::endl;
+      (*warn) += ss.str();
+    }
+  }
+
+  bool ret = exportGroupsToShape(&shape, faceGroup, lineGroup, tags, material,
+                                 name, triangulate, v);
+  // exportGroupsToShape return false when `usemtl` is called in the last
+  // line.
+  // we also add `shape` to `shapes` when `shape.mesh` has already some
+  // faces(indices)
+  if (ret || shape.mesh.indices.size()) {
+    shapes->push_back(shape);
+  }
+  faceGroup.clear();  // for safety
+
+  if (err) {
+    (*err) += errss.str();
+  }
+
+  attrib->vertices.swap(v);
+  attrib->normals.swap(vn);
+  attrib->texcoords.swap(vt);
+  attrib->colors.swap(vc);
+
+  return true;
+}
+
+bool LoadObjWithCallback(std::istream &inStream, const callback_t &callback,
+                         void *user_data /*= NULL*/,
+                         MaterialReader *readMatFn /*= NULL*/,
+                         std::string *warn, /* = NULL*/
+                         std::string *err /*= NULL*/) {
+  std::stringstream errss;
+
+  // material
+  std::map<std::string, int> material_map;
+  int material_id = -1;  // -1 = invalid
+
+  std::vector<index_t> indices;
+  std::vector<material_t> materials;
+  std::vector<std::string> names;
+  names.reserve(2);
+  std::vector<const char *> names_out;
+
+  std::string linebuf;
+  while (inStream.peek() != -1) {
+    safeGetline(inStream, linebuf);
+
+    // Trim newline '\r\n' or '\n'
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\n')
+        linebuf.erase(linebuf.size() - 1);
+    }
+    if (linebuf.size() > 0) {
+      if (linebuf[linebuf.size() - 1] == '\r')
+        linebuf.erase(linebuf.size() - 1);
+    }
+
+    // Skip if empty line.
+    if (linebuf.empty()) {
+      continue;
+    }
+
+    // Skip leading space.
+    const char *token = linebuf.c_str();
+    token += strspn(token, " \t");
+
+    assert(token);
+    if (token[0] == '\0') continue;  // empty line
+
+    if (token[0] == '#') continue;  // comment line
+
+    // vertex
+    if (token[0] == 'v' && IS_SPACE((token[1]))) {
+      token += 2;
+      // TODO(syoyo): Support parsing vertex color extension.
+      real_t x, y, z, w;  // w is optional. default = 1.0
+      parseV(&x, &y, &z, &w, &token);
+      if (callback.vertex_cb) {
+        callback.vertex_cb(user_data, x, y, z, w);
+      }
+      continue;
+    }
+
+    // normal
+    if (token[0] == 'v' && token[1] == 'n' && IS_SPACE((token[2]))) {
+      token += 3;
+      real_t x, y, z;
+      parseReal3(&x, &y, &z, &token);
+      if (callback.normal_cb) {
+        callback.normal_cb(user_data, x, y, z);
+      }
+      continue;
+    }
+
+    // texcoord
+    if (token[0] == 'v' && token[1] == 't' && IS_SPACE((token[2]))) {
+      token += 3;
+      real_t x, y, z;  // y and z are optional. default = 0.0
+      parseReal3(&x, &y, &z, &token);
+      if (callback.texcoord_cb) {
+        callback.texcoord_cb(user_data, x, y, z);
+      }
+      continue;
+    }
+
+    // face
+    if (token[0] == 'f' && IS_SPACE((token[1]))) {
+      token += 2;
+      token += strspn(token, " \t");
+
+      indices.clear();
+      while (!IS_NEW_LINE(token[0])) {
+        vertex_index_t vi = parseRawTriple(&token);
+
+        index_t idx;
+        idx.vertex_index = vi.v_idx;
+        idx.normal_index = vi.vn_idx;
+        idx.texcoord_index = vi.vt_idx;
+
+        indices.push_back(idx);
+        size_t n = strspn(token, " \t\r");
+        token += n;
+      }
+
+      if (callback.index_cb && indices.size() > 0) {
+        callback.index_cb(user_data, &indices.at(0),
+                          static_cast<int>(indices.size()));
+      }
+
+      continue;
+    }
+
+    // use mtl
+    if ((0 == strncmp(token, "usemtl", 6)) && IS_SPACE((token[6]))) {
+      token += 7;
+      std::stringstream ss;
+      ss << token;
+      std::string namebuf = ss.str();
+
+      int newMaterialId = -1;
+      if (material_map.find(namebuf) != material_map.end()) {
+        newMaterialId = material_map[namebuf];
+      } else {
+        // { error!! material not found }
+      }
+
+      if (newMaterialId != material_id) {
+        material_id = newMaterialId;
+      }
+
+      if (callback.usemtl_cb) {
+        callback.usemtl_cb(user_data, namebuf.c_str(), material_id);
+      }
+
+      continue;
+    }
+
+    // load mtl
+    if ((0 == strncmp(token, "mtllib", 6)) && IS_SPACE((token[6]))) {
+      if (readMatFn) {
+        token += 7;
+
+        std::vector<std::string> filenames;
+        SplitString(std::string(token), ' ', filenames);
+
+        if (filenames.empty()) {
+          if (warn) {
+            (*warn) +=
+                "Looks like empty filename for mtllib. Use default "
+                "material. \n";
+          }
+        } else {
+          bool found = false;
+          for (size_t s = 0; s < filenames.size(); s++) {
+            std::string warn_mtl;
+            std::string err_mtl;
+            bool ok = (*readMatFn)(filenames[s].c_str(), &materials,
+                                   &material_map, &warn_mtl, &err_mtl);
+
+            if (warn && (!warn_mtl.empty())) {
+              (*warn) += warn_mtl;  // This should be warn message.
+            }
+
+            if (err && (!err_mtl.empty())) {
+              (*err) += err_mtl;
+            }
+
+            if (ok) {
+              found = true;
+              break;
+            }
+          }
+
+          if (!found) {
+            if (warn) {
+              (*warn) +=
+                  "Failed to load material file(s). Use default "
+                  "material.\n";
+            }
+          } else {
+            if (callback.mtllib_cb) {
+              callback.mtllib_cb(user_data, &materials.at(0),
+                                 static_cast<int>(materials.size()));
+            }
+          }
+        }
+      }
+
+      continue;
+    }
+
+    // group name
+    if (token[0] == 'g' && IS_SPACE((token[1]))) {
+      names.clear();
+
+      while (!IS_NEW_LINE(token[0])) {
+        std::string str = parseString(&token);
+        names.push_back(str);
+        token += strspn(token, " \t\r");  // skip tag
+      }
+
+      assert(names.size() > 0);
+
+      if (callback.group_cb) {
+        if (names.size() > 1) {
+          // create const char* array.
+          names_out.resize(names.size() - 1);
+          for (size_t j = 0; j < names_out.size(); j++) {
+            names_out[j] = names[j + 1].c_str();
+          }
+          callback.group_cb(user_data, &names_out.at(0),
+                            static_cast<int>(names_out.size()));
+
+        } else {
+          callback.group_cb(user_data, NULL, 0);
+        }
+      }
+
+      continue;
+    }
+
+    // object name
+    if (token[0] == 'o' && IS_SPACE((token[1]))) {
+      // @todo { multiple object name? }
+      token += 2;
+
+      std::stringstream ss;
+      ss << token;
+      std::string object_name = ss.str();
+
+      if (callback.object_cb) {
+        callback.object_cb(user_data, object_name.c_str());
+      }
+
+      continue;
+    }
+
+#if 0  // @todo
+    if (token[0] == 't' && IS_SPACE(token[1])) {
+      tag_t tag;
+
+      token += 2;
+      std::stringstream ss;
+      ss << token;
+      tag.name = ss.str();
+
+      token += tag.name.size() + 1;
+
+      tag_sizes ts = parseTagTriple(&token);
+
+      tag.intValues.resize(static_cast<size_t>(ts.num_ints));
+
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_ints); ++i) {
+        tag.intValues[i] = atoi(token);
+        token += strcspn(token, "/ \t\r") + 1;
+      }
+
+      tag.floatValues.resize(static_cast<size_t>(ts.num_reals));
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_reals); ++i) {
+        tag.floatValues[i] = parseReal(&token);
+        token += strcspn(token, "/ \t\r") + 1;
+      }
+
+      tag.stringValues.resize(static_cast<size_t>(ts.num_strings));
+      for (size_t i = 0; i < static_cast<size_t>(ts.num_strings); ++i) {
+        std::stringstream ss;
+        ss << token;
+        tag.stringValues[i] = ss.str();
+        token += tag.stringValues[i].size() + 1;
+      }
+
+      tags.push_back(tag);
+    }
+#endif
+
+    // Ignore unknown command.
+  }
+
+  if (err) {
+    (*err) += errss.str();
+  }
+
+  return true;
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}  // namespace tinyobj
+
+#endif

third-party/DPVO/Pangolin/components/tinyobj/src/tinyobj.cpp

@@ -0,0 +1,29 @@
+/* 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.
+ */
+
+#define TINYOBJLOADER_IMPLEMENTATION
+#include <tinyobj/tiny_obj_loader.h>

third-party/DPVO/Pangolin/examples/BasicOpenGL/1_gl_intro_classic_triangle.cpp

@@ -0,0 +1,57 @@
+#include <pangolin/display/display.h>
+#include <pangolin/gl/gl.h>
+
+void sample()
+{
+    // Create a 500x500 pixel application window with an OpenGL Context
+    // By default the window is double buffered if available.
+    // Load any available OpenGL Extensions (through GLEW)
+    pangolin::CreateWindowAndBind("Classic GL Triangle", 500, 500);
+
+    // List coordinates of a triangle
+    // These vertices will be relative to the coordinates of the window
+    // which default in OpenGL to +/- 1.0 in X and Y (first two vertex ordinates)
+    const float vertices[] = {
+        -0.5f, -0.5f, 0.0f,
+         0.5f, -0.5f, 0.0f,
+         0.0f,  0.5f, 0.0f
+    };
+
+    // We want the background to be purple
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    // We want our triangle to be a pleasant shade of blue!
+    glColor3f(0.29f, 0.71f, 1.0f);
+
+    // We keep rendering in a loop so that the triangle will keep showing
+    // and get adjusted as the window is resized. Press Escape or close the
+    // window to exit the Pangolin loop.
+    while( !pangolin::ShouldQuit() )
+    {
+        // Clear the window
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // This buffer contains floating point vertices with 3 dimensions.
+        // They starts from the 0th element and are packed without padding.
+        glVertexPointer(3, GL_FLOAT, 0, vertices);
+
+        // Use Them!
+        glEnableClientState(GL_VERTEX_ARRAY);
+
+        // Connect the first 3 of these vertices to form a triangle!
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+
+        // Disable the stuff we enabled...
+        glDisableClientState(GL_VERTEX_ARRAY);
+
+        // Process any windowing events and swap the back and front
+        // OpenGL buffers if available.
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/1_gl_intro_pango_triangle.cpp

@@ -0,0 +1,48 @@
+#include <pangolin/display/display.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/gldraw.h>
+
+void sample()
+{
+    // Create a 500x500 pixel application window with an OpenGL Context
+    // By default the window is double buffered if available.
+    // Load any available OpenGL Extensions (through GLEW)
+    pangolin::CreateWindowAndBind("Pango GL Triangle", 500, 500);
+
+    // List coordinates of a triangle
+    // These vertices will be relative to the coordinates of the window
+    // which default in OpenGL to +/- 1.0 in X and Y (first two vertex ordinates)
+    std::vector<Eigen::Vector3f> vertices = {
+        {-0.5f, -0.5f, 0.0f},
+        {0.5f, -0.5f, 0.0f },
+        {0.0f,  0.5f, 0.0f }
+    };
+
+    // We want the background to be purple
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    // We want our triangle to be a pleasant shade of blue!
+    glColor3f(0.29f, 0.71f, 1.0f);
+
+    // We keep rendering in a loop so that the triangle will keep showing
+    // and get adjusted as the window is resized. Press Escape or close the
+    // window to exit the Pangolin loop.
+    while( !pangolin::ShouldQuit() )
+    {
+        // Clear the window
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Connect the first 3  vertices to form a triangle!
+        pangolin::glDrawVertices(vertices, GL_TRIANGLES);
+
+        // Process any windowing events and swap the back and front
+        // OpenGL buffers if available.
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/2_gl_intro_classic_triangle_vbo.cpp

@@ -0,0 +1,62 @@
+#include <pangolin/display/display.h>
+
+// Here is an example of Pangolin being used *just* for windowing.
+// We're using
+void sample()
+{
+    pangolin::CreateWindowAndBind("Classic GL Triangle with VBO", 500, 500);
+
+    // List coordinates of a triangle
+    const float vertices[] = {
+        -0.5f, -0.5f, 0.0f,
+         0.5f, -0.5f, 0.0f,
+         0.0f,  0.5f, 0.0f
+    };
+
+    // Create an OpenGL Buffer to store these coordinates
+    unsigned int VBO;
+    glGenBuffers(1, &VBO);
+
+    // Set that buffer as the current GL buffer
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+    // Copy our host data into the currently bound OpenGL buffer
+    // GL_STATIC_DRAW is a hint about how we'll use the buffer
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+    glColor3f(0.29f, 0.71f, 1.0f);
+
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Set our buffer as the current one for OpenGL
+        glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+        // This buffer contains floating point vertices with 3 dimensions.
+        // They starts from the 0th element and are packed without padding.
+        glVertexPointer(3, GL_FLOAT, 0, 0);
+
+        // Use Them!
+        glEnableClientState(GL_VERTEX_ARRAY);
+
+        // Connect the first 3 of these vertices to form a triangle!
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+
+        // Disable the stuff we enabled...
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+        pangolin::FinishFrame();
+    }
+
+    // Deallocate the OpenGL buffer we made
+    glDeleteBuffers(1, &VBO);
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/2_gl_intro_pango_triangle_vbo.cpp

@@ -0,0 +1,35 @@
+#include <pangolin/display/display.h>
+#include <pangolin/gl/glvbo.h>
+
+void sample()
+{
+    pangolin::CreateWindowAndBind("Pango GL Triangle with VBO", 500, 500);
+
+    // Create an OpenGL Buffer containing the vertices of a triangle
+    pangolin::GlBuffer vbo(pangolin::GlArrayBuffer,
+        std::vector<Eigen::Vector3f>{
+           {-0.5f, -0.5f, 0.0f},
+           { 0.5f, -0.5f, 0.0f },
+           { 0.0f,  0.5f, 0.0f }
+        }
+    );
+
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+    glColor3f(0.29f, 0.71f, 1.0f);
+
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Connect the first 3 vertices in the GL Buffer to form a triangle!
+        pangolin::RenderVbo(vbo, GL_TRIANGLES);
+
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/3_gl_intro_classic_triangle_vbo_shader.cpp

@@ -0,0 +1,155 @@
+#include <pangolin/display/display.h>
+
+const char* vertex_shader = R"Shader(
+#version 120
+attribute vec3 a_position;
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = vec4(a_position, 1.0);
+    v_pos = a_position.xy;
+}
+)Shader";
+
+const char* fragment_shader = R"Shader(
+#version 120
+varying vec2 v_pos;
+uniform float u_time;
+
+vec3 colorA = vec3(0.905,0.045,0.045);
+vec3 colorB = vec3(0.995,0.705,0.051);
+
+void main() {
+    float pattern = sin(10*v_pos.y + u_time) * sin(10*v_pos.x + u_time) * 0.5 + 0.5;
+    vec3 color = mix(colorA, colorB, pattern);
+    gl_FragColor = vec4(color, 1.0);
+}
+)Shader";
+
+// Here is an example of Pangolin being used *just* for windowing.
+// Influenced by https://learnopengl.com/Getting-started/Hello-Triangle
+void sample()
+{
+    pangolin::CreateWindowAndBind("Classic GL Triangle With VBO and Shader", 500, 500);
+
+    // Build and compile our shader program
+    // ------------------------------------
+
+    // Create a vertex shader GL object
+    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
+
+    // Tell GL the source code to use
+    glShaderSource(vertexShader, 1, &vertex_shader, NULL);
+
+    // Actually compile the program
+    glCompileShader(vertexShader);
+
+    // Check if the compilation was successfull, and print anyn errors
+    int success;
+    char infoLog[512];
+    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
+    if (!success)
+    {
+        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
+        std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
+    }
+
+    // Repeat for the Fragment shader
+    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragmentShader, 1, &fragment_shader, NULL);
+    glCompileShader(fragmentShader);
+    // check for shader compile errors
+    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
+    if (!success)
+    {
+        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
+        std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl;
+    }
+
+    // Link the vertex and fragment shaders into one complete program
+    unsigned int shaderProgram = glCreateProgram();
+    glAttachShader(shaderProgram, vertexShader);
+    glAttachShader(shaderProgram, fragmentShader);
+    glLinkProgram(shaderProgram);
+
+    // Check for linking errors
+    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
+    if (!success) {
+        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
+        std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+    }
+
+    // Delete the now unused shader objects
+    glDeleteShader(vertexShader);
+    glDeleteShader(fragmentShader);
+
+    // Setup the Triangle VBO
+    // ------------------------------------
+
+    // List coordinates of a triangle
+    const float vertices[] = {
+        -0.5f, -0.5f, 0.0f,
+         0.5f, -0.5f, 0.0f,
+         0.0f,  0.5f, 0.0f
+    };
+
+    // Create an OpenGL Buffer to store these coordinates
+    unsigned int VBO;
+    glGenBuffers(1, &VBO);
+
+    // Set that buffer as the current GL buffer
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+    // Copy our host data into the currently bound OpenGL buffer
+    // GL_STATIC_DRAW is a hint about how we'll use the buffer
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    // Enable use of the shader that we created for future rendering commands
+    glUseProgram(shaderProgram);
+
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    // Setup a variable to progress a simple animation as a function of time
+    float time = 0.01f;
+
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Set our buffer as the current one for OpenGL
+        glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+        // This buffer contains floating point vertices with 3 dimensions.
+        // They starts from the 0th element and are packed without padding.
+        glVertexPointer(3, GL_FLOAT, 0, 0);
+
+        // Use Them!
+        glEnableClientState(GL_VERTEX_ARRAY);
+
+        GLint u_time = glGetUniformLocation(shaderProgram, "u_time");
+        glUniform1f( u_time, time);
+
+        // Connect the first 3 of these vertices to form a triangle!
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+
+        // Disable the stuff we enabled...
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+        time += 0.01;
+
+        pangolin::FinishFrame();
+    }
+
+    // Deallocate the OpenGL buffer we made
+    glDeleteBuffers(1, &VBO);
+
+    // Deallocate the GlSl Shader program
+    glDeleteProgram(shaderProgram);
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/3_gl_intro_pango_triangle_vbo_shader.cpp

@@ -0,0 +1,75 @@
+#include <pangolin/display/display.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/gl/glvbo.h>
+#include <pangolin/gl/glsl.h>
+
+const std::string my_shader = R"Shader(
+@start vertex
+#version 120
+attribute vec3 a_position;
+varying vec2 v_pos;
+
+void main() {
+    gl_Position = vec4(a_position, 1.0);
+    v_pos = a_position.xy;
+}
+
+@start fragment
+#version 120
+varying vec2 v_pos;
+uniform float u_time;
+
+vec3 colorA = vec3(0.905,0.045,0.045);
+vec3 colorB = vec3(0.995,0.705,0.051);
+
+void main() {
+    float pattern = sin(10*v_pos.y + u_time) * sin(10*v_pos.x + u_time) * 0.5 + 0.5;
+    vec3 color = mix(colorA, colorB, pattern);
+    gl_FragColor = vec4(color, 1.0);
+}
+)Shader";
+
+void sample()
+{
+    pangolin::CreateWindowAndBind("Pango GL Triangle With VBO and Shader", 500, 500);
+
+    pangolin::GlBuffer vbo(pangolin::GlArrayBuffer,
+        std::vector<Eigen::Vector3f>{
+           {-0.5f, -0.5f, 0.0f},
+           { 0.5f, -0.5f, 0.0f },
+           { 0.0f,  0.5f, 0.0f }
+        }
+    );
+
+    // Encapsulate a GlSl shader program to define how to render OpenGL primitives
+    // The Pangolin GlSlProgram has a preprocessor which can seperate different kinds of
+    // shaders and manage compile-time defines.
+    pangolin::GlSlProgram prog;
+    prog.AddShader( pangolin::GlSlAnnotatedShader, my_shader );
+    prog.Link();
+    prog.Bind();
+
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    // Setup a variable to progress a simple animation as a function of time
+    float time = 0.01f;
+
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Update the shader u_time parameter and render the triangles
+        // whilst this shader is active
+        prog.SetUniform("u_time", time);
+        pangolin::RenderVbo(vbo, GL_TRIANGLES);
+        time += 0.01;
+
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/4_gl_intro_viewport.cpp

@@ -0,0 +1,79 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/gl/glvbo.h>
+
+void sample()
+{
+    pangolin::CreateWindowAndBind("Pango GL Triangle with VBO", 1000, 500);
+
+    // A pangolin::View is an object oriented encapsulation of a glViewport.
+    // It describes which rectangle of pixels in the window map to the OpenGL
+    // Normalized Device Coordinates (NDC) for rendering.
+    // See https://www.songho.ca/opengl/gl_transform.html for technical description
+    // of OpenGL coordinate systems and transforms.
+
+    // The View::SetBounds() method accepts the bottom, top, left, right arguments
+    // which correspond to the vertical min/max and horizontal min/max locations.
+    // Units can be fractional [0,1] representing bottom/left of window to top/right.
+    // You can use pangolin::Attach::Pix() to specify an absolute pixel coordinate
+    // relative to the bottom or left edge instead of a fractional one.
+    // pangolin::Attach::ReversePix() is instead relative to the top or right edge.
+    //
+    // A View is parented to the main window (pangolin::DisplayBase()) by default,
+    // but that can be changed with the View::AddDisplay() method to re-child to any
+    // other View. The specified bounds are relative to the parent and will
+    // be recalculated automatically during resize events.
+
+    // Create two 'views' representing the left and right half of the window.
+    auto& view1 = pangolin::CreateDisplay().SetBounds(0.0, 1.0, 0.0, 0.5);
+    auto& view2 = pangolin::CreateDisplay().SetBounds(0.0, 1.0, 0.5, 1.0);
+
+    // Create an OpenGL Buffer containing the vertices of a triangle
+    pangolin::GlBuffer vertices(pangolin::GlArrayBuffer,
+        std::vector<Eigen::Vector3f>{
+           {-0.5f, -0.5f, 0.0f},
+           { 0.5f, -0.5f, 0.0f },
+           { 0.0f,  0.5f, 0.0f }
+        }
+    );
+
+    // Set the background color
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Views also maintain their expected visibility, but since we're doing our own
+        // rendering inside the view we need to check this manually before drawing.
+        if(view1.IsShown()) {
+            // 'Activating()' a view will use the calculated absolute pixel
+            // positions and pass them on to glViewport to describe where
+            // to render on the screen.
+            view1.Activate();
+
+            // Render a blue triangle
+            glColor3f(0.29f, 0.71f, 1.0f);
+            pangolin::RenderVbo(vertices, GL_TRIANGLES);
+        }
+
+        if(view2.IsShown()) {
+            view2.Activate();
+
+            // Render a green triangle
+            glColor3f(0.71f, 1.0f, 0.29f);
+            pangolin::RenderVbo(vertices, GL_TRIANGLES);
+        }
+
+        // FinishFrame processes any pending windowing events such as
+        // mouse clicks and resizes. Resizes will trigger View absolute
+        // bounds recalculations.
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/5_gl_intro_view_transforms.cpp

@@ -0,0 +1,98 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/gl/gldraw.h>
+
+// Please read the following fantastic resource on the
+// OpenGL Transformation pipeline:
+// http://www.songho.ca/opengl/gl_transform.html
+//
+// In order to manipulate the position of objects within a scene and the
+// position and projection action of a virtual OpenGL camera, we must
+// understand the distinct set of coordinate systems that OpenGL uses.
+// The Terminology for OpenGL, DirectX, Computer Vision and Robotics Literature
+// are all a bit different but the concepts remain the same.
+
+void sample()
+{
+    // Define the core parameters of a virtual OpenGL Camera which we will use
+    // to show a simple scene. These quantities are best thought of as analogous
+    // to the backplane dimensions and focal length (all in the same unit, say mm)
+    // of a virtual pinhole camera (i.e. a camera with no lens and just a pinhole
+    // apperture).
+    const int gl_camera_width = 100;
+    const int gl_camera_height = 100;
+    const double gl_camera_focal_length = 100.0;
+
+    // Create an application window of arbitrary dimensions
+    pangolin::CreateWindowAndBind("Pango GL Triangle with VBO", 1024, 768);
+
+    // Create a child view within the parent window which will stretch and grow
+    // with the application window but maintain a fixed aspect of width to height
+    // that will match the virtual camera we wish to render with respect to.
+    auto& view = pangolin::CreateDisplay()
+                    .SetAspect( (float)gl_camera_width / (float)gl_camera_height);
+
+    pangolin::OpenGlRenderState render_transforms(
+        // The OpenGL Projection Matrix handles the transform from
+        // Camera coordinates into Normalized Device Coordinates (within the Viewport)
+        // It can be used to specify the action of the virtual OpenGL Camera
+        pangolin::ProjectionMatrix(
+            gl_camera_width, gl_camera_height,
+            gl_camera_focal_length, gl_camera_focal_length,
+            gl_camera_width/2.0, gl_camera_height/2.0,
+            0.01,  // 'Near clipping plane' - The closest and furthest thing we can render
+            100.0  // 'Far clipping plane'    in scene units. Required when rasterizing
+                   //                         due to finite numerical precision.
+        ),
+        // The OpenGL ModelView Matrix handles the transform from
+        // Object coordinates into Camera Coordinates. It is useful when
+        // vertices and renderable objects are specified in a fixed
+        // 'object centric' coordinate system but we want to transform
+        // how the object appears to move relative to the camera.
+        pangolin::ModelViewLookAt(
+            2.0, 2.0, 2.0, // coordinates of center of camera
+            0.0, 0.0, 0.0, // coordinates to point camera towards
+            pangolin::AxisY // The 'up' axis for the camera
+        )
+    );
+
+    // We explicitly tell GL to only 'paint' pixels if they are in-front
+    // of what is already in the framebuffer. Try turning this off and see
+    // what happens!
+    glEnable(GL_DEPTH_TEST);
+
+    // Set the background color set during the glClear operation below.
+    glClearColor(0.64f, 0.5f, 0.81f, 0.0f);
+
+    for( double time=0.0; !pangolin::ShouldQuit(); time += 0.01 )
+    {
+        // Clear both the color buffer but also the depth buffer.
+        // Try just clearing the color buffer and see what happens!
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Set the camera position as a function of time.
+        // Here we use a circular orbit in XZ Plane.
+        render_transforms.SetModelViewMatrix(
+            pangolin::ModelViewLookAt(
+                2.0*sin(time), 2.0, 2.0*cos(time),
+                0.0, 0.0, 0.0,
+                pangolin::AxisY
+            )
+        );
+
+        if(view.IsShown()) {
+            view.Activate(render_transforms);
+            render_transforms.Apply();
+            pangolin::glDrawColouredCube();
+        }
+
+        pangolin::FinishFrame();
+    }
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    sample();
+    return 0;
+}

third-party/DPVO/Pangolin/examples/BasicOpenGL/CMakeLists.txt

@@ -0,0 +1,22 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+set(sample_srcs
+    1_gl_intro_classic_triangle.cpp
+    1_gl_intro_pango_triangle.cpp
+    2_gl_intro_classic_triangle_vbo.cpp
+    2_gl_intro_pango_triangle_vbo.cpp
+    3_gl_intro_classic_triangle_vbo_shader.cpp
+    3_gl_intro_pango_triangle_vbo_shader.cpp
+    4_gl_intro_viewport.cpp
+    5_gl_intro_view_transforms.cpp
+)
+
+foreach( sample_src ${sample_srcs})
+    get_filename_component(sample_name ${sample_src} NAME_WE)
+    set(target_name "tutorial_${sample_name}")
+    add_executable(${target_name} ${sample_src})
+    target_link_libraries(${target_name} pango_display)
+endforeach()
+

third-party/DPVO/Pangolin/examples/BasicOpenGL/README.md

@@ -0,0 +1,39 @@
+# Basic OpenGL Tutorial with Pangolin
+
+By popular request, here is a set of basic OpenGL intros for people wanting to get going quickly with Pangolin.
+
+#### gl_intro_triangle
+
+Drawing a triangle is the *HelloWorld* of OpenGL and a good place for us to start. 
+
+`1_gl_intro_classic_triangle.cpp`: In the **classic** version, Pangolin's main use is creating a window and OpenGL context that we can use without platform specific code. [GLFW](https://www.glfw.org/) would be a good alternative if this is your only aim. Notice drawing the triangle takes 3 function calls and there is a matched Enable... / Disable... call that we must take care to pair.
+
+`1_gl_intro_pango_triangle.cpp`: This is the **pango** version where we make use of a simple utilitiy method to accomplish the same as before. Not much to write home about, but you can see the general ethos of Pangolin is to reduce OpenGL boilerplate without getting too fancy.
+
+
+
+#### gl_intro_triangle_vbo
+
+`2_gl_intro_classic_triangle_vbo.cpp`: In the previous example, the vertices of the triangle live in your machines main memory. Your poor graphics card is being drip fed the vertices each time the image is redrawn every frame. This VBO (Vertex Buffer Object) example instead copies the vertex data to your GPU's memory once, and then only references it later. Your graphics card then gets to keep it handy (in probably faster memory) without repeated transfers over a shared bus. The **classic** version uses only the regular OpenGL API. You'll notice it is a C API, and we're notably missing C++ idioms like [RAII](https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization) to make sure we don't leak resources such as the VBO buffer.
+
+`2_gl_intro_pango_triangle_vbo.cpp`: The **pango** version gets a bit more compact where we make use of the `pangolin::GlBuffer` wrapper to manage the GL object lifetime.
+
+
+
+#### gl_intro_triangle_vbo_shader
+
+`3_gl_intro_classic_triangle_vbo_shader.cpp`: Okay, so I lied - people don't really recommend using the 'fixed pipeline' for rendering stuff in OpenGL anymore - you're meant to use *GLSL shaders*, code that can run on your graphics hardware to more explicitly outline how you want things to appear. Most of what we had before was fine, but `glColor3f` is normally replaced by shader output, plus a bunch of other stuff that we've not introduced anyway, so don't panic. Personally, the **classic** version gives me shudders - just look at all the boilerplate! 
+
+`3_gl_intro_pango_triangle_vbo_shader.cpp`: The **pango** version shows how to use some of its C++ wrappers that you'll hopefully agree improve readability. Pangolin also has a few utilities to help with writing shaders, most notable here for those familiar with GLSL is Pangolins preprocessor which allows you to `#include`, `#expect` and `#define` things, as well as load multiple shaders from one file with the `@start` annotations.
+
+
+
+#### gl_intro_viewport
+
+Okay, I've finished trying to outline how much boilerplate is needed with the regular OpenGL API. Here is a simple intro on how to use Pangolin to organize sub-views of the main window. Pangolin will take care of resizing these views as the window is resized which you would otherwise do manually. Notice we've ditched the shaders again because unless you really care about performance, I wont tell people you're using the deprecated pipeline if you dont. It's really your choice - you can use Pangolin or not either way.
+
+
+
+#### gl_intro_view_transforms
+
+In this example we've moved from Flatland into 3D! Doing so requires us to get acquinted with a few important transforms that map from different coordinate systems. In the previous examples, our trusty triangle was getting defined on the XY plane within a box from bottom-left (-1.0,-1.0) to top-right (1.0,1.0) which is then mapped to pixels by the specified viewport. This coordinate system is called *normalized device coordinates*, so named because it is independent of final render resolution but represents the final 2D mapping of render primitives. There are some other important coordinate systems in OpenGL (namely clip coordinates), but what really matters is that whatever coordinate system we care about can somehow get converted into one OpenGL cares about. For this, we talk about coordinate transforms! To make like easy, we try to use linear transforms. Since perspective projection isn't linear, we use homogeneous coordinates to cheat. OpenGL's *fixed pipeline* has several built-in capabilities for working with these 4x4 homogeneous transforms, but the modern OpenGL way is to handle all that stuff ourselves. I'd recommend learning a bit more from the excellent resource [songho](https://www.songho.ca/opengl/gl_transform.html), but you can probably pick up a lot as a practitioner from the code.

third-party/DPVO/Pangolin/examples/CMakeLists.txt

@@ -0,0 +1,15 @@
+add_subdirectory(BasicOpenGL)
+
+add_subdirectory(HelloPangolin)
+add_subdirectory(HelloPangolinThreads)
+add_subdirectory(SimpleDisplay)
+add_subdirectory(SimpleMultiDisplay)
+add_subdirectory(SimpleDisplayImage)
+add_subdirectory(SimplePlot)
+add_subdirectory(SimpleVideo)
+add_subdirectory(SimpleRecord)
+
+if(NOT EMSCRIPTEN)
+    add_subdirectory(HelloPangolinOffscreen)
+    add_subdirectory(SimpleScene)
+endif()