X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bmusb.h;h=9ba27bcc111234040d807bbcd0fafbb3f3cd9275;hb=5b54cc5acb28f5d2071c99ef7a715044aa30f10c;hp=fb6f87135f514158f0fcdcd9bbbd4b5ab24655c5;hpb=cbaa849e8d1cd73fc46ed63dc3146bff92b4a991;p=bmusb diff --git a/bmusb.h b/bmusb.h index fb6f871..9ba27bc 100644 --- a/bmusb.h +++ b/bmusb.h @@ -2,7 +2,18 @@ #define _BMUSB_H #include +#include +#include +#include #include +#include +#include +#include +#include +#include +#include + +struct libusb_transfer; // An interface for frame allocators; if you do not specify one // (using set_video_frame_allocator), a default one that pre-allocates @@ -14,10 +25,17 @@ class FrameAllocator { public: struct Frame { uint8_t *data = nullptr; + uint8_t *data2 = nullptr; // Only if interleaved == true. 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; void *userdata = nullptr; FrameAllocator *owner = nullptr; + + // If set to true, every other byte will go to data and to data2. + // If so, and are still about the number of total bytes + // so if size == 1024, there's 512 bytes in data and 512 in data2. + bool interleaved = false; }; virtual ~FrameAllocator(); @@ -41,19 +59,202 @@ class FrameAllocator { virtual void release_frame(Frame frame) = 0; }; +// Audio is more important than video, and also much cheaper. +// By having many more audio frames available, hopefully if something +// starts to drop, we'll have CPU load go down (from not having to +// process as much video) before we have to drop audio. +#define NUM_QUEUED_VIDEO_FRAMES 16 +#define NUM_QUEUED_AUDIO_FRAMES 64 + +class MallocFrameAllocator : public FrameAllocator { +public: + MallocFrameAllocator(size_t frame_size, size_t num_queued_frames); + Frame alloc_frame() override; + void release_frame(Frame frame) override; + +private: + size_t frame_size; + + std::mutex freelist_mutex; + std::stack> freelist; // All of size . +}; + +// Represents an input mode you can tune a card to. +struct VideoMode { + std::string name; + bool autodetect = false; // If true, all the remaining fields are irrelevant. + unsigned width = 0, height = 0; + unsigned frame_rate_num = 0, frame_rate_den = 0; + bool interlaced = false; +}; + +// Represents the format of an actual frame coming in. +struct VideoFormat { + uint16_t id = 0; // For debugging/logging only. + unsigned width = 0, height = 0, second_field_start = 0; + unsigned extra_lines_top = 0, extra_lines_bottom = 0; + unsigned frame_rate_nom = 0, frame_rate_den = 0; + bool interlaced = false; + bool has_signal = false; +}; + +struct AudioFormat { + uint16_t id = 0; // For debugging/logging only. + unsigned bits_per_sample = 0; + unsigned num_channels = 0; +}; + typedef std::function + FrameAllocator::Frame video_frame, size_t video_offset, VideoFormat video_format, + FrameAllocator::Frame audio_frame, size_t audio_offset, AudioFormat audio_format)> frame_callback_t; -void set_video_frame_allocator(FrameAllocator *allocator); // Does not take ownership. -FrameAllocator *get_video_frame_allocator(); +class CaptureInterface { + public: + virtual ~CaptureInterface() {} + + virtual std::map get_available_video_modes() const = 0; + virtual uint32_t get_current_video_mode() const = 0; + virtual void set_video_mode(uint32_t video_mode_id) = 0; + + // Does not take ownership. + virtual void set_video_frame_allocator(FrameAllocator *allocator) = 0; + + virtual FrameAllocator *get_video_frame_allocator() = 0; + + // Does not take ownership. + virtual void set_audio_frame_allocator(FrameAllocator *allocator) = 0; + + virtual FrameAllocator *get_audio_frame_allocator() = 0; + + virtual void set_frame_callback(frame_callback_t callback) = 0; + + // Needs to be run before configure_card(). + virtual void set_dequeue_thread_callbacks(std::function init, std::function cleanup) = 0; + + // Only valid after configure_card(). + virtual std::string get_description() const = 0; + + virtual void configure_card() = 0; + + virtual void start_bm_capture() = 0; + + virtual void stop_dequeue_thread() = 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() {} + + std::map get_available_video_modes() const override; + uint32_t get_current_video_mode() const override; + void set_video_mode(uint32_t video_mode_id) override; + + // Does not take ownership. + void set_video_frame_allocator(FrameAllocator *allocator) override + { + video_frame_allocator = allocator; + } + + FrameAllocator *get_video_frame_allocator() override + { + return video_frame_allocator; + } + + // Does not take ownership. + void set_audio_frame_allocator(FrameAllocator *allocator) override + { + audio_frame_allocator = allocator; + } + + FrameAllocator *get_audio_frame_allocator() override + { + return audio_frame_allocator; + } + + void set_frame_callback(frame_callback_t callback) override + { + frame_callback = callback; + } + + // Needs to be run before configure_card(). + void set_dequeue_thread_callbacks(std::function init, std::function cleanup) override + { + dequeue_init_callback = init; + dequeue_cleanup_callback = cleanup; + has_dequeue_callbacks = true; + } + + // Only valid after configure_card(). + std::string get_description() const override { + return description; + } + + void configure_card() override; + void start_bm_capture() override; + void stop_dequeue_thread() override; + + // TODO: It's rather messy to have these outside the interface. + static void start_bm_thread(); + static void stop_bm_thread(); -void set_audio_frame_allocator(FrameAllocator *allocator); // Does not take ownership. -FrameAllocator *get_audio_frame_allocator(); + private: + struct QueuedFrame { + uint16_t timecode; + uint16_t format; + FrameAllocator::Frame frame; + }; + + void start_new_audio_block(const uint8_t *start); + void start_new_frame(const uint8_t *start); + + void queue_frame(uint16_t format, uint16_t timecode, FrameAllocator::Frame frame, std::deque *q); + void dequeue_thread_func(); + + static void usb_thread_func(); + static void cb_xfr(struct libusb_transfer *xfr); + + std::string description; + + FrameAllocator::Frame current_video_frame; + FrameAllocator::Frame current_audio_frame; + + std::mutex queue_lock; + std::condition_variable queues_not_empty; + std::deque pending_video_frames; + std::deque pending_audio_frames; + + FrameAllocator *video_frame_allocator = nullptr; + FrameAllocator *audio_frame_allocator = nullptr; + frame_callback_t frame_callback = nullptr; + + std::thread dequeue_thread; + std::atomic dequeue_thread_should_quit; + bool has_dequeue_callbacks = false; + std::function dequeue_init_callback = nullptr; + std::function dequeue_cleanup_callback = nullptr; + + int current_register = 0; + + static constexpr int NUM_BMUSB_REGISTERS = 60; + uint8_t register_file[NUM_BMUSB_REGISTERS]; + + int card_index; + std::vector iso_xfrs; + int assumed_frame_width = 1280; +}; -void set_frame_callback(frame_callback_t callback); -void start_bm_capture(); -void stop_bm_capture(); +// Get details for the given video format; returns false if detection was incomplete. +// Note: Frame rate is _frame_ rate, not field rate. So 1080i60 gets 30/1, _not_ 60/1. +// "second_field_start" is only valid for interlaced modes; it signifies +// how many lines from the very top of the frame there are before the second field +// starts (so it will always be >= height/2 + extra_lines_top). +bool decode_video_format(uint16_t video_format, VideoFormat *decoded_video_format); #endif