X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bmusb.h;h=9ba27bcc111234040d807bbcd0fafbb3f3cd9275;hb=5b54cc5acb28f5d2071c99ef7a715044aa30f10c;hp=58ad9e7f3d86b0c60fd742921a7a279708ea07f7;hpb=cb414fadb0738aeab971cc9b83c322118015d00b;p=bmusb diff --git a/bmusb.h b/bmusb.h index 58ad9e7..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; @@ -157,7 +252,9 @@ class BMUSBCapture { // 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. -bool decode_video_format(uint16_t video_format, int *width, int *height, int *extra_lines_top, int *extra_lines_bottom, - int *frame_rate_nom, int *frame_rate_den, bool *interlaced); +// "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