Add a function to get video format details.

[bmusb] / bmusb.cpp

diff --git a/bmusb.cpp b/bmusb.cpp
index 0582b99631b5d30de538adb5e50b12002504e66e..74adca86c14c603c2c0855c41ba319849365638a 100644 (file)
--- a/bmusb.cpp
+++ b/bmusb.cpp
@@ -159,13 +159,17 @@ void BMUSBCapture::dequeue_thread_func()
                unique_lock<mutex> lock(queue_lock);
                queues_not_empty.wait(lock, [this]{ return dequeue_thread_should_quit || (!pending_video_frames.empty() && !pending_audio_frames.empty()); });
 
+               if (dequeue_thread_should_quit) break;
+
                uint16_t video_timecode = pending_video_frames.front().timecode;
                uint16_t audio_timecode = pending_audio_frames.front().timecode;
                if (uint16_less_than_with_wraparound(video_timecode, audio_timecode)) {
                        printf("Video block 0x%04x without corresponding audio block, dropping.\n",
                                video_timecode);
-                       video_frame_allocator->release_frame(pending_video_frames.front().frame);
+                       QueuedFrame video_frame = pending_video_frames.front();
                        pending_video_frames.pop_front();
+                       lock.unlock();
+                       video_frame_allocator->release_frame(video_frame.frame);
                } else if (uint16_less_than_with_wraparound(audio_timecode, video_timecode)) {
                        printf("Audio block 0x%04x without corresponding video block, sending blank frame.\n",
                                audio_timecode);
@@ -1059,3 +1063,89 @@ void BMUSBCapture::stop_bm_thread()
        should_quit = true;
        usb_thread.join();
 }
+
+struct VideoFormatEntry {
+       uint16_t normalized_video_format;
+       int width, height;
+       int frame_rate_den, frame_rate_nom;
+       bool interlaced;
+};
+
+bool decode_video_format(uint16_t video_format, int *width, int *height, int *frame_rate_den, int *frame_rate_nom, bool *interlaced)
+{
+       *interlaced = false;
+
+       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.
+               // FIXME: find the dimensions.
+               *frame_rate_nom = 3013;
+               *frame_rate_den = 100;
+               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;
+               *frame_rate_nom = 60;
+               *frame_rate_den = 1;
+               return false;
+       }
+
+       // NTSC (480i59.94, I suppose). A special case, see below.
+       if (video_format == 0xe901 || video_format == 0xe9c1 || video_format == 0xe801) {
+               *width = 640;
+               *height = 480;
+               *frame_rate_nom = 60000;
+               *frame_rate_den = 1001;
+               *interlaced = true;
+               return true;
+       }
+
+       // PAL (576i50, I suppose). A special case, see below.
+       if (video_format == 0xe909) {
+               *width = 720;
+               *height = 576;
+               *frame_rate_nom = 50;
+               *frame_rate_den = 1;
+               *interlaced = true;
+               return true;
+       }
+
+       // 0x8 seems to be a flag about availability of deep color on the input,
+       // 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;
+       constexpr VideoFormatEntry entries[] = {
+               { 0x0143, 1280,  720,    50,    1, false },  // 720p50.
+               { 0x0103, 1280,  720,    60,    1, false },  // 720p60.
+               { 0x0121, 1280,  720, 60000, 1001, false },  // 720p59.94.
+               { 0x01c3, 1920, 1080,    30,    1, false },  // 1080p30.
+               { 0x0003, 1920, 1080,    30,    1,  true },  // 1080i60.
+               { 0x01e1, 1920, 1080, 30000, 1001, false },  // 1080p29.97.
+               { 0x0021, 1920, 1080, 30000, 1001,  true },  // 1080i59.94.
+               { 0x0063, 1920, 1080,    25,    1, false },  // 1080p25.
+               { 0x0043, 1920, 1080,    25,    1,  true },  // 1080p50.
+               { 0x008e, 1920, 1080,    24,    1, false },  // 1080p24.
+               { 0x00a1, 1920, 1080, 24000, 1001, false },  // 1080p23.98.
+       };
+       for (const VideoFormatEntry &entry : entries) {
+               if (normalized_video_format == entry.normalized_video_format) {
+                       *width = entry.width;
+                       *height = entry.height;
+                       *frame_rate_nom = entry.frame_rate_nom;
+                       *frame_rate_den = entry.frame_rate_den;
+                       *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;
+       return false;
+}