X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=bmusb.cpp;h=74adca86c14c603c2c0855c41ba319849365638a;hb=89136643760d7da0c94c4d4fb1ec778f9cefb97f;hp=e55d85d5acc07e5c891e944b59db2b4db4deb0d0;hpb=ffdf54bcfe1ad3baaa9e193da4073af3d1230073;p=bmusb

diff --git a/bmusb.cpp b/bmusb.cpp
index e55d85d..74adca8 100644
--- a/bmusb.cpp
+++ b/bmusb.cpp
@@ -120,6 +120,7 @@ bool uint16_less_than_with_wraparound(uint16_t a, uint16_t b)
 
 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);
@@ -131,11 +132,7 @@ void BMUSBCapture::queue_frame(uint16_t format, uint16_t timecode, FrameAllocato
 	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
 }
 
@@ -162,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);
@@ -638,8 +639,9 @@ void BMUSBCapture::cb_xfr(struct libusb_transfer *xfr)
 	}
 #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);
 	}
 }
@@ -659,6 +661,80 @@ void BMUSBCapture::usb_thread_func()
 	}
 }
 
+struct USBCardDevice {
+	uint16_t product;
+	uint8_t bus, port;
+	libusb_device *device;
+};
+
+libusb_device_handle *open_card(int card_index)
+{	
+	libusb_device **devices;
+	ssize_t num_devices = libusb_get_device_list(nullptr, &devices);
+	if (num_devices == -1) {
+		fprintf(stderr, "Error finding USB devices\n");
+		exit(1);
+	}
+	vector<USBCardDevice> found_cards;
+	for (ssize_t i = 0; i < num_devices; ++i) {
+		libusb_device_descriptor desc;
+                if (libusb_get_device_descriptor(devices[i], &desc) < 0) {
+			fprintf(stderr, "Error getting device descriptor for device %d\n", int(i));
+			exit(1);
+		}
+
+		uint8_t bus = libusb_get_bus_number(devices[i]);
+		uint8_t port = libusb_get_port_number(devices[i]);
+
+		if (!(desc.idVendor == 0x1edb && desc.idProduct == 0xbd3b) &&
+		    !(desc.idVendor == 0x1edb && desc.idProduct == 0xbd4f)) {
+			libusb_unref_device(devices[i]);
+			continue;
+		}
+
+		found_cards.push_back({ desc.idProduct, bus, port, devices[i] });
+	}
+	libusb_free_device_list(devices, 0);
+
+	// Sort the devices to get a consistent ordering.
+	sort(found_cards.begin(), found_cards.end(), [](const USBCardDevice &a, const USBCardDevice &b) {
+		if (a.product != b.product)
+			return a.product < b.product;
+		if (a.bus != b.bus)
+			return a.bus < b.bus;
+		return a.port < b.port;
+	});
+
+	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);
+		if (found_cards[i].product == 0xbd3b) {
+			fprintf(stderr, "Intensity Shuttle\n");
+		} else if (found_cards[i].product == 0xbd4f) {
+			fprintf(stderr, "UltraStudio SDI\n");
+		} else {
+			assert(false);
+		}
+	}
+
+	if (size_t(card_index) >= found_cards.size()) {
+		fprintf(stderr, "Could not open card %d (only %d found)\n", card_index, int(found_cards.size()));
+		exit(1);
+	}
+
+	libusb_device_handle *devh;
+	int rc = libusb_open(found_cards[card_index].device, &devh);
+	if (rc < 0) {
+		fprintf(stderr, "Error opening card %d: %s\n", card_index, libusb_error_name(rc));
+		exit(1);
+	}
+
+	for (size_t i = 0; i < found_cards.size(); ++i) {
+		libusb_unref_device(found_cards[i].device);
+	}
+
+	return devh;
+}
+
 void BMUSBCapture::configure_card()
 {
 	if (video_frame_allocator == nullptr) {
@@ -679,9 +755,7 @@ void BMUSBCapture::configure_card()
 		exit(1);
 	}
 
-	//struct libusb_device_handle *devh = libusb_open_device_with_vid_pid(nullptr, 0x1edb, 0xbd3b);
-	//struct libusb_device_handle *devh = libusb_open_device_with_vid_pid(nullptr, 0x1edb, 0xbd4f);
-	struct libusb_device_handle *devh = libusb_open_device_with_vid_pid(nullptr, vid, pid);
+	libusb_device_handle *devh = open_card(card_index);
 	if (!devh) {
 		fprintf(stderr, "Error finding USB device\n");
 		exit(1);
@@ -732,7 +806,7 @@ void BMUSBCapture::configure_card()
 	}
 	rc = libusb_set_interface_alt_setting(devh, /*interface=*/0, /*alternate_setting=*/2);
 	if (rc < 0) {
-		fprintf(stderr, "Error setting alternate 1: %s\n", libusb_error_name(rc));
+		fprintf(stderr, "Error setting alternate 2: %s\n", libusb_error_name(rc));
 		exit(1);
 	}
 #if 0
@@ -905,7 +979,7 @@ void BMUSBCapture::configure_card()
 	// 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) {
@@ -919,7 +993,7 @@ void BMUSBCapture::configure_card()
 					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;
@@ -989,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;
+}