Switch to buffer requests without memcpy

include/CaptureDeviceSpecific/3DSCapture_FTD3/3dscapture_ftd3_compatibility.hpp

@@ -4,7 +4,7 @@
 #include "capture_structs.hpp"
 #include "devicecapture.hpp"
 
-#define FTD3_CONCURRENT_BUFFERS 4
+#define FTD3_CONCURRENT_BUFFERS NUM_CONCURRENT_DATA_BUFFER_WRITERS
 
 struct ftd3_device_device_handlers {
 	void* usb_handle = NULL;

include/CaptureDeviceSpecific/3DSCapture_FTD3/3dscapture_ftd3_libusb_comms.hpp

@@ -13,7 +13,6 @@ struct ftd3_async_callback_data {
 	void* actual_user_data;
 	void* transfer_data;
 	std::mutex transfer_data_access;
-	int internal_index;
 };
 
 int ftd3_libusb_ctrl_in(ftd3_device_device_handlers* handlers, uint32_t timeout, uint8_t* buf, int length, uint8_t request, uint16_t value, uint16_t index, int* transferred);

include/CaptureDeviceSpecific/3DSCapture_FTD3/3dscapture_ftd3_shared_general.hpp

@@ -8,6 +8,6 @@
 uint64_t ftd3_get_capture_size(CaptureData* capture_data);
 std::string ftd3_get_serial(std::string serial_string, int &curr_serial_extra_id);
 void ftd3_insert_device(std::vector<CaptureDevice> &devices_list, std::string serial_string, int &curr_serial_extra_id, bool is_driver);
-void data_output_update(CaptureReceived* received_buffer, size_t read_data, CaptureData* capture_data, std::chrono::time_point<std::chrono::high_resolution_clock> &base_time);
+void data_output_update(int inner_index, size_t read_data, CaptureData* capture_data, std::chrono::time_point<std::chrono::high_resolution_clock> &base_time);
 
 #endif

include/CaptureDeviceSpecific/DSCapture_FTD2/dscapture_ftd2_general.hpp

@@ -8,14 +8,11 @@
 #include <chrono>
 
 // Sometimes the CC returns a 2 length packet, if you're too fast
-#define BASE_NUM_CAPTURE_RECEIVED_DATA_BUFFERS 4
-#define NUM_CAPTURE_RECEIVED_DATA_0_MULTIPLIER 2
-#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS (BASE_NUM_CAPTURE_RECEIVED_DATA_BUFFERS * NUM_CAPTURE_RECEIVED_DATA_0_MULTIPLIER)
+#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS NUM_CONCURRENT_DATA_BUFFER_WRITERS
 
 typedef void (*fdt2_async_callback_function)(void* user_data, int transfer_length, int transfer_status);
 
 struct ftd2_async_callback_data {
-	FTD2OldDSCaptureReceivedRaw buffer_raw;
 	fdt2_async_callback_function function;
 	void* actual_user_data;
 	void* transfer_data;
@@ -34,6 +31,8 @@ struct FTD2CaptureReceivedData {
 	int* status;
 	uint32_t index;
 	uint32_t* last_used_index;
+	uint8_t* buffer_raw;
+	uint32_t* buffer_target;
 	size_t* curr_offset;
 	CaptureData* capture_data;
 	std::chrono::time_point<std::chrono::high_resolution_clock>* clock_start;

include/CaptureDeviceSpecific/ISDevices/usb_is_device_acquisition_general.hpp

@@ -6,12 +6,11 @@
 #include "capture_structs.hpp"
 #include "display_structs.hpp"
 
-#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS 4
+#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS NUM_CONCURRENT_DATA_BUFFER_WRITERS
 
 struct ISDeviceCaptureReceivedData {
 	volatile bool in_use;
 	uint32_t index;
-	CaptureReceived buffer;
 	SharedConsumerMutex* is_buffer_free_shared_mutex;
 	int* status;
 	uint32_t* last_index;
@@ -24,10 +23,10 @@ struct ISDeviceCaptureReceivedData {
 int set_acquisition_mode(is_device_device_handlers* handlers, CaptureScreensType capture_type, CaptureSpeedsType capture_speed, const is_device_usb_device* usb_device_desc);
 int EndAcquisition(CaptureData* capture_data, ISDeviceCaptureReceivedData* is_device_capture_recv_data, bool do_drain_frames, int start_frames, CaptureScreensType capture_type);
 int EndAcquisition(const is_device_usb_device* usb_device_desc, is_device_device_handlers* handlers, bool do_drain_frames, int start_frames, CaptureScreensType capture_type);
-int is_device_read_frame_and_output(CaptureData* capture_data, CaptureReceived* capture_buf, CaptureScreensType curr_capture_type, std::chrono::time_point<std::chrono::high_resolution_clock> &clock_start);
+int is_device_read_frame_and_output(CaptureData* capture_data, int internal_index, CaptureScreensType curr_capture_type, std::chrono::time_point<std::chrono::high_resolution_clock> &clock_start);
 void is_device_read_frame_request(CaptureData* capture_data, ISDeviceCaptureReceivedData* is_device_capture_recv_data, CaptureScreensType curr_capture_type, uint32_t index);
 uint64_t usb_is_device_get_video_in_size(CaptureScreensType capture_type, is_device_type device_type);
-void output_to_thread(CaptureData* capture_data, CaptureReceived* capture_buf, CaptureScreensType curr_capture_type, std::chrono::time_point<std::chrono::high_resolution_clock>* clock_start, size_t read_size);
+void output_to_thread(CaptureData* capture_data, int internal_index, CaptureScreensType curr_capture_type, std::chrono::time_point<std::chrono::high_resolution_clock>* clock_start, size_t read_size);
 
 ISDeviceCaptureReceivedData* is_device_get_free_buffer(CaptureData* capture_data, ISDeviceCaptureReceivedData* is_device_capture_recv_data);
 bool is_device_are_buffers_all_free(ISDeviceCaptureReceivedData* is_device_capture_recv_data);

include/CaptureDeviceSpecific/Nisetro/cypress_nisetro_acquisition_general.hpp

@@ -3,12 +3,11 @@
 
 #include "cypress_nisetro_communications.hpp"
 
-#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS 4
+#define NUM_CAPTURE_RECEIVED_DATA_BUFFERS NUM_CONCURRENT_DATA_BUFFER_WRITERS
 
 struct CypressDeviceCaptureReceivedData {
 	volatile bool in_use;
 	uint32_t index;
-	CaptureReceived buffer;
 	SharedConsumerMutex* is_buffer_free_shared_mutex;
 	size_t* scheduled_special_read;
 	uint32_t* active_special_read_index;
@@ -20,7 +19,6 @@ struct CypressDeviceCaptureReceivedData {
 	int* consecutive_output_to_thread;
 	CaptureData* capture_data;
 	std::chrono::time_point<std::chrono::high_resolution_clock>* clock_start;
-	CaptureScreensType curr_capture_type;
 	cyni_async_callback_data cb_data;
 };
 

include/capture_structs.hpp

@@ -26,12 +26,13 @@ enum CaptureScreensType { CAPTURE_SCREENS_BOTH, CAPTURE_SCREENS_TOP, CAPTURE_SCR
 enum CaptureSpeedsType { CAPTURE_SPEEDS_FULL, CAPTURE_SPEEDS_HALF, CAPTURE_SPEEDS_THIRD, CAPTURE_SPEEDS_QUARTER, CAPTURE_SPEEDS_ENUM_END };
 
 // Readers are Audio and Video. So 2.
-// Use 2 extra buffers. One for writing in case the other 2 are busy,
+// Use 6 extra buffers. 5 for async writing in case the other 2 are busy,
 // and the other for writing without overwriting the latest stuff in
 // a worst case scenario...
 enum CaptureReaderType { CAPTURE_READER_VIDEO, CAPTURE_READER_AUDIO, CAPTURE_READER_ENUM_END };
+#define NUM_CONCURRENT_DATA_BUFFER_WRITERS 5
 #define NUM_CONCURRENT_DATA_BUFFER_READERS ((int)CAPTURE_READER_ENUM_END)
-#define NUM_CONCURRENT_DATA_BUFFERS (NUM_CONCURRENT_DATA_BUFFER_READERS + 2)
+#define NUM_CONCURRENT_DATA_BUFFERS (NUM_CONCURRENT_DATA_BUFFER_READERS + 1 + NUM_CONCURRENT_DATA_BUFFER_WRITERS)
 
 #pragma pack(push, 1)
 
@@ -149,6 +150,11 @@ struct ALIGNED(16) PACKED ISTWLCaptureReceived {
 
 #pragma pack(pop)
 
+struct ALIGNED(16) FTD2OldDSCaptureReceivedNormalPlusRaw {
+	FTD2OldDSCaptureReceived data;
+	FTD2OldDSCaptureReceivedRaw raw_data;
+};
+
 union CaptureReceived {
 	FTD3_3DSCaptureReceived ftd3_received;
 	FTD3_3DSCaptureReceived_3D ftd3_received_3d;
@@ -156,7 +162,7 @@ union CaptureReceived {
 	USB3DSCaptureReceived_3D usb_received_3ds_3d;
 	USBOldDSCaptureReceived usb_received_old_ds;
 	FTD2OldDSCaptureReceived ftd2_received_old_ds;
-	FTD2OldDSCaptureReceivedRaw ftd2_received_old_ds_raw;
+	FTD2OldDSCaptureReceivedNormalPlusRaw ftd2_received_old_ds_normal_plus_raw;
 	ISNitroCaptureReceived is_nitro_capture_received;
 	ISTWLCaptureReceived is_twl_capture_received;
 	CypressNisetroDSCaptureReceived cypress_nisetro_capture_received;
@@ -215,6 +221,7 @@ struct CaptureStatus {
 struct CaptureDataSingleBuffer {
 	CaptureScreensType capture_type;
 	uint64_t read;
+	size_t unused_offset;
 	CaptureReceived capture_buf;
 	double time_in_buf;
 	uint32_t inner_index;
@@ -225,16 +232,18 @@ public:
 	CaptureDataBuffers();
 	CaptureDataSingleBuffer* GetReaderBuffer(CaptureReaderType reader_type);
 	void ReleaseReaderBuffer(CaptureReaderType reader_type);
-	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, CaptureScreensType capture_type = CAPTURE_SCREENS_BOTH, size_t offset = 0);
-	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, size_t offset);
-	CaptureDataSingleBuffer* GetWriterBuffer();
-	void ReleaseWriterBuffer();
+	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, CaptureScreensType capture_type, size_t offset, int index);
+	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, CaptureScreensType capture_type, int index);
+	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, size_t offset, int index);
+	void WriteToBuffer(CaptureReceived* buffer, uint64_t read, double time_in_buf, CaptureDevice* device, int index);
+	CaptureDataSingleBuffer* GetWriterBuffer(int index = 0);
+	void ReleaseWriterBuffer(int index = 0, bool update_last_curr_in = true);
 private:
-	uint32_t inner_index = 0;
 	std::mutex access_mutex;
 	int last_curr_in;
-	int curr_writer_pos;
+	int curr_writer_pos[NUM_CONCURRENT_DATA_BUFFER_WRITERS];
 	int curr_reader_pos[NUM_CONCURRENT_DATA_BUFFER_READERS];
+	bool is_being_written_to[NUM_CONCURRENT_DATA_BUFFERS];
 	int num_readers[NUM_CONCURRENT_DATA_BUFFERS];
 	bool has_read_data[NUM_CONCURRENT_DATA_BUFFERS][NUM_CONCURRENT_DATA_BUFFER_READERS];
 	CaptureDataSingleBuffer buffers[NUM_CONCURRENT_DATA_BUFFERS];