Allow setting the video and audio inputs runtime.

diff --git a/bmusb.cpp b/bmusb.cpp
index 3d2c9f018488e202dff12e9439ebe8be665fa376..d726f0f747848142a7a1827a758ae7d302c8b12b 100644 (file)
--- a/bmusb.cpp
+++ b/bmusb.cpp
@@ -799,7 +799,7 @@ void BMUSBCapture::configure_card()
                exit(1);
        }
 
-       libusb_device_handle *devh = open_card(card_index, &description);
+       devh = open_card(card_index, &description);
        if (!devh) {
                fprintf(stderr, "Error finding USB device\n");
                exit(1);
@@ -919,6 +919,8 @@ void BMUSBCapture::configure_card()
        //   0x20 - 720p??
        //   0x30 - 576p??
 
+       update_capture_mode();
+
        struct ctrl {
                int endpoint;
                int request;
@@ -929,14 +931,6 @@ void BMUSBCapture::configure_card()
                { LIBUSB_ENDPOINT_IN,  214, 16, 0 },
                { LIBUSB_ENDPOINT_IN,  214,  0, 0 },
 
-               // seems to capture on HDMI, clearing the 0x20000000 bit seems to activate 10-bit
-               // capture (v210).
-               // clearing the 0x08000000 bit seems to change the capture format (other source?)
-               // 0x10000000 = analog audio instead of embedded audio, it seems
-               // 0x3a000000 = component video? (analog audio)
-               // 0x3c000000 = composite video? (analog audio)
-               // 0x3e000000 = s-video? (analog audio)
-               { LIBUSB_ENDPOINT_OUT, 215,  0, 0x29000000 },
                //{ LIBUSB_ENDPOINT_OUT, 215,  0, 0x80000100 },
                //{ LIBUSB_ENDPOINT_OUT, 215,  0, 0x09000000 },
                { LIBUSB_ENDPOINT_OUT, 215, 24, 0x73c60001 },  // latch for frame start?
@@ -1249,3 +1243,49 @@ void BMUSBCapture::set_video_mode(uint32_t video_mode_id)
 {
        assert(video_mode_id == 0);  // Matches get_available_video_modes().
 }
+
+std::map<uint32_t, std::string> BMUSBCapture::get_available_video_inputs() const
+{
+       return {
+               { 0x00000000, "HDMI/SDI" },
+               { 0x02000000, "Component" },
+               { 0x04000000, "Composite" },
+               { 0x06000000, "S-video" }
+       };
+}
+
+void BMUSBCapture::set_video_input(uint32_t video_input_id)
+{
+       assert((video_input_id & ~0x06000000) == 0);
+       current_video_input = video_input_id;
+       update_capture_mode();
+}
+
+std::map<uint32_t, std::string> BMUSBCapture::get_available_audio_inputs() const
+{
+       return {
+               { 0x00000000, "Embedded" },
+               { 0x10000000, "Analog" }
+       };
+}
+
+void BMUSBCapture::set_audio_input(uint32_t audio_input_id)
+{
+       assert((audio_input_id & ~0x10000000) == 0);
+       current_audio_input = audio_input_id;
+       update_capture_mode();
+}
+
+void BMUSBCapture::update_capture_mode()
+{
+       // clearing the 0x20000000 bit seems to activate 10-bit capture (v210).
+       // clearing the 0x08000000 bit seems to change the capture format (other source?)
+       uint32_t mode = htonl(0x29000000 | current_video_input | current_audio_input);
+
+       int rc = libusb_control_transfer(devh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
+               /*request=*/215, /*value=*/0, /*index=*/0, (unsigned char *)&mode, sizeof(mode), /*timeout=*/0);
+       if (rc < 0) {
+               fprintf(stderr, "Error on setting mode: %s\n", libusb_error_name(rc));
+               exit(1);
+       }
+}

diff --git a/bmusb.h b/bmusb.h
index 9ba27bcc111234040d807bbcd0fafbb3f3cd9275..9ee6617a6e7874164a8a53603a47d974acf01694 100644 (file)
--- a/bmusb.h
+++ b/bmusb.h
@@ -13,6 +13,7 @@
 #include <thread>
 #include <vector>
 
+struct libusb_device_handle;
 struct libusb_transfer;
 
 // An interface for frame allocators; if you do not specify one
@@ -117,6 +118,14 @@ class CaptureInterface {
        virtual uint32_t get_current_video_mode() const = 0;
        virtual void set_video_mode(uint32_t video_mode_id) = 0;
 
+       virtual std::map<uint32_t, std::string> get_available_video_inputs() const = 0;
+       virtual void set_video_input(uint32_t video_input_id) = 0;
+       virtual uint32_t get_current_video_input() const = 0;
+
+       virtual std::map<uint32_t, std::string> get_available_audio_inputs() const = 0;
+       virtual void set_audio_input(uint32_t audio_input_id) = 0;
+       virtual uint32_t get_current_audio_input() const = 0;
+
        // Does not take ownership.
        virtual void set_video_frame_allocator(FrameAllocator *allocator) = 0;
 
@@ -156,6 +165,14 @@ class BMUSBCapture : public CaptureInterface {
        uint32_t get_current_video_mode() const override;
        void set_video_mode(uint32_t video_mode_id) override;
 
+       virtual std::map<uint32_t, std::string> get_available_video_inputs() const override;
+       virtual void set_video_input(uint32_t video_input_id) override;
+       virtual uint32_t get_current_video_input() const override { return current_video_input; }
+
+       virtual std::map<uint32_t, std::string> get_available_audio_inputs() const override;
+       virtual void set_audio_input(uint32_t audio_input_id) override;
+       virtual uint32_t get_current_audio_input() const override { return current_audio_input; }
+
        // Does not take ownership.
        void set_video_frame_allocator(FrameAllocator *allocator) override
        {
@@ -220,6 +237,8 @@ class BMUSBCapture : public CaptureInterface {
        static void usb_thread_func();
        static void cb_xfr(struct libusb_transfer *xfr);
 
+       void update_capture_mode();
+
        std::string description;
 
        FrameAllocator::Frame current_video_frame;
@@ -248,6 +267,10 @@ class BMUSBCapture : public CaptureInterface {
        int card_index;
        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.
 };
 
 // Get details for the given video format; returns false if detection was incomplete.