Add IS Nitro Driver compatibility

include/CaptureDeviceSpecific/3dscapture_ftd3.hpp

@@ -0,0 +1,17 @@
+#ifndef __3DSCAPTURE_FTD3_HPP
+#define __3DSCAPTURE_FTD3_HPP
+
+#include <vector>
+#include "utils.hpp"
+#include "hw_defs.hpp"
+#include "capture_structs.hpp"
+#include "display_structs.hpp"
+
+void list_devices_ftd3(std::vector<CaptureDevice> &devices_list);
+bool connect_ftd3(bool print_failed, CaptureData* capture_data, CaptureDevice* device);
+void ftd3_capture_main_loop(CaptureData* capture_data);
+void ftd3_capture_cleanup(CaptureData* capture_data);
+void ftd3_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d);
+uint64_t ftd3_get_video_in_size(CaptureData* capture_data);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_acquisition.hpp

@@ -0,0 +1,19 @@
+#ifndef __USB_IS_NITRO_ACQUISITION_HPP
+#define __USB_IS_NITRO_ACQUISITION_HPP
+
+#include <vector>
+#include "utils.hpp"
+#include "hw_defs.hpp"
+#include "capture_structs.hpp"
+#include "display_structs.hpp"
+
+void list_devices_is_nitro(std::vector<CaptureDevice> &devices_list);
+bool is_nitro_connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device);
+void is_nitro_acquisition_main_loop(CaptureData* capture_data);
+void usb_is_nitro_acquisition_cleanup(CaptureData* capture_data);
+void usb_is_nitro_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, CaptureScreensType capture_type);
+uint64_t usb_is_nitro_get_video_in_size(CaptureData* capture_data);
+void usb_is_nitro_init();
+void usb_is_nitro_close();
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_acquisition_capture.hpp

@@ -0,0 +1,11 @@
+#ifndef __USB_IS_NITRO_ACQUISITION_CAPTURE_HPP
+#define __USB_IS_NITRO_ACQUISITION_CAPTURE_HPP
+
+#include "usb_is_nitro_communications.hpp"
+#include "capture_structs.hpp"
+
+int initial_cleanup_capture(const is_nitro_usb_device* usb_device_desc, is_nitro_device_handlers* handlers);
+int EndAcquisitionCapture(is_nitro_device_handlers* handlers, const is_nitro_usb_device* usb_device_desc);
+void is_nitro_acquisition_capture_main_loop(CaptureData* capture_data);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_acquisition_emulator.hpp

@@ -0,0 +1,11 @@
+#ifndef __USB_IS_NITRO_ACQUISITION_EMULATOR_HPP
+#define __USB_IS_NITRO_ACQUISITION_EMULATOR_HPP
+
+#include "usb_is_nitro_communications.hpp"
+#include "capture_structs.hpp"
+
+int initial_cleanup_emulator(const is_nitro_usb_device* usb_device_desc, is_nitro_device_handlers* handlers);
+int EndAcquisitionEmulator(is_nitro_device_handlers* handlers, bool do_drain_frames, int start_frames, CaptureScreensType capture_type, const is_nitro_usb_device* usb_device_desc);
+void is_nitro_acquisition_emulator_main_loop(CaptureData* capture_data);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_acquisition_general.hpp

@@ -0,0 +1,13 @@
+#ifndef __USB_IS_NITRO_ACQUISITION_GENERAL_HPP
+#define __USB_IS_NITRO_ACQUISITION_GENERAL_HPP
+
+#include "usb_is_nitro_communications.hpp"
+#include "capture_structs.hpp"
+#include "display_structs.hpp"
+
+uint64_t _is_nitro_get_video_in_size(CaptureScreensType capture_type);
+int set_acquisition_mode(is_nitro_device_handlers* handlers, CaptureScreensType capture_type, const is_nitro_usb_device* usb_device_desc);
+int EndAcquisition(is_nitro_device_handlers* handlers, bool do_drain_frames, int start_frames, CaptureScreensType capture_type, const is_nitro_usb_device* usb_device_desc);
+int is_nitro_read_frame_and_output(CaptureData* capture_data, int& inner_curr_in, CaptureScreensType curr_capture_type, std::chrono::time_point<std::chrono::high_resolution_clock> &clock_start);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_communications.hpp

