X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bmusb.h;h=9ba27bcc111234040d807bbcd0fafbb3f3cd9275;hb=5b54cc5acb28f5d2071c99ef7a715044aa30f10c;hp=e2033264ad45443528fe97a494a38bd06e0f089a;hpb=fbfef809541ca1910ff09a817f04a4a3baff64e3;p=bmusb diff --git a/bmusb.h b/bmusb.h index e203326..9ba27bc 100644 --- a/bmusb.h +++ b/bmusb.h @@ -6,7 +6,10 @@ #include #include #include +#include #include +#include +#include #include #include @@ -56,58 +59,148 @@ 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; +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 { +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) + void set_video_frame_allocator(FrameAllocator *allocator) override { video_frame_allocator = allocator; } - FrameAllocator *get_video_frame_allocator() + FrameAllocator *get_video_frame_allocator() override { return video_frame_allocator; } // Does not take ownership. - void set_audio_frame_allocator(FrameAllocator *allocator) + void set_audio_frame_allocator(FrameAllocator *allocator) override { audio_frame_allocator = allocator; } - FrameAllocator *get_audio_frame_allocator() + FrameAllocator *get_audio_frame_allocator() override { return audio_frame_allocator; } - void set_frame_callback(frame_callback_t callback) + 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) + void set_dequeue_thread_callbacks(std::function init, std::function cleanup) override { dequeue_init_callback = init; dequeue_cleanup_callback = cleanup; has_dequeue_callbacks = true; } - void configure_card(); - void start_bm_capture(); - void stop_dequeue_thread(); + // 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(); @@ -127,6 +220,8 @@ class BMUSBCapture { 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; @@ -152,6 +247,14 @@ class BMUSBCapture { int card_index; std::vector iso_xfrs; + int assumed_frame_width = 1280; }; +// 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