X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bmusb.cpp;h=3d2c9f018488e202dff12e9439ebe8be665fa376;hb=5b54cc5acb28f5d2071c99ef7a715044aa30f10c;hp=d083f25371558bdcad6ec0cdcf742dcd84703a4c;hpb=ff94397c2eabfeb4738f503a80fa7d94d3ef4ca2;p=bmusb diff --git a/bmusb.cpp b/bmusb.cpp index d083f25..3d2c9f0 100644 --- a/bmusb.cpp +++ b/bmusb.cpp @@ -28,6 +28,7 @@ #include #include #include +#include #include using namespace std; @@ -79,26 +80,6 @@ void change_xfer_size_for_width(int width, libusb_transfer *xfr) FrameAllocator::~FrameAllocator() {} -// 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; - - mutex freelist_mutex; - stack> freelist; // All of size . -}; - MallocFrameAllocator::MallocFrameAllocator(size_t frame_size, size_t num_queued_frames) : frame_size(frame_size) { @@ -190,6 +171,9 @@ void BMUSBCapture::dequeue_thread_func() uint16_t video_timecode = pending_video_frames.front().timecode; uint16_t audio_timecode = pending_audio_frames.front().timecode; + AudioFormat audio_format; + audio_format.bits_per_sample = 24; + audio_format.num_channels = 8; if (uint16_less_than_with_wraparound(video_timecode, audio_timecode)) { printf("Video block 0x%04x without corresponding audio block, dropping.\n", video_timecode); @@ -203,9 +187,16 @@ void BMUSBCapture::dequeue_thread_func() QueuedFrame audio_frame = pending_audio_frames.front(); pending_audio_frames.pop_front(); lock.unlock(); + audio_format.id = audio_frame.format; + + // Use the video format of the pending frame. + QueuedFrame video_frame = pending_video_frames.front(); + VideoFormat video_format; + decode_video_format(video_frame.format, &video_format); + frame_callback(audio_timecode, - FrameAllocator::Frame(), 0, 0x0000, - audio_frame.frame, AUDIO_HEADER_SIZE, audio_frame.format); + FrameAllocator::Frame(), 0, video_format, + audio_frame.frame, AUDIO_HEADER_SIZE, audio_format); } else { QueuedFrame video_frame = pending_video_frames.front(); QueuedFrame audio_frame = pending_audio_frames.front(); @@ -220,9 +211,17 @@ void BMUSBCapture::dequeue_thread_func() dump_audio_block(audio_frame.frame.data, audio_frame.data_len); #endif - frame_callback(video_timecode, - video_frame.frame, HEADER_SIZE, video_frame.format, - audio_frame.frame, AUDIO_HEADER_SIZE, audio_frame.format); + VideoFormat video_format; + audio_format.id = audio_frame.format; + if (decode_video_format(video_frame.format, &video_format)) { + frame_callback(video_timecode, + video_frame.frame, HEADER_SIZE, video_format, + audio_frame.frame, AUDIO_HEADER_SIZE, audio_format); + } else { + frame_callback(video_timecode, + FrameAllocator::Frame(), 0, video_format, + audio_frame.frame, AUDIO_HEADER_SIZE, audio_format); + } } } if (has_dequeue_callbacks) { @@ -256,11 +255,9 @@ void BMUSBCapture::start_new_frame(const uint8_t *start) // Update the assumed frame width. We might be one frame too late on format changes, // but it's much better than asking the user to choose manually. - unsigned width, height, second_field_start, extra_lines_top, extra_lines_bottom, frame_rate_nom, frame_rate_den; - bool interlaced; - if (decode_video_format(format, &width, &height, &second_field_start, &extra_lines_top, &extra_lines_bottom, - &frame_rate_nom, &frame_rate_den, &interlaced)) { - assumed_frame_width = width; + VideoFormat video_format; + if (decode_video_format(format, &video_format)) { + assumed_frame_width = video_format.width; } } //printf("Found frame start, format 0x%04x timecode 0x%04x, previous frame length was %d/%d\n", @@ -706,7 +703,7 @@ struct USBCardDevice { libusb_device *device; }; -libusb_device_handle *open_card(int card_index) +libusb_device_handle *open_card(int card_index, string *description) { libusb_device **devices; ssize_t num_devices = libusb_get_device_list(nullptr, &devices); @@ -745,14 +742,22 @@ libusb_device_handle *open_card(int card_index) }); for (size_t i = 0; i < found_cards.size(); ++i) { - fprintf(stderr, "Card %d: Bus %03u Device %03u ", int(i), found_cards[i].bus, found_cards[i].port); + const char *product_name = nullptr; if (found_cards[i].product == 0xbd3b) { - fprintf(stderr, "Intensity Shuttle\n"); + product_name = "Intensity Shuttle"; } else if (found_cards[i].product == 0xbd4f) { - fprintf(stderr, "UltraStudio SDI\n"); + product_name = "UltraStudio SDI"; } else { assert(false); } + + char buf[256]; + snprintf(buf, sizeof(buf), "Card %d: Bus %03u Device %03u %s", + int(i), found_cards[i].bus, found_cards[i].port, product_name); + if (i == size_t(card_index)) { + *description = buf; + } + fprintf(stderr, "%s\n", buf); } if (size_t(card_index) >= found_cards.size()) { @@ -794,7 +799,7 @@ void BMUSBCapture::configure_card() exit(1); } - libusb_device_handle *devh = open_card(card_index); + libusb_device_handle *devh = open_card(card_index, &description); if (!devh) { fprintf(stderr, "Error finding USB device\n"); exit(1); @@ -1119,61 +1124,64 @@ struct VideoFormatEntry { bool interlaced; }; -bool decode_video_format(uint16_t video_format, unsigned *width, unsigned *height, unsigned *second_field_start, - unsigned *extra_lines_top, unsigned *extra_lines_bottom, - unsigned *frame_rate_nom, unsigned *frame_rate_den, bool *interlaced) +bool decode_video_format(uint16_t video_format, VideoFormat *decoded_video_format) { - *interlaced = false; + decoded_video_format->id = video_format; + decoded_video_format->interlaced = false; // TODO: Add these for all formats as we find them. - *extra_lines_top = *extra_lines_bottom = *second_field_start = 0; + decoded_video_format->extra_lines_top = decoded_video_format->extra_lines_bottom = decoded_video_format->second_field_start = 0; if (video_format == 0x0800) { // No video signal. These green pseudo-frames seem to come at about 30.13 Hz. // It's a strange thing, but what can you do. - *width = 720; - *height = 525; - *extra_lines_top = 0; - *extra_lines_bottom = 0; - *frame_rate_nom = 3013; - *frame_rate_den = 100; + decoded_video_format->width = 720; + decoded_video_format->height = 525; + decoded_video_format->extra_lines_top = 0; + decoded_video_format->extra_lines_bottom = 0; + decoded_video_format->frame_rate_nom = 3013; + decoded_video_format->frame_rate_den = 100; + decoded_video_format->has_signal = false; return true; } if ((video_format & 0xe800) != 0xe800) { printf("Video format 0x%04x does not appear to be a video format. Assuming 60 Hz.\n", video_format); - *width = 0; - *height = 0; - *extra_lines_top = 0; - *extra_lines_bottom = 0; - *frame_rate_nom = 60; - *frame_rate_den = 1; + decoded_video_format->width = 0; + decoded_video_format->height = 0; + decoded_video_format->extra_lines_top = 0; + decoded_video_format->extra_lines_bottom = 0; + decoded_video_format->frame_rate_nom = 60; + decoded_video_format->frame_rate_den = 1; + decoded_video_format->has_signal = false; return false; } + decoded_video_format->has_signal = true; + // NTSC (480i59.94, I suppose). A special case, see below. if (video_format == 0xe901 || video_format == 0xe9c1 || video_format == 0xe801) { - *width = 720; - *height = 480; - *extra_lines_top = 17; - *extra_lines_bottom = 28; - *frame_rate_nom = 30000; - *frame_rate_den = 1001; - *second_field_start = 280; - *interlaced = true; + decoded_video_format->width = 720; + decoded_video_format->height = 480; + decoded_video_format->extra_lines_top = 17; + decoded_video_format->extra_lines_bottom = 28; + decoded_video_format->frame_rate_nom = 30000; + decoded_video_format->frame_rate_den = 1001; + decoded_video_format->second_field_start = 280; + decoded_video_format->interlaced = true; return true; } // PAL (576i50, I suppose). A special case, see below. - if (video_format == 0xe909 || video_format == 0xe9c9) { - *width = 720; - *height = 576; - *extra_lines_top = 22; - *extra_lines_bottom = 27; - *frame_rate_nom = 25; - *frame_rate_den = 1; - *second_field_start = 335; - *interlaced = true; + if (video_format == 0xe909 || video_format == 0xe9c9 || video_format == 0xe809 || video_format == 0xebe9 || video_format == 0xebe1) { + decoded_video_format->width = 720; + decoded_video_format->height = 576; + decoded_video_format->extra_lines_top = 22; + decoded_video_format->extra_lines_bottom = 27; + decoded_video_format->frame_rate_nom = 25; + decoded_video_format->frame_rate_den = 1; + decoded_video_format->second_field_start = 335; + decoded_video_format->interlaced = true; return true; } @@ -1181,15 +1189,21 @@ bool decode_video_format(uint16_t video_format, unsigned *width, unsigned *heigh // except when it's not (e.g. it's the only difference between NTSC // and PAL). Rather confusing. But we clear it here nevertheless, because // usually it doesn't mean anything. - uint16_t normalized_video_format = video_format & ~0xe808; + // + // 0x4 is a flag I've only seen from the D4. I don't know what it is. + uint16_t normalized_video_format = video_format & ~0xe80c; constexpr VideoFormatEntry entries[] = { + { 0x01f1, 720, 480, 0, 40, 5, 60000, 1001, false }, // 480p59.94 (believed). + { 0x0131, 720, 576, 0, 44, 5, 50, 1, false }, // 576p50. + { 0x0011, 720, 576, 0, 44, 5, 50, 1, false }, // 576p50 (5:4). { 0x0143, 1280, 720, 0, 25, 5, 50, 1, false }, // 720p50. { 0x0103, 1280, 720, 0, 25, 5, 60, 1, false }, // 720p60. + { 0x0125, 1280, 720, 0, 25, 5, 60, 1, false }, // 720p60. { 0x0121, 1280, 720, 0, 25, 5, 60000, 1001, false }, // 720p59.94. { 0x01c3, 1920, 1080, 0, 0, 0, 30, 1, false }, // 1080p30. - { 0x0003, 1920, 1080, 582, 20, 25, 30, 1, true }, // 1080i60. + { 0x0003, 1920, 1080, 583, 20, 25, 30, 1, true }, // 1080i60. { 0x01e1, 1920, 1080, 0, 0, 0, 30000, 1001, false }, // 1080p29.97. - { 0x0021, 1920, 1080, 582, 20, 25, 30000, 1001, true }, // 1080i59.94. + { 0x0021, 1920, 1080, 583, 20, 25, 30000, 1001, true }, // 1080i59.94. { 0x0063, 1920, 1080, 0, 0, 0, 25, 1, false }, // 1080p25. { 0x0043, 1920, 1080, 0, 0, 0, 25, 1, true }, // 1080p50. { 0x008e, 1920, 1080, 0, 0, 0, 24, 1, false }, // 1080p24. @@ -1197,22 +1211,41 @@ bool decode_video_format(uint16_t video_format, unsigned *width, unsigned *heigh }; for (const VideoFormatEntry &entry : entries) { if (normalized_video_format == entry.normalized_video_format) { - *width = entry.width; - *height = entry.height; - *second_field_start = entry.second_field_start; - *extra_lines_top = entry.extra_lines_top; - *extra_lines_bottom = entry.extra_lines_bottom; - *frame_rate_nom = entry.frame_rate_nom; - *frame_rate_den = entry.frame_rate_den; - *interlaced = entry.interlaced; + decoded_video_format->width = entry.width; + decoded_video_format->height = entry.height; + decoded_video_format->second_field_start = entry.second_field_start; + decoded_video_format->extra_lines_top = entry.extra_lines_top; + decoded_video_format->extra_lines_bottom = entry.extra_lines_bottom; + decoded_video_format->frame_rate_nom = entry.frame_rate_nom; + decoded_video_format->frame_rate_den = entry.frame_rate_den; + decoded_video_format->interlaced = entry.interlaced; return true; } } - printf("Unknown video format 0x%04x. Assuming 720p60.\n", video_format); - *width = 1280; - *height = 720; - *frame_rate_nom = 60; - *frame_rate_den = 1; + printf("Unknown video format 0x%04x (normalized 0x%04x). Assuming 720p60.\n", video_format, normalized_video_format); + decoded_video_format->width = 1280; + decoded_video_format->height = 720; + decoded_video_format->frame_rate_nom = 60; + decoded_video_format->frame_rate_den = 1; return false; } + +map BMUSBCapture::get_available_video_modes() const +{ + // The USB3 cards autodetect, and seem to have no provision for forcing modes. + VideoMode auto_mode; + auto_mode.name = "Autodetect"; + auto_mode.autodetect = true; + return {{ 0, auto_mode }}; +} + +uint32_t BMUSBCapture::get_current_video_mode() const +{ + return 0; // Matches get_available_video_modes(). +} + +void BMUSBCapture::set_video_mode(uint32_t video_mode_id) +{ + assert(video_mode_id == 0); // Matches get_available_video_modes(). +}