@@ -0,0 +1,63 @@
+#ifndef __USB_IS_NITRO_COMMUNICATIONS_HPP
+#define __USB_IS_NITRO_COMMUNICATIONS_HPP
+
+#include <libusb.h>
+#include <vector>
+#include <fstream>
+#include "utils.hpp"
+
+#define IS_NITRO_REAL_SERIAL_NUMBER_SIZE 10
+
+enum is_nitro_forward_config_values_colors {
+	IS_NITRO_FORWARD_CONFIG_COLOR_RGB24 = 0,
+};
+
+enum is_nitro_forward_config_values_screens {
+	IS_NITRO_FORWARD_CONFIG_MODE_BOTH = 0,
+	IS_NITRO_FORWARD_CONFIG_MODE_TOP = 1,
+	IS_NITRO_FORWARD_CONFIG_MODE_BOTTOM = 2,
+};
+
+enum is_nitro_forward_config_values_rate {
+	IS_NITRO_FORWARD_CONFIG_RATE_FULL = 0,
+	IS_NITRO_FORWARD_CONFIG_RATE_HALF = 1,
+	IS_NITRO_FORWARD_CONFIG_RATE_THIRD = 2,
+	IS_NITRO_FORWARD_CONFIG_RATE_QUARTER = 3,
+};
+
+struct is_nitro_usb_device {
+	std::string name;
+	int vid;
+	int pid;
+	int default_config;
+	int default_interface;
+	int bulk_timeout;
+	int ep2_in;
+	int ep1_out;
+	int product_id;
+	int manufacturer_id;
+	bool is_capture;
+};
+
+struct is_nitro_device_handlers {
+	libusb_device_handle* usb_handle;
+	void* read_handle;
+	void* write_handle;
+	void* mutex;
+};
+
+int GetNumISNitroDesc(void);
+const is_nitro_usb_device* GetISNitroDesc(int index);
+int DisableLca2(is_nitro_device_handlers* handlers, const is_nitro_usb_device* device_desc);
+int StartUsbCaptureDma(is_nitro_device_handlers* handlers, const is_nitro_usb_device* device_desc);
+int StopUsbCaptureDma(is_nitro_device_handlers* handlers, const is_nitro_usb_device* device_desc);
+int SetForwardFrameCount(is_nitro_device_handlers* handlers, uint16_t count, const is_nitro_usb_device* device_desc);
+int SetForwardFramePermanent(is_nitro_device_handlers* handlers, const is_nitro_usb_device* device_desc);
+int GetFrameCounter(is_nitro_device_handlers* handlers, uint16_t* out, const is_nitro_usb_device* device_desc);
+int GetDeviceSerial(is_nitro_device_handlers* handlers, uint8_t* buf, const is_nitro_usb_device* device_desc);
+int UpdateFrameForwardConfig(is_nitro_device_handlers* handlers, is_nitro_forward_config_values_colors colors, is_nitro_forward_config_values_screens screens, is_nitro_forward_config_values_rate rate, const is_nitro_usb_device* device_desc);
+int UpdateFrameForwardEnable(is_nitro_device_handlers* handlers, bool enable, bool restart, const is_nitro_usb_device* device_desc);
+int ReadLidState(is_nitro_device_handlers* handlers, uint32_t* out, const is_nitro_usb_device* device_desc);
+int ReadFrame(is_nitro_device_handlers* handlers, uint8_t* buf, int length, const is_nitro_usb_device* device_desc);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_is_driver.hpp

@@ -0,0 +1,14 @@
+#ifndef __USB_IS_NITRO_IS_DRIVER_HPP
+#define __USB_IS_NITRO_IS_DRIVER_HPP
+
+#include <vector>
+#include "capture_structs.hpp"
+#include "usb_is_nitro_communications.hpp"
+
+void is_driver_list_devices(std::vector<CaptureDevice>& devices_list, bool* not_supported_elems, int* curr_serial_extra_id_is_nitro, const size_t num_is_nitro_desc);
+is_nitro_device_handlers* is_driver_serial_reconnection(const is_nitro_usb_device* usb_device_desc, CaptureDevice* device);
+void is_driver_end_connection(is_nitro_device_handlers* handlers);
+int is_driver_bulk_out(is_nitro_device_handlers* handlers, uint8_t* buf, int length, int* transferred);
+int is_driver_bulk_in(is_nitro_device_handlers* handlers, uint8_t* buf, int length, int* transferred);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_libusb.hpp

