void BMUSBCapture::queue_frame(uint16_t format, uint16_t timecode, FrameAllocator::Frame frame, deque<QueuedFrame> *q)
{
+ unique_lock<mutex> lock(queue_lock);
if (!q->empty() && !uint16_less_than_with_wraparound(q->back().timecode, timecode)) {
printf("Blocks going backwards: prev=0x%04x, cur=0x%04x (dropped)\n",
q->back().timecode, timecode);
qf.format = format;
qf.timecode = timecode;
qf.frame = frame;
-
- {
- unique_lock<mutex> lock(queue_lock);
- q->push_back(move(qf));
- }
+ q->push_back(move(qf));
queues_not_empty.notify_one(); // might be spurious
}
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);
}
#endif
- if (libusb_submit_transfer(xfr) < 0) {
- fprintf(stderr, "error re-submitting URB\n");
+ int rc = libusb_submit_transfer(xfr);
+ if (rc < 0) {
+ fprintf(stderr, "error re-submitting URB: %s\n", libusb_error_name(rc));
exit(1);
}
}
// set up isochronous transfers for audio and video
for (int e = 3; e <= 4; ++e) {
//int num_transfers = (e == 3) ? 6 : 6;
- int num_transfers = 6;
+ int num_transfers = 10;
for (int i = 0; i < num_transfers; ++i) {
int num_iso_pack, size;
if (e == 3) {
size &= ~1023;
size += 1024;
}
- num_iso_pack = (2 << 18) / size; // 512 kB.
+ num_iso_pack = (2 << 16) / size; // 128 kB.
printf("Picking %d packets of 0x%x bytes each\n", num_iso_pack, size);
} else {
size = 0xc0;
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;
+}