Support card hotplugging (both add and remove).

[bmusb] / bmusb.h

diff --git a/bmusb.h b/bmusb.h
index bf1f51fb60eb65b77a40d26da003787b88414ded..941c57c27d358ba22f28cb97268f71c475178f9c 100644 (file)
--- a/bmusb.h
+++ b/bmusb.h
@@ -1,6 +1,7 @@
 #ifndef _BMUSB_H
 #define _BMUSB_H
 
+#include <libusb.h>
 #include <stdint.h>
 #include <atomic>
 #include <condition_variable>
@@ -13,8 +14,7 @@
 #include <thread>
 #include <vector>
 
-struct libusb_device_handle;
-struct libusb_transfer;
+class BMUSBCapture;
 
 // An interface for frame allocators; if you do not specify one
 // (using set_video_frame_allocator), a default one that pre-allocates
@@ -111,6 +111,9 @@ typedef std::function<void(uint16_t timecode,
                            FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format)>
        frame_callback_t;
 
+typedef std::function<void(libusb_device *dev)> card_connected_callback_t;
+typedef std::function<void()> card_disconnected_callback_t;
+
 class CaptureInterface {
  public:
        virtual ~CaptureInterface() {}
@@ -150,13 +153,17 @@ class CaptureInterface {
        virtual void start_bm_capture() = 0;
 
        virtual void stop_dequeue_thread() = 0;
+
+       // If a card is disconnected, it cannot come back; you should call stop_dequeue_thread()
+       // and delete it.
+       virtual bool get_disconnected() const = 0;
 };
 
 // The actual capturing class, representing capture from a single card.
 class BMUSBCapture : public CaptureInterface {
  public:
-       BMUSBCapture(int card_index)
-               : card_index(card_index)
+       BMUSBCapture(int card_index, libusb_device *dev = nullptr)
+               : card_index(card_index), dev(dev)
        {
        }
 
@@ -223,11 +230,34 @@ class BMUSBCapture : public CaptureInterface {
        void configure_card() override;
        void start_bm_capture() override;
        void stop_dequeue_thread() override;
+       bool get_disconnected() const override { return disconnected; }
 
        // TODO: It's rather messy to have these outside the interface.
        static void start_bm_thread();
        static void stop_bm_thread();
 
+       // Hotplug event (for devices being inserted between start_bm_thread()
+       // and stop_bm_thread()); entirely optional, but must be set before
+       // start_bm_capture(). Note that your callback should do as little work
+       // as possible, since the callback comes from the main USB handling
+       // thread, which is very time-sensitive.
+       //
+       // The callback function transfers ownership. If you don't want to hold
+       // on to the device given to you in the callback, you need to call
+       // libusb_unref_device().
+       static void set_card_connected_callback(card_connected_callback_t callback)
+       {
+               card_connected_callback = callback;
+       }
+
+       // Similar to set_card_connected_callback(), with the same caveats.
+       // (Note that this is set per-card and not global, as it is logically
+       // connected to an existing BMUSBCapture object.)
+       void set_card_disconnected_callback(card_disconnected_callback_t callback)
+       {
+               card_disconnected_callback = callback;
+       }
+
  private:
        struct QueuedFrame {
                uint16_t timecode;
@@ -243,6 +273,7 @@ class BMUSBCapture : public CaptureInterface {
 
        static void usb_thread_func();
        static void cb_xfr(struct libusb_transfer *xfr);
+       static int cb_hotplug(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data);
 
        void update_capture_mode();
 
@@ -261,6 +292,8 @@ class BMUSBCapture : public CaptureInterface {
        std::unique_ptr<FrameAllocator> owned_video_frame_allocator;
        std::unique_ptr<FrameAllocator> owned_audio_frame_allocator;
        frame_callback_t frame_callback = nullptr;
+       static card_connected_callback_t card_connected_callback;
+       card_disconnected_callback_t card_disconnected_callback = nullptr;
 
        std::thread dequeue_thread;
        std::atomic<bool> dequeue_thread_should_quit;
@@ -273,13 +306,20 @@ class BMUSBCapture : public CaptureInterface {
        static constexpr int NUM_BMUSB_REGISTERS = 60;
        uint8_t register_file[NUM_BMUSB_REGISTERS];
 
-       int card_index;
+       // If <dev> is nullptr, will choose device number <card_index> from the list
+       // of available devices on the system. <dev> is not used after configure_card()
+       // (it will be unref-ed).
+       int card_index = -1;
+       libusb_device *dev = nullptr;
+
        std::vector<libusb_transfer *> iso_xfrs;
        int assumed_frame_width = 1280;
 
        libusb_device_handle *devh = nullptr;
        uint32_t current_video_input = 0x00000000;  // HDMI/SDI.
        uint32_t current_audio_input = 0x00000000;  // Embedded.
+
+       bool disconnected = false;
 };
 
 // Get details for the given video format; returns false if detection was incomplete.