1 // Intensity Shuttle USB3 capture driver, v0.5.1
2 // Can download 8-bit and 10-bit UYVY/v210 frames from HDMI, quite stable
3 // (can do captures for hours at a time with no drops), except during startup
4 // 576p60/720p60/1080i60 works, 1080p60 does not work (firmware limitation)
5 // Audio comes out as 8-channel 24-bit raw audio.
7 #if (defined(__i386__) || defined(__x86_64__)) && defined(__GNUC__)
8 #define HAS_MULTIVERSIONING 1
15 #include <netinet/in.h>
21 #if HAS_MULTIVERSIONING
22 #include <immintrin.h>
24 #include "bmusb/bmusb.h"
28 #include <condition_variable>
40 using namespace std::placeholders;
42 #define USB_VENDOR_BLACKMAGIC 0x1edb
44 #define HEADER_SIZE 44
45 //#define HEADER_SIZE 0
46 #define AUDIO_HEADER_SIZE 4
48 #define FRAME_SIZE (8 << 20) // 8 MB.
49 #define USB_VIDEO_TRANSFER_SIZE (128 << 10) // 128 kB.
53 card_connected_callback_t BMUSBCapture::card_connected_callback = nullptr;
54 bool BMUSBCapture::hotplug_existing_devices = false;
61 atomic<bool> should_quit;
63 int find_xfer_size_for_width(int width)
65 // Video seems to require isochronous packets scaled with the width;
66 // seemingly six lines is about right, rounded up to the required 1kB
68 int size = width * 2 * 6;
69 // Note that for 10-bit input, you'll need to increase size accordingly.
70 //size = size * 4 / 3;
71 if (size % 1024 != 0) {
78 void change_xfer_size_for_width(int width, libusb_transfer *xfr)
80 assert(width >= MIN_WIDTH);
81 size_t size = find_xfer_size_for_width(width);
82 int num_iso_pack = xfr->length / size;
83 if (num_iso_pack != xfr->num_iso_packets ||
84 size != xfr->iso_packet_desc[0].length) {
85 xfr->num_iso_packets = num_iso_pack;
86 libusb_set_iso_packet_lengths(xfr, size);
90 struct VideoFormatEntry {
91 uint16_t normalized_video_format;
92 unsigned width, height, second_field_start;
93 unsigned extra_lines_top, extra_lines_bottom;
94 unsigned frame_rate_nom, frame_rate_den;
98 // Get details for the given video format; returns false if detection was incomplete.
99 bool decode_video_format(uint16_t video_format, VideoFormat *decoded_video_format)
101 decoded_video_format->id = video_format;
102 decoded_video_format->interlaced = false;
104 // TODO: Add these for all formats as we find them.
105 decoded_video_format->extra_lines_top = decoded_video_format->extra_lines_bottom = decoded_video_format->second_field_start = 0;
107 if (video_format == 0x0800) {
108 // No video signal. These green pseudo-frames seem to come at about 30.13 Hz.
109 // It's a strange thing, but what can you do.
110 decoded_video_format->width = 720;
111 decoded_video_format->height = 525;
112 decoded_video_format->extra_lines_top = 0;
113 decoded_video_format->extra_lines_bottom = 0;
114 decoded_video_format->frame_rate_nom = 3013;
115 decoded_video_format->frame_rate_den = 100;
116 decoded_video_format->has_signal = false;
119 if ((video_format & 0xe800) != 0xe800) {
120 printf("Video format 0x%04x does not appear to be a video format. Assuming 60 Hz.\n",
122 decoded_video_format->width = 0;
123 decoded_video_format->height = 0;
124 decoded_video_format->extra_lines_top = 0;
125 decoded_video_format->extra_lines_bottom = 0;
126 decoded_video_format->frame_rate_nom = 60;
127 decoded_video_format->frame_rate_den = 1;
128 decoded_video_format->has_signal = false;
132 decoded_video_format->has_signal = true;
134 // NTSC (480i59.94, I suppose). A special case, see below.
135 if (video_format == 0xe901 || video_format == 0xe9c1 || video_format == 0xe801) {
136 decoded_video_format->width = 720;
137 decoded_video_format->height = 480;
138 decoded_video_format->extra_lines_top = 17;
139 decoded_video_format->extra_lines_bottom = 28;
140 decoded_video_format->frame_rate_nom = 30000;
141 decoded_video_format->frame_rate_den = 1001;
142 decoded_video_format->second_field_start = 280;
143 decoded_video_format->interlaced = true;
147 // PAL (576i50, I suppose). A special case, see below.
148 if (video_format == 0xe909 || video_format == 0xe9c9 || video_format == 0xe809 || video_format == 0xebe9 || video_format == 0xebe1) {
149 decoded_video_format->width = 720;
150 decoded_video_format->height = 576;
151 decoded_video_format->extra_lines_top = 22;
152 decoded_video_format->extra_lines_bottom = 27;
153 decoded_video_format->frame_rate_nom = 25;
154 decoded_video_format->frame_rate_den = 1;
155 decoded_video_format->second_field_start = 335;
156 decoded_video_format->interlaced = true;
160 // 0x8 seems to be a flag about availability of deep color on the input,
161 // except when it's not (e.g. it's the only difference between NTSC
162 // and PAL). Rather confusing. But we clear it here nevertheless, because
163 // usually it doesn't mean anything.
165 // 0x4 is a flag I've only seen from the D4. I don't know what it is.
166 uint16_t normalized_video_format = video_format & ~0xe80c;
167 constexpr VideoFormatEntry entries[] = {
168 { 0x01f1, 720, 480, 0, 40, 5, 60000, 1001, false }, // 480p59.94 (believed).
169 { 0x0131, 720, 576, 0, 44, 5, 50, 1, false }, // 576p50.
170 { 0x0011, 720, 576, 0, 44, 5, 50, 1, false }, // 576p50 (5:4).
171 { 0x0143, 1280, 720, 0, 25, 5, 50, 1, false }, // 720p50.
172 { 0x0103, 1280, 720, 0, 25, 5, 60, 1, false }, // 720p60.
173 { 0x0125, 1280, 720, 0, 25, 5, 60, 1, false }, // 720p60.
174 { 0x0121, 1280, 720, 0, 25, 5, 60000, 1001, false }, // 720p59.94.
175 { 0x01c3, 1920, 1080, 0, 0, 0, 30, 1, false }, // 1080p30.
176 { 0x0003, 1920, 1080, 583, 20, 25, 30, 1, true }, // 1080i60.
177 { 0x01e1, 1920, 1080, 0, 0, 0, 30000, 1001, false }, // 1080p29.97.
178 { 0x0021, 1920, 1080, 583, 20, 25, 30000, 1001, true }, // 1080i59.94.
179 { 0x0063, 1920, 1080, 0, 0, 0, 25, 1, false }, // 1080p25.
180 { 0x0043, 1920, 1080, 0, 0, 0, 25, 1, true }, // 1080p50.
181 { 0x008e, 1920, 1080, 0, 0, 0, 24, 1, false }, // 1080p24.
182 { 0x00a1, 1920, 1080, 0, 0, 0, 24000, 1001, false }, // 1080p23.98.
184 for (const VideoFormatEntry &entry : entries) {
185 if (normalized_video_format == entry.normalized_video_format) {
186 decoded_video_format->width = entry.width;
187 decoded_video_format->height = entry.height;
188 decoded_video_format->second_field_start = entry.second_field_start;
189 decoded_video_format->extra_lines_top = entry.extra_lines_top;
190 decoded_video_format->extra_lines_bottom = entry.extra_lines_bottom;
191 decoded_video_format->frame_rate_nom = entry.frame_rate_nom;
192 decoded_video_format->frame_rate_den = entry.frame_rate_den;
193 decoded_video_format->interlaced = entry.interlaced;
198 printf("Unknown video format 0x%04x (normalized 0x%04x). Assuming 720p60.\n", video_format, normalized_video_format);
199 decoded_video_format->width = 1280;
200 decoded_video_format->height = 720;
201 decoded_video_format->frame_rate_nom = 60;
202 decoded_video_format->frame_rate_den = 1;
208 FrameAllocator::~FrameAllocator() {}
210 MallocFrameAllocator::MallocFrameAllocator(size_t frame_size, size_t num_queued_frames)
211 : frame_size(frame_size)
213 for (size_t i = 0; i < num_queued_frames; ++i) {
214 freelist.push(unique_ptr<uint8_t[]>(new uint8_t[frame_size]));
218 FrameAllocator::Frame MallocFrameAllocator::alloc_frame()
223 unique_lock<mutex> lock(freelist_mutex); // Meh.
224 if (freelist.empty()) {
225 printf("Frame overrun (no more spare frames of size %ld), dropping frame!\n",
228 vf.data = freelist.top().release();
229 vf.size = frame_size;
230 freelist.pop(); // Meh.
235 void MallocFrameAllocator::release_frame(Frame frame)
237 if (frame.overflow > 0) {
238 printf("%d bytes overflow after last (malloc) frame\n", int(frame.overflow));
240 unique_lock<mutex> lock(freelist_mutex);
241 freelist.push(unique_ptr<uint8_t[]>(frame.data));
244 bool uint16_less_than_with_wraparound(uint16_t a, uint16_t b)
249 return (b - a < 0x8000);
251 int wrap_b = 0x10000 + int(b);
252 return (wrap_b - a < 0x8000);
256 void BMUSBCapture::queue_frame(uint16_t format, uint16_t timecode, FrameAllocator::Frame frame, deque<QueuedFrame> *q)
258 unique_lock<mutex> lock(queue_lock);
259 if (!q->empty() && !uint16_less_than_with_wraparound(q->back().timecode, timecode)) {
260 printf("Blocks going backwards: prev=0x%04x, cur=0x%04x (dropped)\n",
261 q->back().timecode, timecode);
262 frame.owner->release_frame(frame);
268 qf.timecode = timecode;
270 q->push_back(move(qf));
271 queues_not_empty.notify_one(); // might be spurious
274 void dump_frame(const char *filename, uint8_t *frame_start, size_t frame_len)
276 FILE *fp = fopen(filename, "wb");
277 if (fwrite(frame_start + HEADER_SIZE, frame_len - HEADER_SIZE, 1, fp) != 1) {
278 printf("short write!\n");
283 void dump_audio_block(uint8_t *audio_start, size_t audio_len)
285 fwrite(audio_start + AUDIO_HEADER_SIZE, 1, audio_len - AUDIO_HEADER_SIZE, audiofp);
288 void BMUSBCapture::dequeue_thread_func()
290 if (has_dequeue_callbacks) {
291 dequeue_init_callback();
293 while (!dequeue_thread_should_quit) {
294 unique_lock<mutex> lock(queue_lock);
295 queues_not_empty.wait(lock, [this]{ return dequeue_thread_should_quit || (!pending_video_frames.empty() && !pending_audio_frames.empty()); });
297 if (dequeue_thread_should_quit) break;
299 uint16_t video_timecode = pending_video_frames.front().timecode;
300 uint16_t audio_timecode = pending_audio_frames.front().timecode;
301 AudioFormat audio_format;
302 audio_format.bits_per_sample = 24;
303 audio_format.num_channels = 8;
304 if (uint16_less_than_with_wraparound(video_timecode, audio_timecode)) {
305 printf("Video block 0x%04x without corresponding audio block, dropping.\n",
307 QueuedFrame video_frame = pending_video_frames.front();
308 pending_video_frames.pop_front();
310 video_frame_allocator->release_frame(video_frame.frame);
311 } else if (uint16_less_than_with_wraparound(audio_timecode, video_timecode)) {
312 printf("Audio block 0x%04x without corresponding video block, sending blank frame.\n",
314 QueuedFrame audio_frame = pending_audio_frames.front();
315 pending_audio_frames.pop_front();
317 audio_format.id = audio_frame.format;
319 // Use the video format of the pending frame.
320 QueuedFrame video_frame = pending_video_frames.front();
321 VideoFormat video_format;
322 decode_video_format(video_frame.format, &video_format);
324 frame_callback(audio_timecode,
325 FrameAllocator::Frame(), 0, video_format,
326 audio_frame.frame, AUDIO_HEADER_SIZE, audio_format);
328 QueuedFrame video_frame = pending_video_frames.front();
329 QueuedFrame audio_frame = pending_audio_frames.front();
330 pending_audio_frames.pop_front();
331 pending_video_frames.pop_front();
336 snprintf(filename, sizeof(filename), "%04x%04x.uyvy", video_frame.format, video_timecode);
337 dump_frame(filename, video_frame.frame.data, video_frame.data_len);
338 dump_audio_block(audio_frame.frame.data, audio_frame.data_len);
341 VideoFormat video_format;
342 audio_format.id = audio_frame.format;
343 if (decode_video_format(video_frame.format, &video_format)) {
344 frame_callback(video_timecode,
345 video_frame.frame, HEADER_SIZE, video_format,
346 audio_frame.frame, AUDIO_HEADER_SIZE, audio_format);
348 frame_callback(video_timecode,
349 FrameAllocator::Frame(), 0, video_format,
350 audio_frame.frame, AUDIO_HEADER_SIZE, audio_format);
354 if (has_dequeue_callbacks) {
355 dequeue_cleanup_callback();
359 void BMUSBCapture::start_new_frame(const uint8_t *start)
361 uint16_t format = (start[3] << 8) | start[2];
362 uint16_t timecode = (start[1] << 8) | start[0];
364 if (current_video_frame.len > 0) {
365 // If format is 0x0800 (no signal), add a fake (empty) audio
366 // frame to get it out of the queue.
367 // TODO: Figure out if there are other formats that come with
368 // no audio, and treat them the same.
369 if (format == 0x0800) {
370 FrameAllocator::Frame fake_audio_frame = audio_frame_allocator->alloc_frame();
371 if (fake_audio_frame.data == nullptr) {
372 // Oh well, it's just a no-signal frame anyway.
373 printf("Couldn't allocate fake audio frame, also dropping no-signal video frame.\n");
374 current_video_frame.owner->release_frame(current_video_frame);
375 current_video_frame = video_frame_allocator->alloc_frame();
378 queue_frame(format, timecode, fake_audio_frame, &pending_audio_frames);
381 queue_frame(format, timecode, current_video_frame, &pending_video_frames);
383 // Update the assumed frame width. We might be one frame too late on format changes,
384 // but it's much better than asking the user to choose manually.
385 VideoFormat video_format;
386 if (decode_video_format(format, &video_format)) {
387 assumed_frame_width = video_format.width;
390 //printf("Found frame start, format 0x%04x timecode 0x%04x, previous frame length was %d/%d\n",
392 // //start[7], start[6], start[5], start[4],
393 // read_current_frame, FRAME_SIZE);
395 current_video_frame = video_frame_allocator->alloc_frame();
396 //if (current_video_frame.data == nullptr) {
397 // read_current_frame = -1;
399 // read_current_frame = 0;
403 void BMUSBCapture::start_new_audio_block(const uint8_t *start)
405 uint16_t format = (start[3] << 8) | start[2];
406 uint16_t timecode = (start[1] << 8) | start[0];
407 if (current_audio_frame.len > 0) {
408 //dump_audio_block();
409 queue_frame(format, timecode, current_audio_frame, &pending_audio_frames);
411 //printf("Found audio block start, format 0x%04x timecode 0x%04x, previous block length was %d\n",
412 // format, timecode, read_current_audio_block);
413 current_audio_frame = audio_frame_allocator->alloc_frame();
417 static void dump_pack(const libusb_transfer *xfr, int offset, const libusb_iso_packet_descriptor *pack)
419 // printf("ISO pack%u length:%u, actual_length:%u, offset:%u\n", i, pack->length, pack->actual_length, offset);
420 for (unsigned j = 0; j < pack->actual_length; j++) {
421 //for (int j = 0; j < min(pack->actual_length, 16u); j++) {
422 printf("%02x", xfr->buffer[j + offset]);
425 else if ((j % 8) == 7)
433 void memcpy_interleaved(uint8_t *dest1, uint8_t *dest2, const uint8_t *src, size_t n)
436 uint8_t *dptr1 = dest1;
437 uint8_t *dptr2 = dest2;
439 for (size_t i = 0; i < n; i += 2) {
445 void add_to_frame(FrameAllocator::Frame *current_frame, const char *frame_type_name, const uint8_t *start, const uint8_t *end)
447 if (current_frame->data == nullptr ||
448 current_frame->len > current_frame->size ||
453 int bytes = end - start;
454 if (current_frame->len + bytes > current_frame->size) {
455 current_frame->overflow = current_frame->len + bytes - current_frame->size;
456 current_frame->len = current_frame->size;
457 if (current_frame->overflow > 1048576) {
458 printf("%d bytes overflow after last %s frame\n",
459 int(current_frame->overflow), frame_type_name);
460 current_frame->overflow = 0;
464 if (current_frame->interleaved) {
465 uint8_t *data = current_frame->data + current_frame->len / 2;
466 uint8_t *data2 = current_frame->data2 + current_frame->len / 2;
467 if (current_frame->len % 2 == 1) {
471 if (bytes % 2 == 1) {
474 ++current_frame->len;
477 memcpy_interleaved(data, data2, start, bytes);
478 current_frame->len += bytes;
480 memcpy(current_frame->data + current_frame->len, start, bytes);
481 current_frame->len += bytes;
487 void avx2_dump(const char *name, __m256i n)
489 printf("%-10s:", name);
490 printf(" %02x", _mm256_extract_epi8(n, 0));
491 printf(" %02x", _mm256_extract_epi8(n, 1));
492 printf(" %02x", _mm256_extract_epi8(n, 2));
493 printf(" %02x", _mm256_extract_epi8(n, 3));
494 printf(" %02x", _mm256_extract_epi8(n, 4));
495 printf(" %02x", _mm256_extract_epi8(n, 5));
496 printf(" %02x", _mm256_extract_epi8(n, 6));
497 printf(" %02x", _mm256_extract_epi8(n, 7));
499 printf(" %02x", _mm256_extract_epi8(n, 8));
500 printf(" %02x", _mm256_extract_epi8(n, 9));
501 printf(" %02x", _mm256_extract_epi8(n, 10));
502 printf(" %02x", _mm256_extract_epi8(n, 11));
503 printf(" %02x", _mm256_extract_epi8(n, 12));
504 printf(" %02x", _mm256_extract_epi8(n, 13));
505 printf(" %02x", _mm256_extract_epi8(n, 14));
506 printf(" %02x", _mm256_extract_epi8(n, 15));
508 printf(" %02x", _mm256_extract_epi8(n, 16));
509 printf(" %02x", _mm256_extract_epi8(n, 17));
510 printf(" %02x", _mm256_extract_epi8(n, 18));
511 printf(" %02x", _mm256_extract_epi8(n, 19));
512 printf(" %02x", _mm256_extract_epi8(n, 20));
513 printf(" %02x", _mm256_extract_epi8(n, 21));
514 printf(" %02x", _mm256_extract_epi8(n, 22));
515 printf(" %02x", _mm256_extract_epi8(n, 23));
517 printf(" %02x", _mm256_extract_epi8(n, 24));
518 printf(" %02x", _mm256_extract_epi8(n, 25));
519 printf(" %02x", _mm256_extract_epi8(n, 26));
520 printf(" %02x", _mm256_extract_epi8(n, 27));
521 printf(" %02x", _mm256_extract_epi8(n, 28));
522 printf(" %02x", _mm256_extract_epi8(n, 29));
523 printf(" %02x", _mm256_extract_epi8(n, 30));
524 printf(" %02x", _mm256_extract_epi8(n, 31));
529 #ifndef HAS_MULTIVERSIONING
531 const uint8_t *add_to_frame_fastpath(FrameAllocator::Frame *current_frame, const uint8_t *start, const uint8_t *limit, const char sync_char)
533 // No fast path possible unless we have multiversioning.
537 #else // defined(HAS_MULTIVERSIONING)
539 __attribute__((target("sse4.1")))
540 const uint8_t *add_to_frame_fastpath_core(FrameAllocator::Frame *current_frame, const uint8_t *aligned_start, const uint8_t *limit, const char sync_char);
542 __attribute__((target("avx2")))
543 const uint8_t *add_to_frame_fastpath_core(FrameAllocator::Frame *current_frame, const uint8_t *aligned_start, const uint8_t *limit, const char sync_char);
545 // Does a memcpy and memchr in one to reduce processing time.
546 // Note that the benefit is somewhat limited if your L3 cache is small,
547 // as you'll (unfortunately) spend most of the time loading the data
550 // Complicated cases are left to the slow path; it basically stops copying
551 // up until the first instance of "sync_char" (usually a bit before, actually).
552 // This is fine, since 0x00 bytes shouldn't really show up in normal picture
553 // data, and what we really need this for is the 00 00 ff ff marker in video data.
554 __attribute__((target("default")))
555 const uint8_t *add_to_frame_fastpath(FrameAllocator::Frame *current_frame, const uint8_t *start, const uint8_t *limit, const char sync_char)
557 // No fast path possible unless we have SSE 4.1 or higher.
561 __attribute__((target("sse4.1", "avx2")))
562 const uint8_t *add_to_frame_fastpath(FrameAllocator::Frame *current_frame, const uint8_t *start, const uint8_t *limit, const char sync_char)
564 if (current_frame->data == nullptr ||
565 current_frame->len > current_frame->size ||
569 size_t orig_bytes = limit - start;
570 if (orig_bytes < 128) {
575 // Don't read more bytes than we can write.
576 limit = min(limit, start + (current_frame->size - current_frame->len));
578 // Align end to 32 bytes.
579 limit = (const uint8_t *)(intptr_t(limit) & ~31);
581 if (start >= limit) {
585 // Process [0,31] bytes, such that start gets aligned to 32 bytes.
586 const uint8_t *aligned_start = (const uint8_t *)(intptr_t(start + 31) & ~31);
587 if (aligned_start != start) {
588 const uint8_t *sync_start = (const uint8_t *)memchr(start, sync_char, aligned_start - start);
589 if (sync_start == nullptr) {
590 add_to_frame(current_frame, "", start, aligned_start);
592 add_to_frame(current_frame, "", start, sync_start);
597 // Make the length a multiple of 64.
598 if (current_frame->interleaved) {
599 if (((limit - aligned_start) % 64) != 0) {
602 assert(((limit - aligned_start) % 64) == 0);
605 return add_to_frame_fastpath_core(current_frame, aligned_start, limit, sync_char);
608 __attribute__((target("avx2")))
609 const uint8_t *add_to_frame_fastpath_core(FrameAllocator::Frame *current_frame, const uint8_t *aligned_start, const uint8_t *limit, const char sync_char)
611 const __m256i needle = _mm256_set1_epi8(sync_char);
613 const __restrict __m256i *in = (const __m256i *)aligned_start;
614 if (current_frame->interleaved) {
615 __restrict __m256i *out1 = (__m256i *)(current_frame->data + (current_frame->len + 1) / 2);
616 __restrict __m256i *out2 = (__m256i *)(current_frame->data2 + current_frame->len / 2);
617 if (current_frame->len % 2 == 1) {
621 __m256i shuffle_cw = _mm256_set_epi8(
622 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0,
623 15, 13, 11, 9, 7, 5, 3, 1, 14, 12, 10, 8, 6, 4, 2, 0);
624 while (in < (const __m256i *)limit) {
625 // Note: For brevity, comments show lanes as if they were 2x64-bit (they're actually 2x128).
626 __m256i data1 = _mm256_stream_load_si256(in); // AaBbCcDd EeFfGgHh
627 __m256i data2 = _mm256_stream_load_si256(in + 1); // IiJjKkLl MmNnOoPp
629 __m256i found1 = _mm256_cmpeq_epi8(data1, needle);
630 __m256i found2 = _mm256_cmpeq_epi8(data2, needle);
631 __m256i found = _mm256_or_si256(found1, found2);
633 data1 = _mm256_shuffle_epi8(data1, shuffle_cw); // ABCDabcd EFGHefgh
634 data2 = _mm256_shuffle_epi8(data2, shuffle_cw); // IJKLijkl MNOPmnop
636 data1 = _mm256_permute4x64_epi64(data1, 0b11011000); // ABCDEFGH abcdefgh
637 data2 = _mm256_permute4x64_epi64(data2, 0b11011000); // IJKLMNOP ijklmnop
639 __m256i lo = _mm256_permute2x128_si256(data1, data2, 0b00100000);
640 __m256i hi = _mm256_permute2x128_si256(data1, data2, 0b00110001);
642 _mm256_storeu_si256(out1, lo); // Store as early as possible, even if the data isn't used.
643 _mm256_storeu_si256(out2, hi);
645 if (!_mm256_testz_si256(found, found)) {
653 current_frame->len += (uint8_t *)in - aligned_start;
655 __m256i *out = (__m256i *)(current_frame->data + current_frame->len);
656 while (in < (const __m256i *)limit) {
657 __m256i data = _mm256_load_si256(in);
658 _mm256_storeu_si256(out, data); // Store as early as possible, even if the data isn't used.
659 __m256i found = _mm256_cmpeq_epi8(data, needle);
660 if (!_mm256_testz_si256(found, found)) {
667 current_frame->len = (uint8_t *)out - current_frame->data;
670 //printf("managed to fastpath %ld/%ld bytes\n", (const uint8_t *)in - (const uint8_t *)aligned_start, orig_bytes);
671 return (const uint8_t *)in;
674 __attribute__((target("sse4.1")))
675 const uint8_t *add_to_frame_fastpath_core(FrameAllocator::Frame *current_frame, const uint8_t *aligned_start, const uint8_t *limit, const char sync_char)
677 const __m128i needle = _mm_set1_epi8(sync_char);
679 const __m128i *in = (const __m128i *)aligned_start;
680 if (current_frame->interleaved) {
681 __m128i *out1 = (__m128i *)(current_frame->data + (current_frame->len + 1) / 2);
682 __m128i *out2 = (__m128i *)(current_frame->data2 + current_frame->len / 2);
683 if (current_frame->len % 2 == 1) {
687 __m128i mask_lower_byte = _mm_set1_epi16(0x00ff);
688 while (in < (const __m128i *)limit) {
689 __m128i data1 = _mm_load_si128(in);
690 __m128i data2 = _mm_load_si128(in + 1);
691 __m128i data1_lo = _mm_and_si128(data1, mask_lower_byte);
692 __m128i data2_lo = _mm_and_si128(data2, mask_lower_byte);
693 __m128i data1_hi = _mm_srli_epi16(data1, 8);
694 __m128i data2_hi = _mm_srli_epi16(data2, 8);
695 __m128i lo = _mm_packus_epi16(data1_lo, data2_lo);
696 _mm_storeu_si128(out1, lo); // Store as early as possible, even if the data isn't used.
697 __m128i hi = _mm_packus_epi16(data1_hi, data2_hi);
698 _mm_storeu_si128(out2, hi);
699 __m128i found1 = _mm_cmpeq_epi8(data1, needle);
700 __m128i found2 = _mm_cmpeq_epi8(data2, needle);
701 if (!_mm_testz_si128(found1, found1) ||
702 !_mm_testz_si128(found2, found2)) {
710 current_frame->len += (uint8_t *)in - aligned_start;
712 __m128i *out = (__m128i *)(current_frame->data + current_frame->len);
713 while (in < (const __m128i *)limit) {
714 __m128i data = _mm_load_si128(in);
715 _mm_storeu_si128(out, data); // Store as early as possible, even if the data isn't used.
716 __m128i found = _mm_cmpeq_epi8(data, needle);
717 if (!_mm_testz_si128(found, found)) {
724 current_frame->len = (uint8_t *)out - current_frame->data;
727 //printf("managed to fastpath %ld/%ld bytes\n", (const uint8_t *)in - (const uint8_t *)aligned_start, orig_bytes);
728 return (const uint8_t *)in;
731 #endif // defined(HAS_MULTIVERSIONING)
733 void decode_packs(const libusb_transfer *xfr,
734 const char *sync_pattern,
736 FrameAllocator::Frame *current_frame,
737 const char *frame_type_name,
738 function<void(const uint8_t *start)> start_callback)
741 for (int i = 0; i < xfr->num_iso_packets; i++) {
742 const libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i];
744 if (pack->status != LIBUSB_TRANSFER_COMPLETED) {
745 fprintf(stderr, "Error: pack %u/%u status %d\n", i, xfr->num_iso_packets, pack->status);
750 const uint8_t *start = xfr->buffer + offset;
751 const uint8_t *limit = start + pack->actual_length;
752 while (start < limit) { // Usually runs only one iteration.
753 start = add_to_frame_fastpath(current_frame, start, limit, sync_pattern[0]);
754 if (start == limit) break;
755 assert(start < limit);
757 const unsigned char* start_next_frame = (const unsigned char *)memmem(start, limit - start, sync_pattern, sync_length);
758 if (start_next_frame == nullptr) {
759 // add the rest of the buffer
760 add_to_frame(current_frame, frame_type_name, start, limit);
763 add_to_frame(current_frame, frame_type_name, start, start_next_frame);
764 start = start_next_frame + sync_length; // skip sync
765 start_callback(start);
769 dump_pack(xfr, offset, pack);
771 offset += pack->length;
775 void BMUSBCapture::cb_xfr(struct libusb_transfer *xfr)
777 if (xfr->status != LIBUSB_TRANSFER_COMPLETED &&
778 xfr->status != LIBUSB_TRANSFER_NO_DEVICE) {
779 fprintf(stderr, "error: transfer status %d\n", xfr->status);
780 libusb_free_transfer(xfr);
784 assert(xfr->user_data != nullptr);
785 BMUSBCapture *usb = static_cast<BMUSBCapture *>(xfr->user_data);
787 if (xfr->status == LIBUSB_TRANSFER_NO_DEVICE) {
788 if (!usb->disconnected) {
789 fprintf(stderr, "Device went away, stopping transfers.\n");
790 usb->disconnected = true;
791 if (usb->card_disconnected_callback) {
792 usb->card_disconnected_callback();
795 // Don't reschedule the transfer; the loop will stop by itself.
799 if (xfr->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
800 if (xfr->endpoint == 0x84) {
801 decode_packs(xfr, "DeckLinkAudioResyncT", 20, &usb->current_audio_frame, "audio", bind(&BMUSBCapture::start_new_audio_block, usb, _1));
803 decode_packs(xfr, "\x00\x00\xff\xff", 4, &usb->current_video_frame, "video", bind(&BMUSBCapture::start_new_frame, usb, _1));
805 // Update the transfer with the new assumed width, if we're in the process of changing formats.
806 change_xfer_size_for_width(usb->assumed_frame_width, xfr);
809 if (xfr->type == LIBUSB_TRANSFER_TYPE_CONTROL) {
810 //const libusb_control_setup *setup = libusb_control_transfer_get_setup(xfr);
811 uint8_t *buf = libusb_control_transfer_get_data(xfr);
813 if (setup->wIndex == 44) {
814 printf("read timer register: 0x%02x%02x%02x%02x\n", buf[0], buf[1], buf[2], buf[3]);
816 printf("read register %2d: 0x%02x%02x%02x%02x\n",
817 setup->wIndex, buf[0], buf[1], buf[2], buf[3]);
820 memcpy(usb->register_file + usb->current_register, buf, 4);
821 usb->current_register = (usb->current_register + 4) % NUM_BMUSB_REGISTERS;
822 if (usb->current_register == 0) {
823 // read through all of them
824 printf("register dump:");
825 for (int i = 0; i < NUM_BMUSB_REGISTERS; i += 4) {
826 printf(" 0x%02x%02x%02x%02x", usb->register_file[i], usb->register_file[i + 1], usb->register_file[i + 2], usb->register_file[i + 3]);
830 libusb_fill_control_setup(xfr->buffer,
831 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, /*request=*/214, /*value=*/0,
832 /*index=*/usb->current_register, /*length=*/4);
837 printf("length:%u, actual_length:%u\n", xfr->length, xfr->actual_length);
838 for (i = 0; i < xfr->actual_length; i++) {
839 printf("%02x", xfr->buffer[i]);
849 int rc = libusb_submit_transfer(xfr);
851 fprintf(stderr, "error re-submitting URB: %s\n", libusb_error_name(rc));
856 int BMUSBCapture::cb_hotplug(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
858 if (card_connected_callback != nullptr) {
859 libusb_device_descriptor desc;
860 if (libusb_get_device_descriptor(dev, &desc) < 0) {
861 fprintf(stderr, "Error getting device descriptor for hotplugged device %p, killing hotplug\n", dev);
862 libusb_unref_device(dev);
866 if ((desc.idVendor == USB_VENDOR_BLACKMAGIC && desc.idProduct == 0xbd3b) ||
867 (desc.idVendor == USB_VENDOR_BLACKMAGIC && desc.idProduct == 0xbd4f)) {
868 card_connected_callback(dev); // Callback takes ownership.
872 libusb_unref_device(dev);
876 void BMUSBCapture::usb_thread_func()
879 memset(¶m, 0, sizeof(param));
880 param.sched_priority = 1;
881 if (sched_setscheduler(0, SCHED_RR, ¶m) == -1) {
882 printf("couldn't set realtime priority for USB thread: %s\n", strerror(errno));
884 while (!should_quit) {
885 timeval sec { 1, 0 };
886 int rc = libusb_handle_events_timeout(nullptr, &sec);
887 if (rc != LIBUSB_SUCCESS)
894 struct USBCardDevice {
897 libusb_device *device;
900 const char *get_product_name(uint16_t product)
902 if (product == 0xbd3b) {
903 return "Intensity Shuttle";
904 } else if (product == 0xbd4f) {
905 return "UltraStudio SDI";
912 string get_card_description(int id, uint8_t bus, uint8_t port, uint16_t product)
914 const char *product_name = get_product_name(product);
917 snprintf(buf, sizeof(buf), "USB card %d: Bus %03u Device %03u %s",
918 id, bus, port, product_name);
922 vector<USBCardDevice> find_all_cards()
924 libusb_device **devices;
925 ssize_t num_devices = libusb_get_device_list(nullptr, &devices);
926 if (num_devices == -1) {
927 fprintf(stderr, "Error finding USB devices\n");
930 vector<USBCardDevice> found_cards;
931 for (ssize_t i = 0; i < num_devices; ++i) {
932 libusb_device_descriptor desc;
933 if (libusb_get_device_descriptor(devices[i], &desc) < 0) {
934 fprintf(stderr, "Error getting device descriptor for device %d\n", int(i));
938 uint8_t bus = libusb_get_bus_number(devices[i]);
939 uint8_t port = libusb_get_port_number(devices[i]);
941 if (!(desc.idVendor == USB_VENDOR_BLACKMAGIC && desc.idProduct == 0xbd3b) &&
942 !(desc.idVendor == USB_VENDOR_BLACKMAGIC && desc.idProduct == 0xbd4f)) {
943 libusb_unref_device(devices[i]);
947 found_cards.push_back({ desc.idProduct, bus, port, devices[i] });
949 libusb_free_device_list(devices, 0);
951 // Sort the devices to get a consistent ordering.
952 sort(found_cards.begin(), found_cards.end(), [](const USBCardDevice &a, const USBCardDevice &b) {
953 if (a.product != b.product)
954 return a.product < b.product;
956 return a.bus < b.bus;
957 return a.port < b.port;
963 libusb_device_handle *open_card(int card_index, string *description)
965 vector<USBCardDevice> found_cards = find_all_cards();
967 for (size_t i = 0; i < found_cards.size(); ++i) {
968 string tmp_description = get_card_description(i, found_cards[i].bus, found_cards[i].port, found_cards[i].product);
969 fprintf(stderr, "%s\n", tmp_description.c_str());
970 if (i == size_t(card_index)) {
971 *description = tmp_description;
975 if (size_t(card_index) >= found_cards.size()) {
976 fprintf(stderr, "Could not open card %d (only %d found)\n", card_index, int(found_cards.size()));
980 libusb_device_handle *devh;
981 int rc = libusb_open(found_cards[card_index].device, &devh);
983 fprintf(stderr, "Error opening card %d: %s\n", card_index, libusb_error_name(rc));
987 for (size_t i = 0; i < found_cards.size(); ++i) {
988 libusb_unref_device(found_cards[i].device);
994 libusb_device_handle *open_card(unsigned card_index, libusb_device *dev, string *description)
996 uint8_t bus = libusb_get_bus_number(dev);
997 uint8_t port = libusb_get_port_number(dev);
999 libusb_device_descriptor desc;
1000 if (libusb_get_device_descriptor(dev, &desc) < 0) {
1001 fprintf(stderr, "Error getting device descriptor for device %p\n", dev);
1005 *description = get_card_description(card_index, bus, port, desc.idProduct);
1007 libusb_device_handle *devh;
1008 int rc = libusb_open(dev, &devh);
1010 fprintf(stderr, "Error opening card %p: %s\n", dev, libusb_error_name(rc));
1019 unsigned BMUSBCapture::num_cards()
1021 int rc = libusb_init(nullptr);
1023 fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
1027 vector<USBCardDevice> found_cards = find_all_cards();
1028 unsigned ret = found_cards.size();
1029 for (size_t i = 0; i < found_cards.size(); ++i) {
1030 libusb_unref_device(found_cards[i].device);
1035 void BMUSBCapture::configure_card()
1037 if (video_frame_allocator == nullptr) {
1038 owned_video_frame_allocator.reset(new MallocFrameAllocator(FRAME_SIZE, NUM_QUEUED_VIDEO_FRAMES));
1039 set_video_frame_allocator(owned_video_frame_allocator.get());
1041 if (audio_frame_allocator == nullptr) {
1042 owned_audio_frame_allocator.reset(new MallocFrameAllocator(65536, NUM_QUEUED_AUDIO_FRAMES));
1043 set_audio_frame_allocator(owned_audio_frame_allocator.get());
1045 dequeue_thread_should_quit = false;
1046 dequeue_thread = thread(&BMUSBCapture::dequeue_thread_func, this);
1049 struct libusb_transfer *xfr;
1051 rc = libusb_init(nullptr);
1053 fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
1057 if (dev == nullptr) {
1058 devh = open_card(card_index, &description);
1060 devh = open_card(card_index, dev, &description);
1061 libusb_unref_device(dev);
1064 fprintf(stderr, "Error finding USB device\n");
1068 libusb_config_descriptor *config;
1069 rc = libusb_get_config_descriptor(libusb_get_device(devh), /*config_index=*/0, &config);
1071 fprintf(stderr, "Error getting configuration: %s\n", libusb_error_name(rc));
1076 printf("%d interface\n", config->bNumInterfaces);
1077 for (int interface_number = 0; interface_number < config->bNumInterfaces; ++interface_number) {
1078 printf(" interface %d\n", interface_number);
1079 const libusb_interface *interface = &config->interface[interface_number];
1080 for (int altsetting = 0; altsetting < interface->num_altsetting; ++altsetting) {
1081 const libusb_interface_descriptor *interface_desc = &interface->altsetting[altsetting];
1082 printf(" alternate setting %d\n", interface_desc->bAlternateSetting);
1083 for (int endpoint_number = 0; endpoint_number < interface_desc->bNumEndpoints; ++endpoint_number) {
1084 const libusb_endpoint_descriptor *endpoint = &interface_desc->endpoint[endpoint_number];
1085 printf(" endpoint address 0x%02x\n", endpoint->bEndpointAddress);
1091 rc = libusb_set_configuration(devh, /*configuration=*/1);
1093 fprintf(stderr, "Error setting configuration 1: %s\n", libusb_error_name(rc));
1097 rc = libusb_claim_interface(devh, 0);
1099 fprintf(stderr, "Error claiming interface 0: %s\n", libusb_error_name(rc));
1103 // Alternate setting 1 is output, alternate setting 2 is input.
1104 // Card is reset when switching alternates, so the driver uses
1105 // this “double switch” when it wants to reset.
1107 // There's also alternate settings 3 and 4, which seem to be
1108 // like 1 and 2 except they advertise less bandwidth needed.
1109 rc = libusb_set_interface_alt_setting(devh, /*interface=*/0, /*alternate_setting=*/1);
1111 fprintf(stderr, "Error setting alternate 1: %s\n", libusb_error_name(rc));
1112 if (rc == LIBUSB_ERROR_NOT_FOUND) {
1113 fprintf(stderr, "This is usually because the card came up in USB2 mode.\n");
1114 fprintf(stderr, "In particular, this tends to happen if you boot up with the\n");
1115 fprintf(stderr, "card plugged in; just unplug and replug it, and it usually works.\n");
1119 rc = libusb_set_interface_alt_setting(devh, /*interface=*/0, /*alternate_setting=*/2);
1121 fprintf(stderr, "Error setting alternate 2: %s\n", libusb_error_name(rc));
1125 rc = libusb_set_interface_alt_setting(devh, /*interface=*/0, /*alternate_setting=*/1);
1127 fprintf(stderr, "Error setting alternate 1: %s\n", libusb_error_name(rc));
1133 rc = libusb_claim_interface(devh, 3);
1135 fprintf(stderr, "Error claiming interface 3: %s\n", libusb_error_name(rc));
1141 // 44 is some kind of timer register (first 16 bits count upwards)
1142 // 24 is some sort of watchdog?
1143 // you can seemingly set it to 0x73c60001 and that bit will eventually disappear
1144 // (or will go to 0x73c60010?), also seen 0x73c60100
1145 // 12 also changes all the time, unclear why
1146 // 16 seems to be autodetected mode somehow
1147 // -- this is e00115e0 after reset?
1148 // ed0115e0 after mode change [to output?]
1149 // 2d0015e0 after more mode change [to input]
1150 // ed0115e0 after more mode change
1151 // 2d0015e0 after more mode change
1153 // 390115e0 seems to indicate we have signal
1154 // changes to 200115e0 when resolution changes/we lose signal, driver resets after a while
1156 // 200015e0 on startup
1157 // changes to 250115e0 when we sync to the signal
1159 // so only first 16 bits count, and 0x0100 is a mask for ok/stable signal?
1161 // Bottom 16 bits of this register seem to be firmware version number (possibly not all all of them).
1163 // 28 and 32 seems to be analog audio input levels (one byte for each of the eight channels).
1164 // however, if setting 32 with HDMI embedded audio, it is immediately overwritten back (to 0xe137002a).
1166 // 4, 8, 20 are unclear. seem to be some sort of bitmask, but we can set them to 0 with no apparent effect.
1167 // perhaps some of them are related to analog output?
1169 // 36 can be set to 0 with no apparent effect (all of this tested on both video and audio),
1170 // but the driver sets it to 0x8036802a at some point.
1172 // all of this is on request 214/215. other requests (192, 219,
1173 // 222, 223, 224) are used for firmware upgrade. Probably best to
1174 // stay out of it unless you know what you're doing.
1178 // first byte is 0x39 for a stable 576p60 signal, 0x2d for a stable 720p60 signal, 0x20 for no signal
1181 // 0x01 - stable signal
1182 // 0x04 - deep color
1183 // 0x08 - unknown (audio??)
1187 update_capture_mode();
1195 static const ctrl ctrls[] = {
1196 { LIBUSB_ENDPOINT_IN, 214, 16, 0 },
1197 { LIBUSB_ENDPOINT_IN, 214, 0, 0 },
1199 //{ LIBUSB_ENDPOINT_OUT, 215, 0, 0x80000100 },
1200 //{ LIBUSB_ENDPOINT_OUT, 215, 0, 0x09000000 },
1201 { LIBUSB_ENDPOINT_OUT, 215, 24, 0x73c60001 }, // latch for frame start?
1202 { LIBUSB_ENDPOINT_IN, 214, 24, 0 }, //
1205 for (unsigned req = 0; req < sizeof(ctrls) / sizeof(ctrls[0]); ++req) {
1206 uint32_t flipped = htonl(ctrls[req].data);
1207 static uint8_t value[4];
1208 memcpy(value, &flipped, sizeof(flipped));
1209 int size = sizeof(value);
1210 //if (ctrls[req].request == 215) size = 0;
1211 rc = libusb_control_transfer(devh, LIBUSB_REQUEST_TYPE_VENDOR | ctrls[req].endpoint,
1212 /*request=*/ctrls[req].request, /*value=*/0, /*index=*/ctrls[req].index, value, size, /*timeout=*/0);
1214 fprintf(stderr, "Error on control %d: %s\n", ctrls[req].index, libusb_error_name(rc));
1218 if (ctrls[req].index == 16 && rc == 4) {
1219 printf("Card firmware version: 0x%02x%02x\n", value[2], value[3]);
1223 printf("rc=%d: ep=%d@%d %d -> 0x", rc, ctrls[req].endpoint, ctrls[req].request, ctrls[req].index);
1224 for (int i = 0; i < rc; ++i) {
1225 printf("%02x", value[i]);
1234 static int my_index = 0;
1235 static uint8_t value[4];
1236 int size = sizeof(value);
1237 rc = libusb_control_transfer(devh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN,
1238 /*request=*/214, /*value=*/0, /*index=*/my_index, value, size, /*timeout=*/0);
1240 fprintf(stderr, "Error on control\n");
1243 printf("rc=%d index=%d: 0x", rc, my_index);
1244 for (int i = 0; i < rc; ++i) {
1245 printf("%02x", value[i]);
1252 // set up an asynchronous transfer of the timer register
1253 static uint8_t cmdbuf[LIBUSB_CONTROL_SETUP_SIZE + 4];
1254 static int completed = 0;
1256 xfr = libusb_alloc_transfer(0);
1257 libusb_fill_control_setup(cmdbuf,
1258 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, /*request=*/214, /*value=*/0,
1259 /*index=*/44, /*length=*/4);
1260 libusb_fill_control_transfer(xfr, devh, cmdbuf, cb_xfr, &completed, 0);
1261 xfr->user_data = this;
1262 libusb_submit_transfer(xfr);
1264 // set up an asynchronous transfer of register 24
1265 static uint8_t cmdbuf2[LIBUSB_CONTROL_SETUP_SIZE + 4];
1266 static int completed2 = 0;
1268 xfr = libusb_alloc_transfer(0);
1269 libusb_fill_control_setup(cmdbuf2,
1270 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, /*request=*/214, /*value=*/0,
1271 /*index=*/24, /*length=*/4);
1272 libusb_fill_control_transfer(xfr, devh, cmdbuf2, cb_xfr, &completed2, 0);
1273 xfr->user_data = this;
1274 libusb_submit_transfer(xfr);
1277 // set up an asynchronous transfer of the register dump
1278 static uint8_t cmdbuf3[LIBUSB_CONTROL_SETUP_SIZE + 4];
1279 static int completed3 = 0;
1281 xfr = libusb_alloc_transfer(0);
1282 libusb_fill_control_setup(cmdbuf3,
1283 LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN, /*request=*/214, /*value=*/0,
1284 /*index=*/current_register, /*length=*/4);
1285 libusb_fill_control_transfer(xfr, devh, cmdbuf3, cb_xfr, &completed3, 0);
1286 xfr->user_data = this;
1287 //libusb_submit_transfer(xfr);
1289 //audiofp = fopen("audio.raw", "wb");
1291 // set up isochronous transfers for audio and video
1292 for (int e = 3; e <= 4; ++e) {
1293 //int num_transfers = (e == 3) ? 6 : 6;
1294 int num_transfers = 6;
1295 for (int i = 0; i < num_transfers; ++i) {
1297 int num_iso_pack, size;
1299 // Allocate for minimum width (because that will give us the most
1300 // number of packets, so we don't need to reallocated, but we'll
1301 // default to 720p for the first frame.
1302 size = find_xfer_size_for_width(MIN_WIDTH);
1303 num_iso_pack = USB_VIDEO_TRANSFER_SIZE / size;
1304 buf_size = USB_VIDEO_TRANSFER_SIZE;
1308 buf_size = num_iso_pack * size;
1310 int num_bytes = num_iso_pack * size;
1311 assert(size_t(num_bytes) <= buf_size);
1312 #if LIBUSB_API_VERSION >= 0x01000105
1313 uint8_t *buf = libusb_dev_mem_alloc(devh, num_bytes);
1315 uint8_t *buf = nullptr;
1317 if (buf == nullptr) {
1318 fprintf(stderr, "Failed to allocate persistent DMA memory ");
1319 #if LIBUSB_API_VERSION >= 0x01000105
1320 fprintf(stderr, "(probably too old kernel; use 4.6.0 or newer).\n");
1322 fprintf(stderr, "(compiled against too old libusb-1.0).\n");
1324 fprintf(stderr, "Will go slower, and likely fail due to memory fragmentation after a few hours.\n");
1325 buf = new uint8_t[num_bytes];
1328 xfr = libusb_alloc_transfer(num_iso_pack);
1330 fprintf(stderr, "oom\n");
1334 int ep = LIBUSB_ENDPOINT_IN | e;
1335 libusb_fill_iso_transfer(xfr, devh, ep, buf, buf_size,
1336 num_iso_pack, cb_xfr, nullptr, 0);
1337 libusb_set_iso_packet_lengths(xfr, size);
1338 xfr->user_data = this;
1341 change_xfer_size_for_width(assumed_frame_width, xfr);
1344 iso_xfrs.push_back(xfr);
1349 void BMUSBCapture::start_bm_capture()
1352 for (libusb_transfer *xfr : iso_xfrs) {
1353 int rc = libusb_submit_transfer(xfr);
1356 //printf("num_bytes=%d\n", num_bytes);
1357 fprintf(stderr, "Error submitting iso to endpoint 0x%02x, number %d: %s\n",
1358 xfr->endpoint, i, libusb_error_name(rc));
1365 libusb_release_interface(devh, 0);
1369 libusb_exit(nullptr);
1374 void BMUSBCapture::stop_dequeue_thread()
1376 dequeue_thread_should_quit = true;
1377 queues_not_empty.notify_all();
1378 dequeue_thread.join();
1381 void BMUSBCapture::start_bm_thread()
1383 // Devices leaving are discovered by seeing the isochronous packets
1384 // coming back with errors, so only care about devices joining.
1385 if (card_connected_callback != nullptr) {
1386 if (libusb_hotplug_register_callback(
1387 nullptr, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, hotplug_existing_devices ? LIBUSB_HOTPLUG_ENUMERATE : LIBUSB_HOTPLUG_NO_FLAGS,
1388 USB_VENDOR_BLACKMAGIC, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
1389 &BMUSBCapture::cb_hotplug, nullptr, nullptr) < 0) {
1390 fprintf(stderr, "libusb_hotplug_register_callback() failed\n");
1395 should_quit = false;
1396 usb_thread = thread(&BMUSBCapture::usb_thread_func);
1399 void BMUSBCapture::stop_bm_thread()
1405 map<uint32_t, VideoMode> BMUSBCapture::get_available_video_modes() const
1407 // The USB3 cards autodetect, and seem to have no provision for forcing modes.
1408 VideoMode auto_mode;
1409 auto_mode.name = "Autodetect";
1410 auto_mode.autodetect = true;
1411 return {{ 0, auto_mode }};
1414 uint32_t BMUSBCapture::get_current_video_mode() const
1416 return 0; // Matches get_available_video_modes().
1419 void BMUSBCapture::set_video_mode(uint32_t video_mode_id)
1421 assert(video_mode_id == 0); // Matches get_available_video_modes().
1424 std::map<uint32_t, std::string> BMUSBCapture::get_available_video_inputs() const
1427 { 0x00000000, "HDMI/SDI" },
1428 { 0x02000000, "Component" },
1429 { 0x04000000, "Composite" },
1430 { 0x06000000, "S-video" }
1434 void BMUSBCapture::set_video_input(uint32_t video_input_id)
1436 assert((video_input_id & ~0x06000000) == 0);
1437 current_video_input = video_input_id;
1438 update_capture_mode();
1441 std::map<uint32_t, std::string> BMUSBCapture::get_available_audio_inputs() const
1444 { 0x00000000, "Embedded" },
1445 { 0x10000000, "Analog" }
1449 void BMUSBCapture::set_audio_input(uint32_t audio_input_id)
1451 assert((audio_input_id & ~0x10000000) == 0);
1452 current_audio_input = audio_input_id;
1453 update_capture_mode();
1456 void BMUSBCapture::update_capture_mode()
1458 // clearing the 0x20000000 bit seems to activate 10-bit capture (v210).
1459 // clearing the 0x08000000 bit seems to change the capture format (other source?)
1460 uint32_t mode = htonl(0x29000000 | current_video_input | current_audio_input);
1462 int rc = libusb_control_transfer(devh, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT,
1463 /*request=*/215, /*value=*/0, /*index=*/0, (unsigned char *)&mode, sizeof(mode), /*timeout=*/0);
1465 fprintf(stderr, "Error on setting mode: %s\n", libusb_error_name(rc));
1470 } // namespace bmusb