@@ -0,0 +1,14 @@
+#ifndef __USB_IS_NITRO_LIBUSB_HPP
+#define __USB_IS_NITRO_LIBUSB_HPP
+
+#include <vector>
+#include "capture_structs.hpp"
+#include "usb_is_nitro_communications.hpp"
+
+void is_nitro_libusb_list_devices(std::vector<CaptureDevice>& devices_list, bool* no_access_elems, bool* not_supported_elems, int* curr_serial_extra_id_is_nitro, const size_t num_is_nitro_desc);
+is_nitro_device_handlers* is_nitro_libusb_serial_reconnection(const is_nitro_usb_device* usb_device_desc, CaptureDevice* device, int& curr_serial_extra_id);
+void is_nitro_libusb_end_connection(is_nitro_device_handlers* handlers, const is_nitro_usb_device* device_desc, bool interface_claimed);
+int is_nitro_libusb_bulk_out(is_nitro_device_handlers* handlers, const is_nitro_usb_device* usb_device_desc, uint8_t* buf, int length, int* transferred);
+int is_nitro_libusb_bulk_in(is_nitro_device_handlers* handlers, const is_nitro_usb_device* usb_device_desc, uint8_t* buf, int length, int* transferred);
+
+#endif

include/CaptureDeviceSpecific/ISNitro/usb_is_nitro_setup_general.hpp

@@ -0,0 +1,12 @@
+#ifndef __USB_IS_NITRO_SETUP_GENERAL_HPP
+#define __USB_IS_NITRO_SETUP_GENERAL_HPP
+
+#include <vector>
+#include "capture_structs.hpp"
+#include "usb_is_nitro_communications.hpp"
+
+std::string get_serial(const is_nitro_usb_device* usb_device_desc, is_nitro_device_handlers* handlers, int& curr_serial_extra_id);
+void is_nitro_insert_device(std::vector<CaptureDevice>& devices_list, is_nitro_device_handlers* handlers, const is_nitro_usb_device* usb_device_desc, int& curr_serial_extra_id_is_nitro, std::string path);
+void is_nitro_insert_device(std::vector<CaptureDevice>& devices_list, is_nitro_device_handlers* handlers, const is_nitro_usb_device* usb_device_desc, int& curr_serial_extra_id_is_nitro);
+
+#endif

include/CaptureDeviceSpecific/dscapture_ftd2.hpp

@@ -0,0 +1,17 @@
+#ifndef __DSCAPTURE_FTD2_HPP
+#define __DSCAPTURE_FTD2_HPP
+
+#include <vector>
+#include "utils.hpp"
+#include "hw_defs.hpp"
+#include "capture_structs.hpp"
+#include "display_structs.hpp"
+
+void list_devices_ftd2(std::vector<CaptureDevice> &devices_list);
+bool connect_ftd2(bool print_failed, CaptureData* capture_data, CaptureDevice* device);
+void ftd2_capture_main_loop(CaptureData* capture_data);
+void ftd2_capture_cleanup(CaptureData* capture_data);
+void ftd2_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d);
+uint64_t ftd2_get_video_in_size(CaptureData* capture_data);
+
+#endif

include/CaptureDeviceSpecific/usb_ds_3ds_capture.hpp

@@ -0,0 +1,19 @@
+#ifndef __USB_DS_3DS_CAPTURE_HPP
+#define __USB_DS_3DS_CAPTURE_HPP
+
+#include <vector>
+#include "utils.hpp"
+#include "hw_defs.hpp"
+#include "capture_structs.hpp"
+#include "display_structs.hpp"
+
+void list_devices_usb_ds_3ds(std::vector<CaptureDevice> &devices_list);
+bool connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device);
+void usb_capture_main_loop(CaptureData* capture_data);
+void usb_capture_cleanup(CaptureData* capture_data);
+void usb_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, CaptureDevice* capture_device, bool enabled_3d);
+uint64_t usb_get_video_in_size(CaptureData* capture_data);
+void usb_ds_3ds_init();
+void usb_ds_3ds_close();
+
+#endif

include/CaptureDeviceSpecific/usb_generic.hpp

@@ -0,0 +1,11 @@
+#ifndef __USB_GENERIC_HPP
+#define __USB_GENERIC_HPP
+
+#include <libusb.h>
+
+void usb_init();
+void usb_close();
+bool usb_is_initialized();
+libusb_context* get_usb_ctx();
+
+#endif