Add another non-interleaved data copy (intended for VA-API MJPEG uploads).

[bmusb] / bmusb / bmusb.h

diff --git a/bmusb/bmusb.h b/bmusb/bmusb.h
index ed106a688e842d99ac631c4539b676a3b19d27d5..a484496bd6be5cd0aa83512258c0e87f75a79978 100644 (file)
--- a/bmusb/bmusb.h
+++ b/bmusb/bmusb.h
@@ -10,6 +10,7 @@
 #include <functional>
 #include <map>
 #include <mutex>
+#include <set>
 #include <stack>
 #include <string>
 #include <thread>
@@ -30,6 +31,7 @@ class FrameAllocator {
        struct Frame {
                uint8_t *data = nullptr;
                uint8_t *data2 = nullptr;  // Only if interleaved == true.
+               uint8_t *data_copy = nullptr;  // Will get a non-interleaved copy if not nullptr.
                size_t len = 0;  // Number of bytes we actually have.
                size_t size = 0;  // Number of bytes we have room for.
                size_t overflow = 0;
@@ -39,6 +41,9 @@ class FrameAllocator {
                // If set to true, every other byte will go to data and to data2.
                // If so, <len> and <size> are still about the number of total bytes
                // so if size == 1024, there's 512 bytes in data and 512 in data2.
+               //
+               // This doesn't really make any sense if you asked for the
+               // 10BitYCbCr pixel format.
                bool interleaved = false;
 
                // At what point this frame was received. Note that this marks the
@@ -122,6 +127,49 @@ struct AudioFormat {
        uint16_t id = 0;  // For debugging/logging only.
        unsigned bits_per_sample = 0;
        unsigned num_channels = 0;
+       unsigned sample_rate = 48000;
+};
+
+enum PixelFormat {
+       // 8-bit 4:2:2 in the standard Cb Y Cr Y order (UYVY).
+       // This is the default.
+       PixelFormat_8BitYCbCr,
+
+       // 10-bit 4:2:2 in v210 order. Six pixels (six Y', three Cb,
+       // three Cr) are packed into four 32-bit little-endian ints
+       // in the following pattern (see e.g. the DeckLink documentation
+       // for reference):
+       //
+       //   A  B   G   R
+       // -----------------
+       //   X Cr0 Y0  Cb0
+       //   X  Y2 Cb2  Y1
+       //   X Cb4 Y3  Cr2
+       //   X  Y5 Cr4  Y4
+       //
+       // If you read in RGB order and ignore the unused top bits,
+       // this is essentially Cb Y Cr Y order, just like UYVY is.
+       //
+       // Note that unlike true v210, there is no guarantee about
+       // 128-byte line alignment (or lack thereof); you should check
+       // the stride member of VideoFormat.
+       PixelFormat_10BitYCbCr,
+
+       // 8-bit 4:4:4:4 BGRA (in that order). bmusb itself doesn't
+       // produce this, but it is useful to represent e.g. synthetic inputs.
+       PixelFormat_8BitBGRA,
+
+       // 8-bit 4:2:0, 4:2:2, 4:4:4 or really anything else, planar
+       // (ie., first all Y', then all Cb, then all Cr). bmusb doesn't
+       // produce this, nor does it specify a mechanism to describe
+       // the precise details of the format.
+       PixelFormat_8BitYCbCrPlanar,
+
+       // These exist only so that the type is guaranteed wide enough
+       // to contain values up to 127. CaptureInterface instances
+       // are free to use them as they see fit for private uses.
+       PixelFormat_Unused100 = 100,
+       PixelFormat_Unused127 = 127
 };
 
 typedef std::function<void(uint16_t timecode,
@@ -140,6 +188,11 @@ class CaptureInterface {
        virtual uint32_t get_current_video_mode() const = 0;
        virtual void set_video_mode(uint32_t video_mode_id) = 0;
 
+       // TODO: Add a way to query this based on mode?
+       virtual std::set<PixelFormat> get_available_pixel_formats() const = 0;
+       virtual void set_pixel_format(PixelFormat pixel_format) = 0;
+       virtual PixelFormat get_current_pixel_format() const = 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;
@@ -191,6 +244,18 @@ class BMUSBCapture : public CaptureInterface {
        // actually opening the card (in configure_card()).
        static unsigned num_cards();
 
+       std::set<PixelFormat> get_available_pixel_formats() const override
+       {
+               return std::set<PixelFormat>{ PixelFormat_8BitYCbCr, PixelFormat_10BitYCbCr };
+       }
+
+       void set_pixel_format(PixelFormat pixel_format) override;
+
+       PixelFormat get_current_pixel_format() const
+       {
+               return current_pixel_format;
+       }
+
        std::map<uint32_t, VideoMode> get_available_video_modes() const override;
        uint32_t get_current_video_mode() const override;
        void set_video_mode(uint32_t video_mode_id) override;
@@ -343,6 +408,7 @@ class BMUSBCapture : public CaptureInterface {
        libusb_device_handle *devh = nullptr;
        uint32_t current_video_input = 0x00000000;  // HDMI/SDI.
        uint32_t current_audio_input = 0x00000000;  // Embedded.
+       PixelFormat current_pixel_format = PixelFormat_8BitYCbCr;
 
        bool disconnected = false;
 };