From 0240e53681e50c1b23774551176c4963ac5ec3e1 Mon Sep 17 00:00:00 2001 From: Lorenzooone Date: Sun, 6 Apr 2025 23:11:34 +0200 Subject: [PATCH] Old Optimize CC output --- CMakeLists.txt | 37 ++- bin/optimize_old_3ds_565_fpga_pl.bin | Bin 0 -> 109306 bytes bin/optimize_old_3ds_888_fpga_pl.bin | Bin 0 -> 109306 bytes bin/optimize_old_3ds_fw.bin | Bin 0 -> 2920 bytes .../cypress_shared_driver_comms.hpp | 2 +- .../cypress_optimize_3ds_acquisition.hpp | 20 ++ ...press_optimize_3ds_acquisition_general.hpp | 10 + .../cypress_optimize_3ds_communications.hpp | 48 ++++ .../cypress_optimize_new_3ds_acquisition.hpp | 20 -- ...s_optimize_new_3ds_acquisition_general.hpp | 10 - ...ypress_optimize_new_3ds_communications.hpp | 49 ---- include/capture_structs.hpp | 82 +++---- .../cypress_shared_driver_comms.cpp | 6 +- .../cypress_optimize_3ds_acquisition.cpp} | 226 +++++++++--------- .../cypress_optimize_3ds_communications.cpp} | 225 +++++++++++------ source/conversions.cpp | 88 ++++--- source/devicecapture.cpp | 40 ++-- 17 files changed, 486 insertions(+), 377 deletions(-) create mode 100644 bin/optimize_old_3ds_565_fpga_pl.bin create mode 100644 bin/optimize_old_3ds_888_fpga_pl.bin create mode 100644 bin/optimize_old_3ds_fw.bin create mode 100644 include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.hpp create mode 100644 include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition_general.hpp create mode 100644 include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.hpp delete mode 100644 include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.hpp delete mode 100644 include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition_general.hpp delete mode 100644 include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.hpp rename source/CaptureDeviceSpecific/{Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.cpp => Optimize_3DS/cypress_optimize_3ds_acquisition.cpp} (67%) rename source/CaptureDeviceSpecific/{Optimize_New_3DS/cypress_optimize_new_3ds_communications.cpp => Optimize_3DS/cypress_optimize_3ds_communications.cpp} (67%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 83578f8..8db55f0 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,13 +11,13 @@ set(NEW_DS_LOOPY_SUPPORT 1) set(IS_DEVICES_SUPPORT 1) set(OLD_DS_3DS_LOOPY_SUPPORT 1) set(CYPRESS_NISETRO_SUPPORT 1) -set(OPTIMIZE_NEW3DS_SUPPORT 1) +set(OPTIMIZE_3DS_SUPPORT 1) set(USE_FTD2XX_FOR_NEW_DS_LOOPY ${NEW_DS_LOOPY_SUPPORT}) set(USE_LIBUSB_FOR_NEW_DS_LOOPY ${NEW_DS_LOOPY_SUPPORT}) set(USE_FTD3XX_FOR_N3DSXL_LOOPY ${N3DSXL_LOOPY_SUPPORT}) set(USE_LIBUSB_FOR_N3DSXL_LOOPY ${N3DSXL_LOOPY_SUPPORT}) -set(USE_CYPRESS_USB_SUPPORT ${CYPRESS_NISETRO_SUPPORT} OR ${OPTIMIZE_NEW3DS_SUPPORT}) +set(USE_CYPRESS_USB_SUPPORT ${CYPRESS_NISETRO_SUPPORT} OR ${OPTIMIZE_3DS_SUPPORT}) set(USE_LIBUSB_SUPPORT ${IS_DEVICES_SUPPORT} OR ${OLD_DS_3DS_LOOPY_SUPPORT} OR ${USE_LIBUSB_FOR_NEW_DS_LOOPY} OR ${USE_LIBUSB_FOR_N3DSXL_LOOPY} OR ${USE_CYPRESS_USB_SUPPORT}) if(NOT (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")) #Performance outside of Windows is very bad for the official drivers... @@ -307,7 +307,7 @@ set(SOURCE_CPP_FTD2_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/DSCapt set(SOURCE_CPP_FTD3_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/3DSCapture_FTD3") set(SOURCE_CPP_CYPRESS_USB_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/CypressShared") set(SOURCE_CPP_CYPRESS_NISETRO_DEVICES_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/Nisetro") -set(SOURCE_CPP_CYPRESS_NEW_OPTIMIZE_3DS_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/Optimize_New_3DS") +set(SOURCE_CPP_CYPRESS_OPTIMIZE_3DS_FILES_BASE_PATH "${SOURCE_CPP_DEVICE_FILES_BASE_PATH}/Optimize_3DS") if(N3DSXL_LOOPY_SUPPORT) list(APPEND SOURCE_CPP_EXTRA_FILES ${SOURCE_CPP_FTD3_FILES_BASE_PATH}/3dscapture_ftd3_shared.cpp ${SOURCE_CPP_FTD3_FILES_BASE_PATH}/3dscapture_ftd3_compatibility.cpp) if(MSVC) @@ -370,12 +370,12 @@ if(CYPRESS_NISETRO_SUPPORT) list(APPEND EXTRA_CXX_FLAGS "-DUSE_CYNI_USB") endif() endif() -if(OPTIMIZE_NEW3DS_SUPPORT) - list(APPEND SOURCE_CPP_EXTRA_FILES ${SOURCE_CPP_CYPRESS_NEW_OPTIMIZE_3DS_FILES_BASE_PATH}/cypress_optimize_new_3ds_communications.cpp ${SOURCE_CPP_CYPRESS_NEW_OPTIMIZE_3DS_FILES_BASE_PATH}/cypress_optimize_new_3ds_acquisition.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_fw.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_565_fpga_pl.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_888_fpga_pl.cpp) +if(OPTIMIZE_3DS_SUPPORT) + list(APPEND SOURCE_CPP_EXTRA_FILES ${SOURCE_CPP_CYPRESS_OPTIMIZE_3DS_FILES_BASE_PATH}/cypress_optimize_3ds_communications.cpp ${SOURCE_CPP_CYPRESS_OPTIMIZE_3DS_FILES_BASE_PATH}/cypress_optimize_3ds_acquisition.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_fw.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_565_fpga_pl.cpp ${TOOLS_DATA_DIR}/optimize_new_3ds_888_fpga_pl.cpp ${TOOLS_DATA_DIR}/optimize_old_3ds_fw.cpp ${TOOLS_DATA_DIR}/optimize_old_3ds_565_fpga_pl.cpp ${TOOLS_DATA_DIR}/optimize_old_3ds_888_fpga_pl.cpp) if(MSVC) - list(APPEND EXTRA_CXX_FLAGS "/DUSE_CYPRESS_NEW_OPTIMIZE") + list(APPEND EXTRA_CXX_FLAGS "/DUSE_CYPRESS_OPTIMIZE") else() - list(APPEND EXTRA_CXX_FLAGS "-DUSE_CYPRESS_NEW_OPTIMIZE") + list(APPEND EXTRA_CXX_FLAGS "-DUSE_CYPRESS_OPTIMIZE") endif() endif() if(NEW_DS_LOOPY_SUPPORT) @@ -537,7 +537,7 @@ endif() if(USE_FTD2XX_FOR_NEW_DS_LOOPY) target_link_libraries(${OUTPUT_NAME} PRIVATE ${ftd2xx_BINARY_DIR}/${FTD2XX_SUBFOLDER}/${FTD2XX_LIB}) endif() -target_include_directories(${OUTPUT_NAME} PRIVATE ${EXTRA_INCLUDE_DIRECTORIES} ${TOOLS_DATA_DIR} ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/include/Menus ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/ISDevices ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/Nisetro ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/Optimize_New_3DS ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/CypressShared ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/3DSCapture_FTD3 ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/DSCapture_FTD2) +target_include_directories(${OUTPUT_NAME} PRIVATE ${EXTRA_INCLUDE_DIRECTORIES} ${TOOLS_DATA_DIR} ${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/include/Menus ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/ISDevices ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/Nisetro ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/Optimize_3DS ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/CypressShared ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/3DSCapture_FTD3 ${CMAKE_SOURCE_DIR}/include/CaptureDeviceSpecific/DSCapture_FTD2) target_compile_features(${OUTPUT_NAME} PRIVATE cxx_std_20) target_compile_options(${OUTPUT_NAME} PRIVATE ${EXTRA_CXX_FLAGS}) @@ -604,6 +604,27 @@ add_custom_command( DEPENDS ${CMAKE_SOURCE_DIR}/bin/optimize_new_3ds_888_fpga_pl.bin ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} ) +add_custom_command( + OUTPUT ${TOOLS_DATA_DIR}/optimize_old_3ds_fw.cpp + COMMENT "Convert fw binary to C - Optimize Old 3DS" + COMMAND ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_fw.bin ${TOOLS_DATA_DIR} optimize_old_3ds_fw optimize_old_3ds_fw + DEPENDS ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_fw.bin ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} +) + +add_custom_command( + OUTPUT ${TOOLS_DATA_DIR}/optimize_old_3ds_565_fpga_pl.cpp + COMMENT "Convert FPGA 565 PL binary to C - Optimize Old 3DS" + COMMAND ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_565_fpga_pl.bin ${TOOLS_DATA_DIR} optimize_old_3ds_565_fpga_pl optimize_old_3ds_565_fpga_pl + DEPENDS ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_565_fpga_pl.bin ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} +) + +add_custom_command( + OUTPUT ${TOOLS_DATA_DIR}/optimize_old_3ds_888_fpga_pl.cpp + COMMENT "Convert FPGA 888 PL binary to C - Optimize Old 3DS" + COMMAND ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_888_fpga_pl.bin ${TOOLS_DATA_DIR} optimize_old_3ds_888_fpga_pl optimize_old_3ds_888_fpga_pl + DEPENDS ${CMAKE_SOURCE_DIR}/bin/optimize_old_3ds_888_fpga_pl.bin ${TOOLS_DATA_DIR}/CMakeBin2C${HOST_FINAL_EXTENSION} +) + set(SHADERS_LIST "") list(APPEND SHADERS_LIST ${CMAKE_SOURCE_DIR}/shaders/bit_crusher_fragment_shader.2_to_x_1_7.frag ${CMAKE_SOURCE_DIR}/shaders/bit_merger_crusher_fragment_shader.2_to_x_1_6.frag ${CMAKE_SOURCE_DIR}/shaders/bit_merger_crusher_fragment_shader_7.frag ${CMAKE_SOURCE_DIR}/shaders/bit_merger_fragment_shader.2_to_x_0_6.frag ${CMAKE_SOURCE_DIR}/shaders/bit_merger_fragment_shader_7.frag ${CMAKE_SOURCE_DIR}/shaders/frame_blending_bit_crusher_fragment_shader.2_to_x_1_7.frag ${CMAKE_SOURCE_DIR}/shaders/frame_blending_fragment_shader.frag ${CMAKE_SOURCE_DIR}/shaders/no_effect_fragment_shader.frag ${CMAKE_SOURCE_DIR}/shaders/color_emulation_fragment_shader.frag) diff --git a/bin/optimize_old_3ds_565_fpga_pl.bin b/bin/optimize_old_3ds_565_fpga_pl.bin new file mode 100644 index 0000000000000000000000000000000000000000..a8f565301b5f2369d7291bd4f8cfb9fd7ae90449 GIT binary patch literal 109306 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 literal 0 HcmV?d00001 diff --git a/bin/optimize_old_3ds_888_fpga_pl.bin b/bin/optimize_old_3ds_888_fpga_pl.bin new file mode 100644 index 0000000000000000000000000000000000000000..331122245520c210e8871bbddff0331272287ec7 GIT binary patch literal 109306 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 X?~i$be9ip`#-i$Mmu0MMYySTMgrcy~ literal 0 HcmV?d00001 diff --git a/bin/optimize_old_3ds_fw.bin b/bin/optimize_old_3ds_fw.bin new file mode 100644 index 0000000000000000000000000000000000000000..7a6679d08dd711314c66a665be41f5713a93f0ca GIT binary patch literal 2920 zcmcImeQaCR6~FJp@z(<3C1IpN!*O1k!j>kslQ!RRh=at2(n#@O8$RMkvms0X7PC+FBsWMpKm{N>^=`J+zGe(azzIPOQtT^xjJwX!C@)ZPKas&U?=( zp#6i8X8U)~@0@$?JLlbZ?s+aj6gp)^@L>>b+v7BebE~gN9`7@W6%B0=45Yw_>ibfd zp{bqMKI6{PoZ+6`^{* zBs{2W6V-P#WjpTVoIQixO1Gi*;0C4DU~RZoX*XC0t`gM~Qh{^SzEyI_I!vwH`-4#F zWqoc{RF7#8f~J%3s@la(&sEVh<4Paa$Rv1Il;){3$`Poql)1&Cqf&8T%{P#&zaCVcJJX`R+B;{B61BJ`Y z>P(cxq#&iQms6UkP6M73=we=+bNGwk`OvLAt#1x&$_eQhWyv7mkh-phfB21q=OHBI zjmyi+gLf39;LVMq8q=hJOT)jyJ2~g*;4eiLZa#0^`G6Um%^@7r=`K2SA8z}G!Evdm z?#DLHF)(NaCIu+S1q9aIqIy7TI?vGTW>I}!B3@yc>=iJ1_37oO(qqe@?Gw@@DHGqk zx6-=`#l*sc9+rrQvp>ch^)r9(WuCd8+4}%9^CRZ zT@I#U<1Jev4Jfh|CmLs(vVu5Q5NyfQJbk(u<>i?zvomzOyb-eN+nAp%i~A1-i7{e2(Sp3!;jp;8krX zv6f*t`n@K~!XccYnwZZxYku$&7#+WMp<6{YDm5*$lIuM57oaLoN#^WVIcEg_ZInKj zU%KWV-IbX_xv6vOOT=xNglDG@!_u0x{xll4Wu^|sR?4qkDBm-&cCma9Ue8T^{K<-C zQnO4heO!Q(VR&YyZaCzo*8l(7(lkUyQgAuIX)-wql_>P(|^+c2S5H<^*asT$)PFt^r9)7t)ejpl2Tqt)@~byky3V zcecj6z8tK%J>K%a!OAv*HL-R*&45G0@ZJPs)5iZbX5p;I^`bApiQ8!=XtXRix6p_r zXhf>hpy#XL4xxBpA*GF1j3Hwo_~teDA?soPeD6#&5lczCnDDpXrm8N5DYtHrMo{DR zPrLK;7Q7_q^+xo*#5aaY*)Y6%S*g%x#n@)BA?r9i+f@zIi|(uuK9Gi_CbYgOO0N*) z77&>fufINGNh#6(Sa`j7Y;#m`U#X2-H8&{76z#UJ+KX0t!&>GrF8`&0vLh6EmQoVI zs{tEH$fP>AJ9o$pf4G!Q8gv!o4;QN~8W!7EENMxp4$+m>k!e?C_dlSCh)Su{B-2?q sPjG~2hGAKY1+Ed+B1dCzn& devices_list, bool* not_supported_elems, int* curr_serial_extra_id_cypress, std::vector &device_descriptions, CypressWindowsDriversEnum driver); void cypress_driver_find_used_serial(const cy_device_usb_device* usb_device_desc, bool* found, size_t num_free_fw_ids, int &curr_serial_extra_id, CypressWindowsDriversEnum driver); diff --git a/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.hpp b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.hpp new file mode 100644 index 0000000..d275ddd --- /dev/null +++ b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.hpp @@ -0,0 +1,20 @@ +#ifndef __CYPRESS_OPTIMIZE_3DS_ACQUISITION_HPP +#define __CYPRESS_OPTIMIZE_3DS_ACQUISITION_HPP + +#include +#include "utils.hpp" +#include "hw_defs.hpp" +#include "capture_structs.hpp" +#include "display_structs.hpp" +#include "devicecapture.hpp" + +void list_devices_cyop_device(std::vector &devices_list, std::vector &no_access_list); +bool cyop_device_connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device); +uint64_t cyop_device_get_video_in_size(CaptureStatus* status, bool is_3d, InputVideoDataType video_data_type); +uint64_t cyop_device_get_video_in_size(CaptureData* capture_data, bool is_3d, InputVideoDataType video_data_type); +void cyop_device_acquisition_main_loop(CaptureData* capture_data); +void usb_cyop_device_acquisition_cleanup(CaptureData* capture_data); +void usb_cyop_device_init(); +void usb_cyop_device_close(); + +#endif diff --git a/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition_general.hpp b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition_general.hpp new file mode 100644 index 0000000..daca753 --- /dev/null +++ b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition_general.hpp @@ -0,0 +1,10 @@ +#ifndef __CYPRESS_OPTIMIZE_3DS_ACQUISITION_GENERAL_HPP +#define __CYPRESS_OPTIMIZE_3DS_ACQUISITION_GENERAL_HPP + +#include "cypress_shared_communications.hpp" +#include "cypress_optimize_3ds_communications.hpp" + +std::string cypress_optimize_3ds_get_serial(const void* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id); +CaptureDevice cypress_optimize_3ds_create_device(const void* usb_device_desc, std::string serial, std::string path); + +#endif diff --git a/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.hpp b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.hpp new file mode 100644 index 0000000..5b94687 --- /dev/null +++ b/include/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.hpp @@ -0,0 +1,48 @@ +#ifndef __CYPRESS_OPTIMIZE_3DS_DEVICE_COMMUNICATIONS_HPP +#define __CYPRESS_OPTIMIZE_3DS_DEVICE_COMMUNICATIONS_HPP + +#include +#include +#include +#include +#include "utils.hpp" +#include "capture_structs.hpp" +#include "cypress_shared_communications.hpp" + +enum cypress_optimize_device_type { + CYPRESS_OPTIMIZE_NEW_3DS_BLANK_DEVICE, + CYPRESS_OPTIMIZE_NEW_3DS_INSTANTIATED_DEVICE, + CYPRESS_OPTIMIZE_OLD_3DS_BLANK_DEVICE, + CYPRESS_OPTIMIZE_OLD_3DS_INSTANTIATED_DEVICE, +}; + +struct cyop_device_usb_device { + std::string name; + std::string long_name; + cypress_optimize_device_type device_type; + uint8_t* firmware_to_load; + size_t firmware_size; + uint8_t* fpga_pl_565; + size_t fpga_pl_565_size; + uint8_t* fpga_pl_888; + size_t fpga_pl_888_size; + bool is_new_device; + cypress_optimize_device_type next_device; + bool has_bcd_device_serial; + cy_device_usb_device usb_device_info; +}; + + +int GetNumCyOpDeviceDesc(void); +const cyop_device_usb_device* GetCyOpDeviceDesc(int index); +const cyop_device_usb_device* GetNextDeviceDesc(const cyop_device_usb_device* device); +const cy_device_usb_device* get_cy_usb_info(const cyop_device_usb_device* usb_device_desc); +bool has_to_load_firmware(const cyop_device_usb_device* device); +bool load_firmware(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint8_t patch_id); +int capture_start(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, bool is_first_load, bool is_rgb888); +int StartCaptureDma(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, bool is_rgb888); +int capture_end(cy_device_device_handlers* handlers, const cyop_device_usb_device* device); +int ReadFrame(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyop_device_usb_device* device_desc); +int ReadFrameAsync(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyop_device_usb_device* device_desc, cy_async_callback_data* cb_data); + +#endif diff --git a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.hpp b/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.hpp deleted file mode 100644 index f37eca6..0000000 --- a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef __CYPRESS_OPTIMIZE_NEW_3DS_ACQUISITION_HPP -#define __CYPRESS_OPTIMIZE_NEW_3DS_ACQUISITION_HPP - -#include -#include "utils.hpp" -#include "hw_defs.hpp" -#include "capture_structs.hpp" -#include "display_structs.hpp" -#include "devicecapture.hpp" - -void list_devices_cyopn_device(std::vector &devices_list, std::vector &no_access_list); -bool cyopn_device_connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device); -uint64_t cyopn_device_get_video_in_size(CaptureStatus* status, bool is_3d, InputVideoDataType video_data_type); -uint64_t cyopn_device_get_video_in_size(CaptureData* capture_data, bool is_3d, InputVideoDataType video_data_type); -void cyopn_device_acquisition_main_loop(CaptureData* capture_data); -void usb_cyopn_device_acquisition_cleanup(CaptureData* capture_data); -void usb_cyopn_device_init(); -void usb_cyopn_device_close(); - -#endif diff --git a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition_general.hpp b/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition_general.hpp deleted file mode 100644 index d3c8d97..0000000 --- a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition_general.hpp +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef __CYPRESS_OPTIMIZE_NEW_3DS_ACQUISITION_GENERAL_HPP -#define __CYPRESS_OPTIMIZE_NEW_3DS_ACQUISITION_GENERAL_HPP - -#include "cypress_shared_communications.hpp" -#include "cypress_optimize_new_3ds_communications.hpp" - -std::string cypress_optimize_new_3ds_get_serial(const void* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id); -CaptureDevice cypress_optimize_new_3ds_create_device(const void* usb_device_desc, std::string serial, std::string path); - -#endif diff --git a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.hpp b/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.hpp deleted file mode 100644 index bdcc30f..0000000 --- a/include/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.hpp +++ /dev/null @@ -1,49 +0,0 @@ -#ifndef __CYPRESS_OPTIMIZE_NEW_3DS_DEVICE_COMMUNICATIONS_HPP -#define __CYPRESS_OPTIMIZE_NEW_3DS_DEVICE_COMMUNICATIONS_HPP - -#include -#include -#include -#include -#include "utils.hpp" -#include "capture_structs.hpp" -#include "cypress_shared_communications.hpp" - -enum cypress_optimize_new_device_type { - CYPRESS_OPTIMIZE_NEW_3DS_BLANK_DEVICE, - CYPRESS_OPTIMIZE_NEW_3DS_INSTANTIATED_DEVICE, -}; - -struct cyopn_device_usb_device { - std::string name; - std::string long_name; - cypress_optimize_new_device_type device_type; - uint8_t* firmware_to_load; - size_t firmware_size; - uint8_t* fpga_pl_565; - size_t fpga_pl_565_size; - uint8_t* fpga_pl_565_3d; - size_t fpga_pl_565_3d_size; - uint8_t* fpga_pl_888; - size_t fpga_pl_888_size; - uint8_t* fpga_pl_888_3d; - size_t fpga_pl_888_3d_size; - cypress_optimize_new_device_type next_device; - bool has_bcd_device_serial; - cy_device_usb_device usb_device_info; -}; - - -int GetNumCyOpNDeviceDesc(void); -const cyopn_device_usb_device* GetCyOpNDeviceDesc(int index); -const cyopn_device_usb_device* GetNextDeviceDesc(const cyopn_device_usb_device* device); -const cy_device_usb_device* get_cy_usb_info(const cyopn_device_usb_device* usb_device_desc); -bool has_to_load_firmware(const cyopn_device_usb_device* device); -bool load_firmware(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint8_t patch_id); -int capture_start(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, bool is_first_load, bool is_rgb888); -int StartCaptureDma(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, bool is_rgb888); -int capture_end(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device); -int ReadFrame(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyopn_device_usb_device* device_desc); -int ReadFrameAsync(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyopn_device_usb_device* device_desc, cy_async_callback_data* cb_data); - -#endif diff --git a/include/capture_structs.hpp b/include/capture_structs.hpp index a857694..00375ce 100755 --- a/include/capture_structs.hpp +++ b/include/capture_structs.hpp @@ -20,9 +20,9 @@ #define FTD2_INTRA_PACKET_HEADER_SIZE 2 #define MAX_PACKET_SIZE_FTD2 (MAX_PACKET_SIZE_USB2 - FTD2_INTRA_PACKET_HEADER_SIZE) -#define OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE 0x200 +#define OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE 0x200 -enum CaptureConnectionType { CAPTURE_CONN_FTD3, CAPTURE_CONN_USB, CAPTURE_CONN_FTD2, CAPTURE_CONN_IS_NITRO, CAPTURE_CONN_CYPRESS_NISETRO, CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE }; +enum CaptureConnectionType { CAPTURE_CONN_FTD3, CAPTURE_CONN_USB, CAPTURE_CONN_FTD2, CAPTURE_CONN_IS_NITRO, CAPTURE_CONN_CYPRESS_NISETRO, CAPTURE_CONN_CYPRESS_OPTIMIZE }; enum InputVideoDataType { VIDEO_DATA_RGB, VIDEO_DATA_BGR, VIDEO_DATA_RGB16, VIDEO_DATA_BGR16 }; enum CaptureScreensType { CAPTURE_SCREENS_BOTH, CAPTURE_SCREENS_TOP, CAPTURE_SCREENS_BOTTOM, CAPTURE_SCREENS_ENUM_END }; enum CaptureSpeedsType { CAPTURE_SPEEDS_FULL, CAPTURE_SPEEDS_HALF, CAPTURE_SPEEDS_THIRD, CAPTURE_SPEEDS_QUARTER, CAPTURE_SPEEDS_ENUM_END }; @@ -60,56 +60,56 @@ struct PACKED USBOldDSVideoInputData { USBOldDSPixelData screen_data[IN_VIDEO_SIZE_DS]; }; -#define OPTIMIZE_NEW_3DS_PIXEL_R_BITS 5 -#define OPTIMIZE_NEW_3DS_PIXEL_G_BITS 6 -#define OPTIMIZE_NEW_3DS_PIXEL_B_BITS 5 +#define OPTIMIZE_3DS_PIXEL_R_BITS 5 +#define OPTIMIZE_3DS_PIXEL_G_BITS 6 +#define OPTIMIZE_3DS_PIXEL_B_BITS 5 -struct PACKED USB565New3DSOptimizePixelData { - uint16_t r : OPTIMIZE_NEW_3DS_PIXEL_R_BITS; - uint16_t g : OPTIMIZE_NEW_3DS_PIXEL_G_BITS; - uint16_t b : OPTIMIZE_NEW_3DS_PIXEL_B_BITS; +struct PACKED USB5653DSOptimizePixelData { + uint16_t r : OPTIMIZE_3DS_PIXEL_R_BITS; + uint16_t g : OPTIMIZE_3DS_PIXEL_G_BITS; + uint16_t b : OPTIMIZE_3DS_PIXEL_B_BITS; }; -struct PACKED USB888New3DSOptimizePixelData { +struct PACKED USB8883DSOptimizePixelData { uint8_t r; uint8_t g; uint8_t b; }; -struct PACKED USBNew3DSOptimizeSingleSoundData { +struct PACKED USB3DSOptimizeSingleSoundData { uint16_t sample_index; uint16_t sample_l; uint16_t sample_r; }; -struct PACKED USBNew3DSOptimizeHeaderSoundData { +struct PACKED USB3DSOptimizeHeaderSoundData { // Order is Little Endian uint16_t magic; uint16_t unk_fixed_1 : 1; uint16_t buffer_num : 1; uint16_t unk : 4; uint16_t column_index : 10; - USBNew3DSOptimizeSingleSoundData samples[2]; + USB3DSOptimizeSingleSoundData samples[2]; }; -struct PACKED USB565New3DSOptimizeInputColumnData { - USBNew3DSOptimizeHeaderSoundData header_sound; - USB565New3DSOptimizePixelData pixel[HEIGHT_3DS][2]; +struct PACKED USB5653DSOptimizeInputColumnData { + USB3DSOptimizeHeaderSoundData header_sound; + USB5653DSOptimizePixelData pixel[HEIGHT_3DS][2]; }; -struct PACKED USB565New3DSOptimizeInputColumnData3D { - USBNew3DSOptimizeHeaderSoundData header_sound; - USB565New3DSOptimizePixelData pixel[HEIGHT_3DS][3]; +struct PACKED USB5653DSOptimizeInputColumnData3D { + USB3DSOptimizeHeaderSoundData header_sound; + USB5653DSOptimizePixelData pixel[HEIGHT_3DS][3]; }; -struct PACKED USB888New3DSOptimizeInputColumnData { - USBNew3DSOptimizeHeaderSoundData header_sound; - USB888New3DSOptimizePixelData pixel[HEIGHT_3DS][2]; +struct PACKED USB8883DSOptimizeInputColumnData { + USB3DSOptimizeHeaderSoundData header_sound; + USB8883DSOptimizePixelData pixel[HEIGHT_3DS][2]; }; -struct PACKED USB888New3DSOptimizeInputColumnData3D { - USBNew3DSOptimizeHeaderSoundData header_sound; - USB888New3DSOptimizePixelData pixel[HEIGHT_3DS][3]; +struct PACKED USB8883DSOptimizeInputColumnData3D { + USB3DSOptimizeHeaderSoundData header_sound; + USB8883DSOptimizePixelData pixel[HEIGHT_3DS][3]; }; struct PACKED ISNitroEmulatorVideoInputData { @@ -202,24 +202,24 @@ struct ALIGNED(16) PACKED ISTWLCaptureReceived { ISTWLCaptureAudioReceived audio_capture_in[TWL_CAPTURE_MAX_SAMPLES_CHUNK_NUM]; }; -struct ALIGNED(16) PACKED USB565New3DSOptimizeCaptureReceived { - USB565New3DSOptimizeInputColumnData columns_data[TOP_WIDTH_3DS]; - USB565New3DSOptimizePixelData bottom_only_column[HEIGHT_3DS][2]; +struct ALIGNED(16) PACKED USB5653DSOptimizeCaptureReceived { + USB5653DSOptimizeInputColumnData columns_data[TOP_WIDTH_3DS]; + USB5653DSOptimizePixelData bottom_only_column[HEIGHT_3DS][2]; }; -struct ALIGNED(16) PACKED USB565New3DSOptimizeCaptureReceived_3D { - USB565New3DSOptimizeInputColumnData3D columns_data[TOP_WIDTH_3DS]; - USB565New3DSOptimizePixelData bottom_only_column[HEIGHT_3DS][3]; +struct ALIGNED(16) PACKED USB5653DSOptimizeCaptureReceived_3D { + USB5653DSOptimizeInputColumnData3D columns_data[TOP_WIDTH_3DS]; + USB5653DSOptimizePixelData bottom_only_column[HEIGHT_3DS][3]; }; -struct ALIGNED(16) PACKED USB888New3DSOptimizeCaptureReceived { - USB888New3DSOptimizeInputColumnData columns_data[TOP_WIDTH_3DS]; - USB888New3DSOptimizePixelData bottom_only_column[HEIGHT_3DS][2]; +struct ALIGNED(16) PACKED USB8883DSOptimizeCaptureReceived { + USB8883DSOptimizeInputColumnData columns_data[TOP_WIDTH_3DS]; + USB8883DSOptimizePixelData bottom_only_column[HEIGHT_3DS][2]; }; -struct ALIGNED(16) PACKED USB888New3DSOptimizeCaptureReceived_3D { - USB888New3DSOptimizeInputColumnData3D columns_data[TOP_WIDTH_3DS]; - USB888New3DSOptimizePixelData bottom_only_column[HEIGHT_3DS][3]; +struct ALIGNED(16) PACKED USB8883DSOptimizeCaptureReceived_3D { + USB8883DSOptimizeInputColumnData3D columns_data[TOP_WIDTH_3DS]; + USB8883DSOptimizePixelData bottom_only_column[HEIGHT_3DS][3]; }; #pragma pack(pop) @@ -240,10 +240,10 @@ union CaptureReceived { ISNitroCaptureReceived is_nitro_capture_received; ISTWLCaptureReceived is_twl_capture_received; CypressNisetroDSCaptureReceived cypress_nisetro_capture_received; - USB565New3DSOptimizeCaptureReceived cypress_new_optimize_received_565; - USB565New3DSOptimizeCaptureReceived_3D cypress_new_optimize_received_565_3d; - USB888New3DSOptimizeCaptureReceived cypress_new_optimize_received_888; - USB888New3DSOptimizeCaptureReceived_3D cypress_new_optimize_received_888_3d; + USB5653DSOptimizeCaptureReceived cypress_optimize_received_565; + USB5653DSOptimizeCaptureReceived_3D cypress_optimize_received_565_3d; + USB8883DSOptimizeCaptureReceived cypress_optimize_received_888; + USB8883DSOptimizeCaptureReceived_3D cypress_optimize_received_888_3d; }; struct CaptureDevice { diff --git a/source/CaptureDeviceSpecific/CypressShared/cypress_shared_driver_comms.cpp b/source/CaptureDeviceSpecific/CypressShared/cypress_shared_driver_comms.cpp index 020fab9..f872fec 100644 --- a/source/CaptureDeviceSpecific/CypressShared/cypress_shared_driver_comms.cpp +++ b/source/CaptureDeviceSpecific/CypressShared/cypress_shared_driver_comms.cpp @@ -138,14 +138,14 @@ struct PACKED CYPRESS_SET_TRANSFER_SIZE_INFO { #pragma pack(pop) static GUID cypress_driver_guid = {.Data1 = 0xae18aa60, .Data2 = 0x7f6a, .Data3 = 0x11d4, .Data4 = {0x97, 0xdd, 0x0, 0x1, 0x2, 0x29, 0xb9, 0x59}}; -static GUID cypress_optimize_new_driver_guid = {.Data1 = 0xae18aa60, .Data2 = 0x7f6a, .Data3 = 0x11d4, .Data4 = {0x97, 0xdd, 0x0, 0x1, 0x2, 0x29, 0xb9, 0x59}}; +static GUID cypress_optimize_driver_guid = {.Data1 = 0xae18aa60, .Data2 = 0x7f6a, .Data3 = 0x11d4, .Data4 = {0x97, 0xdd, 0x0, 0x1, 0x2, 0x29, 0xb9, 0x59}}; static GUID* get_driver_guid(CypressWindowsDriversEnum driver) { switch(driver) { case CYPRESS_WINDOWS_DEFAULT_USB_DRIVER: return &cypress_driver_guid; - case CYPRESS_WINDOWS_OPTIMIZE_NEW_USB_DRIVER: - return &cypress_optimize_new_driver_guid; + case CYPRESS_WINDOWS_OPTIMIZE_USB_DRIVER: + return &cypress_optimize_driver_guid; default: return NULL; } diff --git a/source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.cpp b/source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.cpp similarity index 67% rename from source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.cpp rename to source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.cpp index ab372f3..47d5ace 100644 --- a/source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_acquisition.cpp +++ b/source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_acquisition.cpp @@ -2,9 +2,9 @@ #include "cypress_shared_driver_comms.hpp" #include "cypress_shared_libusb_comms.hpp" #include "cypress_shared_communications.hpp" -#include "cypress_optimize_new_3ds_communications.hpp" -#include "cypress_optimize_new_3ds_acquisition.hpp" -#include "cypress_optimize_new_3ds_acquisition_general.hpp" +#include "cypress_optimize_3ds_communications.hpp" +#include "cypress_optimize_3ds_acquisition.hpp" +#include "cypress_optimize_3ds_acquisition_general.hpp" #include "usb_generic.hpp" #include @@ -21,16 +21,16 @@ #define SYNCH_VALUE_OPTIMIZE 0xCC33 #define SINGLE_RING_BUFFER_SLICE_SIZE 0x10000 -#define NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS 16 +#define NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS 16 -#define NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS (3 * NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS) +#define NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS (3 * NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS) #define MAX_TIME_WAIT 1.0 -#define OPTIMIZE_NEW_3DS_CYPRESS_USB_WINDOWS_DRIVER CYPRESS_WINDOWS_OPTIMIZE_NEW_USB_DRIVER +#define OPTIMIZE_3DS_CYPRESS_USB_WINDOWS_DRIVER CYPRESS_WINDOWS_OPTIMIZE_USB_DRIVER -struct CypressOptimizeNew3DSDeviceCaptureReceivedData { - CypressOptimizeNew3DSDeviceCaptureReceivedData* array_ptr; +struct CypressOptimize3DSDeviceCaptureReceivedData { + CypressOptimize3DSDeviceCaptureReceivedData* array_ptr; volatile bool in_use; volatile bool to_process; uint32_t index; @@ -53,27 +53,27 @@ struct CypressOptimizeNew3DSDeviceCaptureReceivedData { }; static void cypress_device_read_frame_cb(void* user_data, int transfer_length, int transfer_status); -static int get_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data); -static void error_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int error_val); +static int get_cypress_device_status(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data); +static void error_cypress_device_status(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int error_val); -static cy_device_device_handlers* usb_find_by_serial_number(const cyopn_device_usb_device* usb_device_desc, std::string wanted_serial_number, CaptureDevice* new_device) { +static cy_device_device_handlers* usb_find_by_serial_number(const cyop_device_usb_device* usb_device_desc, std::string wanted_serial_number, CaptureDevice* new_device) { cy_device_device_handlers* final_handlers = NULL; int curr_serial_extra_id = 0; final_handlers = cypress_libusb_serial_reconnection(get_cy_usb_info(usb_device_desc), wanted_serial_number, curr_serial_extra_id, new_device); if(final_handlers == NULL) - final_handlers = cypress_driver_find_by_serial_number(get_cy_usb_info(usb_device_desc), wanted_serial_number, curr_serial_extra_id, new_device, OPTIMIZE_NEW_3DS_CYPRESS_USB_WINDOWS_DRIVER); + final_handlers = cypress_driver_find_by_serial_number(get_cy_usb_info(usb_device_desc), wanted_serial_number, curr_serial_extra_id, new_device, OPTIMIZE_3DS_CYPRESS_USB_WINDOWS_DRIVER); return final_handlers; } -static int usb_find_free_fw_id(const cyopn_device_usb_device* usb_device_desc) { +static int usb_find_free_fw_id(const cyop_device_usb_device* usb_device_desc) { int curr_serial_extra_id = 0; const int num_free_fw_ids = 0x100; bool found[num_free_fw_ids]; for(int i = 0; i < num_free_fw_ids; i++) found[i] = false; cypress_libusb_find_used_serial(get_cy_usb_info(usb_device_desc), found, num_free_fw_ids, curr_serial_extra_id); - cypress_driver_find_used_serial(get_cy_usb_info(usb_device_desc), found, num_free_fw_ids, curr_serial_extra_id, OPTIMIZE_NEW_3DS_CYPRESS_USB_WINDOWS_DRIVER); + cypress_driver_find_used_serial(get_cy_usb_info(usb_device_desc), found, num_free_fw_ids, curr_serial_extra_id, OPTIMIZE_3DS_CYPRESS_USB_WINDOWS_DRIVER); for(int i = 0; i < num_free_fw_ids; i++) if(!found[i]) @@ -81,7 +81,7 @@ static int usb_find_free_fw_id(const cyopn_device_usb_device* usb_device_desc) { return 0; } -static cy_device_device_handlers* usb_reconnect(const cyopn_device_usb_device* usb_device_desc, CaptureDevice* device) { +static cy_device_device_handlers* usb_reconnect(const cyop_device_usb_device* usb_device_desc, CaptureDevice* device) { cy_device_device_handlers* final_handlers = NULL; int curr_serial_extra_id = 0; final_handlers = cypress_libusb_serial_reconnection(get_cy_usb_info(usb_device_desc), device->serial_number, curr_serial_extra_id, NULL); @@ -91,7 +91,7 @@ static cy_device_device_handlers* usb_reconnect(const cyopn_device_usb_device* u return final_handlers; } -static std::string _cypress_optimize_new_3ds_get_serial(const cyopn_device_usb_device* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id) { +static std::string _cypress_optimize_3ds_get_serial(const cyop_device_usb_device* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id) { if((!usb_device_desc->has_bcd_device_serial) && (serial != "")) return serial; if(usb_device_desc->has_bcd_device_serial) @@ -99,23 +99,23 @@ static std::string _cypress_optimize_new_3ds_get_serial(const cyopn_device_usb_d return std::to_string((curr_serial_extra_id++) + 1); } -std::string cypress_optimize_new_3ds_get_serial(const void* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id) { +std::string cypress_optimize_3ds_get_serial(const void* usb_device_desc, std::string serial, uint16_t bcd_device, int& curr_serial_extra_id) { if(usb_device_desc == NULL) return ""; - return _cypress_optimize_new_3ds_get_serial((const cyopn_device_usb_device*)usb_device_desc, serial, bcd_device, curr_serial_extra_id); + return _cypress_optimize_3ds_get_serial((const cyop_device_usb_device*)usb_device_desc, serial, bcd_device, curr_serial_extra_id); } -static CaptureDevice _cypress_optimize_new_3ds_create_device(const cyopn_device_usb_device* usb_device_desc, std::string serial, std::string path) { - return CaptureDevice(serial, usb_device_desc->name, usb_device_desc->long_name, CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE, (void*)usb_device_desc, true, true, true, HEIGHT_3DS, TOP_WIDTH_3DS + BOT_WIDTH_3DS, HEIGHT_3DS, (TOP_WIDTH_3DS * 2) + BOT_WIDTH_3DS, OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE * 8, 90, BOT_WIDTH_3DS, 0, BOT_WIDTH_3DS + TOP_WIDTH_3DS, 0, 0, 0, false, VIDEO_DATA_RGB16, 0x200, path); +static CaptureDevice _cypress_optimize_3ds_create_device(const cyop_device_usb_device* usb_device_desc, std::string serial, std::string path) { + return CaptureDevice(serial, usb_device_desc->name, usb_device_desc->long_name, CAPTURE_CONN_CYPRESS_OPTIMIZE, (void*)usb_device_desc, true, true, true, HEIGHT_3DS, TOP_WIDTH_3DS + BOT_WIDTH_3DS, HEIGHT_3DS, (TOP_WIDTH_3DS * 2) + BOT_WIDTH_3DS, OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE * 8, 90, BOT_WIDTH_3DS, 0, BOT_WIDTH_3DS + TOP_WIDTH_3DS, 0, 0, 0, false, VIDEO_DATA_RGB16, 0x200, path); } -CaptureDevice cypress_optimize_new_3ds_create_device(const void* usb_device_desc, std::string serial, std::string path) { +CaptureDevice cypress_optimize_3ds_create_device(const void* usb_device_desc, std::string serial, std::string path) { if(usb_device_desc == NULL) return CaptureDevice(); - return _cypress_optimize_new_3ds_create_device((const cyopn_device_usb_device*)usb_device_desc, serial, path); + return _cypress_optimize_3ds_create_device((const cyop_device_usb_device*)usb_device_desc, serial, path); } -static void cypress_optimize_new_3ds_connection_end(cy_device_device_handlers* handlers, const cyopn_device_usb_device *device_desc, bool interface_claimed = true) { +static void cypress_optimize_3ds_connection_end(cy_device_device_handlers* handlers, const cyop_device_usb_device *device_desc, bool interface_claimed = true) { if (handlers == NULL) return; if (handlers->usb_handle) @@ -125,51 +125,51 @@ static void cypress_optimize_new_3ds_connection_end(cy_device_device_handlers* h delete handlers; } -void list_devices_cyopn_device(std::vector &devices_list, std::vector &no_access_list) { - const size_t num_cyopn_device_desc = GetNumCyOpNDeviceDesc(); - int* curr_serial_extra_id_cyopn_device = new int[num_cyopn_device_desc]; - bool* no_access_elems = new bool[num_cyopn_device_desc]; - bool* not_supported_elems = new bool[num_cyopn_device_desc]; +void list_devices_cyop_device(std::vector &devices_list, std::vector &no_access_list) { + const size_t num_cyop_device_desc = GetNumCyOpDeviceDesc(); + int* curr_serial_extra_id_cyop_device = new int[num_cyop_device_desc]; + bool* no_access_elems = new bool[num_cyop_device_desc]; + bool* not_supported_elems = new bool[num_cyop_device_desc]; std::vector usb_devices_to_check; - for (int i = 0; i < num_cyopn_device_desc; i++) { + for (int i = 0; i < num_cyop_device_desc; i++) { no_access_elems[i] = false; not_supported_elems[i] = false; - curr_serial_extra_id_cyopn_device[i] = 0; - const cyopn_device_usb_device* curr_device_desc = GetCyOpNDeviceDesc(i); + curr_serial_extra_id_cyop_device[i] = 0; + const cyop_device_usb_device* curr_device_desc = GetCyOpDeviceDesc(i); usb_devices_to_check.push_back(get_cy_usb_info(curr_device_desc)); } - cypress_libusb_list_devices(devices_list, no_access_elems, not_supported_elems, curr_serial_extra_id_cyopn_device, usb_devices_to_check); + cypress_libusb_list_devices(devices_list, no_access_elems, not_supported_elems, curr_serial_extra_id_cyop_device, usb_devices_to_check); bool any_not_supported = false; - for(int i = 0; i < num_cyopn_device_desc; i++) + for(int i = 0; i < num_cyop_device_desc; i++) any_not_supported |= not_supported_elems[i]; - for(int i = 0; i < num_cyopn_device_desc; i++) + for(int i = 0; i < num_cyop_device_desc; i++) if(no_access_elems[i]) no_access_list.emplace_back(usb_devices_to_check[i]->vid, usb_devices_to_check[i]->pid); if(any_not_supported) - cypress_driver_list_devices(devices_list, not_supported_elems, curr_serial_extra_id_cyopn_device, usb_devices_to_check, OPTIMIZE_NEW_3DS_CYPRESS_USB_WINDOWS_DRIVER); + cypress_driver_list_devices(devices_list, not_supported_elems, curr_serial_extra_id_cyop_device, usb_devices_to_check, OPTIMIZE_3DS_CYPRESS_USB_WINDOWS_DRIVER); - delete[] curr_serial_extra_id_cyopn_device; + delete[] curr_serial_extra_id_cyop_device; delete[] no_access_elems; delete[] not_supported_elems; } -bool cyopn_device_connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device) { - const cyopn_device_usb_device* usb_device_info = (const cyopn_device_usb_device*)device->descriptor; +bool cyop_device_connect_usb(bool print_failed, CaptureData* capture_data, CaptureDevice* device) { + const cyop_device_usb_device* usb_device_info = (const cyop_device_usb_device*)device->descriptor; cy_device_device_handlers* handlers = usb_reconnect(usb_device_info, device); if(handlers == NULL) { capture_error_print(true, capture_data, "Device not found"); return false; } if(has_to_load_firmware(usb_device_info)) { - const cyopn_device_usb_device* next_usb_device_info = GetNextDeviceDesc(usb_device_info); + const cyop_device_usb_device* next_usb_device_info = GetNextDeviceDesc(usb_device_info); int free_fw_id = usb_find_free_fw_id(next_usb_device_info); int ret = load_firmware(handlers, usb_device_info, free_fw_id); if(!ret) { capture_error_print(true, capture_data, "Firmware load error"); return false; } - cypress_optimize_new_3ds_connection_end(handlers, usb_device_info); + cypress_optimize_3ds_connection_end(handlers, usb_device_info); std::string new_serial_number = std::to_string(free_fw_id); CaptureDevice new_device; for(int i = 0; i < 20; i++) { @@ -189,39 +189,39 @@ bool cyopn_device_connect_usb(bool print_failed, CaptureData* capture_data, Capt return true; } -uint64_t cyopn_device_get_video_in_size(bool is_3d, InputVideoDataType video_data_type) { +uint64_t cyop_device_get_video_in_size(bool is_3d, InputVideoDataType video_data_type) { bool is_rgb888 = video_data_type == VIDEO_DATA_RGB; if(is_rgb888) { if(is_3d) - return sizeof(USB888New3DSOptimizeCaptureReceived_3D); - return sizeof(USB888New3DSOptimizeCaptureReceived); + return sizeof(USB8883DSOptimizeCaptureReceived_3D); + return sizeof(USB8883DSOptimizeCaptureReceived); } if(is_3d) - return sizeof(USB565New3DSOptimizeCaptureReceived_3D); - return sizeof(USB565New3DSOptimizeCaptureReceived); + return sizeof(USB5653DSOptimizeCaptureReceived_3D); + return sizeof(USB5653DSOptimizeCaptureReceived); } -uint64_t cyopn_device_get_video_in_size(CaptureStatus* status, bool is_3d, InputVideoDataType video_data_type) { - return cyopn_device_get_video_in_size(is_3d, video_data_type); +uint64_t cyop_device_get_video_in_size(CaptureStatus* status, bool is_3d, InputVideoDataType video_data_type) { + return cyop_device_get_video_in_size(is_3d, video_data_type); } -uint64_t cyopn_device_get_video_in_size(CaptureData* capture_data, bool is_3d, InputVideoDataType video_data_type) { - return cyopn_device_get_video_in_size(&capture_data->status, is_3d, video_data_type); +uint64_t cyop_device_get_video_in_size(CaptureData* capture_data, bool is_3d, InputVideoDataType video_data_type) { + return cyop_device_get_video_in_size(&capture_data->status, is_3d, video_data_type); } -static int cypress_device_read_frame_request(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, uint32_t index, bool is_3d, InputVideoDataType video_data_type) { +static int cypress_device_read_frame_request(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, uint32_t index, bool is_3d, InputVideoDataType video_data_type) { if(cypress_device_capture_recv_data == NULL) return LIBUSB_SUCCESS; if((*cypress_device_capture_recv_data->status) < 0) return LIBUSB_SUCCESS; - const cyopn_device_usb_device* usb_device_info = (const cyopn_device_usb_device*)capture_data->status.device.descriptor; + const cyop_device_usb_device* usb_device_info = (const cyop_device_usb_device*)capture_data->status.device.descriptor; cypress_device_capture_recv_data->index = index; cypress_device_capture_recv_data->cb_data.function = cypress_device_read_frame_cb; - //size_t read_size = cyopn_device_get_video_in_size(is_3d, video_data_type); + //size_t read_size = cyop_device_get_video_in_size(is_3d, video_data_type); size_t read_size = SINGLE_RING_BUFFER_SLICE_SIZE; - int new_buffer_slice_index = ((*cypress_device_capture_recv_data->last_ring_buffer_slice_allocated) + 1) % NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; + int new_buffer_slice_index = ((*cypress_device_capture_recv_data->last_ring_buffer_slice_allocated) + 1) % NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; uint8_t* buffer = &cypress_device_capture_recv_data->ring_slice_buffer_arr[new_buffer_slice_index * SINGLE_RING_BUFFER_SLICE_SIZE]; cypress_device_capture_recv_data->is_ring_buffer_slice_data_ready_arr[new_buffer_slice_index] = false; cypress_device_capture_recv_data->is_ring_buffer_slice_data_in_use_arr[new_buffer_slice_index] = true; @@ -234,7 +234,7 @@ static int cypress_device_read_frame_request(CaptureData* capture_data, CypressO return ReadFrameAsync((cy_device_device_handlers*)capture_data->handle, buffer, read_size, usb_device_info, &cypress_device_capture_recv_data->cb_data); } -static void unlock_buffer_directly(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data_real) { +static void unlock_buffer_directly(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data_real) { int slice_index = cypress_device_capture_recv_data_real->ring_buffer_slice_index; cypress_device_capture_recv_data_real->is_ring_buffer_slice_data_ready_arr[slice_index] = false; cypress_device_capture_recv_data_real->is_ring_buffer_slice_data_in_use_arr[slice_index] = false; @@ -243,14 +243,14 @@ static void unlock_buffer_directly(CypressOptimizeNew3DSDeviceCaptureReceivedDat cypress_device_capture_recv_data_real->is_buffer_free_shared_mutex->specific_unlock(cypress_device_capture_recv_data_real->cb_data.internal_index); } -static void unlock_buffer_slice_index(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int slice_index) { +static void unlock_buffer_slice_index(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int slice_index) { int index = cypress_device_capture_recv_data->buffer_ring_slice_to_array_ptr[slice_index]; if(index == -1) return; unlock_buffer_directly(&cypress_device_capture_recv_data->array_ptr[index]); } -static void end_cypress_device_read_frame_cb(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool to_unlock) { +static void end_cypress_device_read_frame_cb(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool to_unlock) { cypress_device_capture_recv_data->to_process = false; if(to_unlock) unlock_buffer_directly(cypress_device_capture_recv_data); @@ -266,24 +266,24 @@ static size_t get_pos_first_synch_in_buffer(uint8_t* buffer) { return SINGLE_RING_BUFFER_SLICE_SIZE + 1; } -static int get_num_consecutive_ready_ring_buffer_slices(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int start_index) { - for(int i = 0; i < NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; i++) { - int index_check = (start_index + i) % NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; +static int get_num_consecutive_ready_ring_buffer_slices(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int start_index) { + for(int i = 0; i < NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; i++) { + int index_check = (start_index + i) % NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; if(!cypress_device_capture_recv_data->is_ring_buffer_slice_data_ready_arr[index_check]) return i; } // Should never happen - return NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; + return NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; } static void cypress_output_to_thread(CaptureData* capture_data, uint8_t *buffer_arr, size_t start_slice_index, size_t start_slice_pos, int internal_index, std::chrono::time_point* clock_start, size_t read_size) { // Output to the other threads... CaptureDataSingleBuffer* data_buf = capture_data->data_buffers.GetWriterBuffer(internal_index); size_t start_byte = (start_slice_index * SINGLE_RING_BUFFER_SLICE_SIZE) + start_slice_pos; - if((start_byte + read_size) <= (NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE)) + if((start_byte + read_size) <= (NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE)) memcpy(&data_buf->capture_buf, buffer_arr + start_byte, read_size); else { - size_t upper_read_size = (NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE) - start_byte; + size_t upper_read_size = (NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE) - start_byte; size_t start_read_size = read_size - upper_read_size; memcpy(&data_buf->capture_buf, buffer_arr + start_byte, upper_read_size); memcpy(((uint8_t*)&data_buf->capture_buf) + upper_read_size, buffer_arr, start_read_size); @@ -299,7 +299,7 @@ static void cypress_output_to_thread(CaptureData* capture_data, uint8_t *buffer_ } static void cypress_device_read_frame_cb(void* user_data, int transfer_length, int transfer_status) { - CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data = (CypressOptimizeNew3DSDeviceCaptureReceivedData*)user_data; + CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data = (CypressOptimize3DSDeviceCaptureReceivedData*)user_data; if((*cypress_device_capture_recv_data->status) < 0) return end_cypress_device_read_frame_cb(cypress_device_capture_recv_data, true); if((transfer_status != LIBUSB_TRANSFER_COMPLETED) || (transfer_length < SINGLE_RING_BUFFER_SLICE_SIZE)) { @@ -315,19 +315,19 @@ static void cypress_device_read_frame_cb(void* user_data, int transfer_length, i volatile int read_slice_index = *cypress_device_capture_recv_data->last_used_ring_buffer_slice_index; if(read_slice_index == -1) { size_t first_to_check = 0; - for(int i = 0; i < NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; i++) { + for(int i = 0; i < NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; i++) { if(!cypress_device_capture_recv_data->is_ring_buffer_slice_data_in_use_arr[i]) first_to_check++; else break; } - if(first_to_check > NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS) { + if(first_to_check > NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS) { int error = LIBUSB_ERROR_OTHER; *cypress_device_capture_recv_data->status = error; return end_cypress_device_read_frame_cb(cypress_device_capture_recv_data, true); } - for(int i = 0; i < NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; i++) { - size_t check_index = (first_to_check + i) % NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; + for(int i = 0; i < NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; i++) { + size_t check_index = (first_to_check + i) % NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; if(cypress_device_capture_recv_data->is_ring_buffer_slice_data_ready_arr[check_index]) { size_t result = get_pos_first_synch_in_buffer(&cypress_device_capture_recv_data->ring_slice_buffer_arr[check_index * SINGLE_RING_BUFFER_SLICE_SIZE]); if(result >= SINGLE_RING_BUFFER_SLICE_SIZE) { @@ -348,7 +348,7 @@ static void cypress_device_read_frame_cb(void* user_data, int transfer_length, i volatile size_t read_slice_pos = *cypress_device_capture_recv_data->last_used_ring_buffer_slice_pos; if(read_slice_index != -1) { int num_consecutive_ready_buffers = get_num_consecutive_ready_ring_buffer_slices(cypress_device_capture_recv_data, read_slice_index); - size_t video_in_size = cyopn_device_get_video_in_size(*cypress_device_capture_recv_data->stored_is_3d, *cypress_device_capture_recv_data->stored_video_data_type); + size_t video_in_size = cyop_device_get_video_in_size(*cypress_device_capture_recv_data->stored_is_3d, *cypress_device_capture_recv_data->stored_video_data_type); size_t raw_new_pos = read_slice_pos + video_in_size; int num_needed_buffers = (raw_new_pos + SINGLE_RING_BUFFER_SLICE_SIZE - 1) / SINGLE_RING_BUFFER_SLICE_SIZE; if(num_consecutive_ready_buffers >= num_needed_buffers) { @@ -359,12 +359,12 @@ static void cypress_device_read_frame_cb(void* user_data, int transfer_length, i size_t new_slice_pos = raw_new_pos % SINGLE_RING_BUFFER_SLICE_SIZE; if(new_slice_pos == 0) new_slice_index += 1; - new_slice_index %= NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; + new_slice_index %= NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; // Unlock the buffers already processed int pos_to_unlock = read_slice_index; while(pos_to_unlock != new_slice_index) { unlock_buffer_slice_index(cypress_device_capture_recv_data, pos_to_unlock); - pos_to_unlock = (pos_to_unlock + 1) % NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; + pos_to_unlock = (pos_to_unlock + 1) % NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; } // Update the position of the data *cypress_device_capture_recv_data->last_used_ring_buffer_slice_index = new_slice_index; @@ -374,21 +374,21 @@ static void cypress_device_read_frame_cb(void* user_data, int transfer_length, i return end_cypress_device_read_frame_cb(cypress_device_capture_recv_data, to_free); } -static int cypress_device_get_num_free_buffers(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static int cypress_device_get_num_free_buffers(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { int num_free = 0; - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) if(!cypress_device_capture_recv_data[i].in_use) num_free += 1; return num_free; } -static void close_all_reads_error(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool &async_read_closed) { +static void close_all_reads_error(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool &async_read_closed) { cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; - const cyopn_device_usb_device* usb_device_desc = (const cyopn_device_usb_device*)capture_data->status.device.descriptor; + const cyop_device_usb_device* usb_device_desc = (const cyop_device_usb_device*)capture_data->status.device.descriptor; if(get_cypress_device_status(cypress_device_capture_recv_data) < 0) { if(!async_read_closed) { if(handlers->usb_handle) { - for (int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) + for (int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) CypressCloseAsyncRead(handlers, get_cy_usb_info(usb_device_desc), &cypress_device_capture_recv_data[i].cb_data); } else @@ -404,28 +404,28 @@ static bool has_too_much_time_passed(const std::chrono::time_point MAX_TIME_WAIT; } -static void error_too_much_time_passed(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool &async_read_closed, const std::chrono::time_point &start_time) { +static void error_too_much_time_passed(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, bool &async_read_closed, const std::chrono::time_point &start_time) { if(has_too_much_time_passed(start_time)) { error_cypress_device_status(cypress_device_capture_recv_data, -1); close_all_reads_error(capture_data, cypress_device_capture_recv_data, async_read_closed); } } -static void check_unlock_waiting_with_error(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static void check_unlock_waiting_with_error(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { if(get_cypress_device_status(cypress_device_capture_recv_data) < 0) { if(cypress_device_capture_recv_data->is_ring_buffer_slice_data_ready_arr[cypress_device_capture_recv_data->ring_buffer_slice_index]) unlock_buffer_directly(cypress_device_capture_recv_data); } } -static void wait_all_cypress_device_buffers_free(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static void wait_all_cypress_device_buffers_free(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { if(cypress_device_capture_recv_data == NULL) return; cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; bool async_read_closed = false; close_all_reads_error(capture_data, cypress_device_capture_recv_data, async_read_closed); const auto start_time = std::chrono::high_resolution_clock::now(); - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) while(cypress_device_capture_recv_data[i].in_use) { error_too_much_time_passed(capture_data, cypress_device_capture_recv_data, async_read_closed, start_time); check_unlock_waiting_with_error(&cypress_device_capture_recv_data[i]); @@ -433,12 +433,12 @@ static void wait_all_cypress_device_buffers_free(CaptureData* capture_data, Cypr } } -static void wait_one_cypress_device_buffer_free(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static void wait_one_cypress_device_buffer_free(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; bool done = false; const auto start_time = std::chrono::high_resolution_clock::now(); while(!done) { - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { if(!cypress_device_capture_recv_data[i].in_use) done = true; } @@ -453,7 +453,7 @@ static void wait_one_cypress_device_buffer_free(CaptureData* capture_data, Cypre } } -static void wait_specific_cypress_device_buffer_free(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static void wait_specific_cypress_device_buffer_free(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; bool done = false; const auto start_time = std::chrono::high_resolution_clock::now(); @@ -471,26 +471,26 @@ static void wait_specific_cypress_device_buffer_free(CaptureData* capture_data, } } -static bool cypress_device_are_buffers_all_free(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { - return cypress_device_get_num_free_buffers(cypress_device_capture_recv_data) == NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; +static bool cypress_device_are_buffers_all_free(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { + return cypress_device_get_num_free_buffers(cypress_device_capture_recv_data) == NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; } -static CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_get_free_buffer(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_get_free_buffer(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { wait_one_cypress_device_buffer_free(capture_data, cypress_device_capture_recv_data); if(get_cypress_device_status(cypress_device_capture_recv_data) < 0) return NULL; - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) if(!cypress_device_capture_recv_data[i].in_use) { return &cypress_device_capture_recv_data[i]; } return NULL; } -static int get_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static int get_cypress_device_status(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { return *cypress_device_capture_recv_data[0].status; } -static void error_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int error_val) { +static void error_cypress_device_status(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, int error_val) { if((error_val == 0) || (get_cypress_device_status(cypress_device_capture_recv_data) == 0)) *cypress_device_capture_recv_data[0].status = error_val; } @@ -498,26 +498,26 @@ static void error_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceiv static void exported_error_cypress_device_status(void* data, int error_val) { if(data == NULL) return; - return error_cypress_device_status((CypressOptimizeNew3DSDeviceCaptureReceivedData*)data, error_val); + return error_cypress_device_status((CypressOptimize3DSDeviceCaptureReceivedData*)data, error_val); } -static void reset_cypress_device_status(CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { +static void reset_cypress_device_status(CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data) { error_cypress_device_status(cypress_device_capture_recv_data, 0); } -static bool cyopn_device_acquisition_loop(CaptureData* capture_data, CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, InputVideoDataType &stored_video_data_type, bool &stored_is_3d) { +static bool cyop_device_acquisition_loop(CaptureData* capture_data, CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data, InputVideoDataType &stored_video_data_type, bool &stored_is_3d) { cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; - const cyopn_device_usb_device* usb_device_desc = (const cyopn_device_usb_device*)capture_data->status.device.descriptor; + const cyop_device_usb_device* usb_device_desc = (const cyop_device_usb_device*)capture_data->status.device.descriptor; uint32_t index = 0; int ret = capture_start(handlers, usb_device_desc, true, stored_video_data_type == VIDEO_DATA_RGB); if (ret < 0) { capture_error_print(true, capture_data, "Capture Start: Failed"); return false; } - CypressSetMaxTransferSize(handlers, get_cy_usb_info(usb_device_desc), cyopn_device_get_video_in_size(stored_is_3d, stored_video_data_type)); + CypressSetMaxTransferSize(handlers, get_cy_usb_info(usb_device_desc), cyop_device_get_video_in_size(stored_is_3d, stored_video_data_type)); auto clock_last_reset = std::chrono::high_resolution_clock::now(); - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { - CypressOptimizeNew3DSDeviceCaptureReceivedData* chosen_buffer = cypress_device_get_free_buffer(capture_data, cypress_device_capture_recv_data); + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { + CypressOptimize3DSDeviceCaptureReceivedData* chosen_buffer = cypress_device_get_free_buffer(capture_data, cypress_device_capture_recv_data); ret = cypress_device_read_frame_request(capture_data, chosen_buffer, index++, stored_is_3d, stored_video_data_type); if(ret < 0) { chosen_buffer->in_use = false; @@ -536,7 +536,7 @@ static bool cyopn_device_acquisition_loop(CaptureData* capture_data, CypressOpti capture_error_print(true, capture_data, "Disconnected: Read error"); return false; } - CypressOptimizeNew3DSDeviceCaptureReceivedData* chosen_buffer = cypress_device_get_free_buffer(capture_data, cypress_device_capture_recv_data); + CypressOptimize3DSDeviceCaptureReceivedData* chosen_buffer = cypress_device_get_free_buffer(capture_data, cypress_device_capture_recv_data); if(chosen_buffer == NULL) error_cypress_device_status(cypress_device_capture_recv_data, LIBUSB_ERROR_TIMEOUT); ret = cypress_device_read_frame_request(capture_data, chosen_buffer, index++, stored_is_3d, stored_video_data_type); @@ -551,24 +551,24 @@ static bool cyopn_device_acquisition_loop(CaptureData* capture_data, CypressOpti return true; } -void cyopn_device_acquisition_main_loop(CaptureData* capture_data) { +void cyop_device_acquisition_main_loop(CaptureData* capture_data) { if(!usb_is_initialized()) return; bool is_done_thread; std::thread async_processing_thread; cy_device_device_handlers* handlers = (cy_device_device_handlers*)capture_data->handle; - const cyopn_device_usb_device* usb_device_desc = (const cyopn_device_usb_device*)capture_data->status.device.descriptor; + const cyop_device_usb_device* usb_device_desc = (const cyop_device_usb_device*)capture_data->status.device.descriptor; uint32_t last_index = -1; int status = 0; InputVideoDataType stored_video_data_type = capture_data->status.device.video_data_type; bool stored_is_3d = false; - uint8_t *ring_slice_buffer = new uint8_t[NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE]; - bool *is_ring_buffer_slice_data_ready = new bool[NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS]; - bool *is_ring_buffer_slice_data_in_use = new bool[NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS]; - int *buffer_ring_slice_to_array = new int[NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS]; - for(int i = 0; i < NUM_TOTAL_OPTIMIZE_NEW_3DS_CYPRESS_BUFFERS; i++) { + uint8_t *ring_slice_buffer = new uint8_t[NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS * SINGLE_RING_BUFFER_SLICE_SIZE]; + bool *is_ring_buffer_slice_data_ready = new bool[NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS]; + bool *is_ring_buffer_slice_data_in_use = new bool[NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS]; + int *buffer_ring_slice_to_array = new int[NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS]; + for(int i = 0; i < NUM_TOTAL_OPTIMIZE_3DS_CYPRESS_BUFFERS; i++) { is_ring_buffer_slice_data_ready[i] = false; is_ring_buffer_slice_data_in_use[i] = false; buffer_ring_slice_to_array[i] = -1; @@ -578,12 +578,12 @@ void cyopn_device_acquisition_main_loop(CaptureData* capture_data) { int last_ring_buffer_slice_allocated = -1; std::vector cb_queue; - SharedConsumerMutex is_buffer_free_shared_mutex(NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); - SharedConsumerMutex is_transfer_done_shared_mutex(NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); - SharedConsumerMutex is_transfer_data_ready_shared_mutex(NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); + SharedConsumerMutex is_buffer_free_shared_mutex(NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); + SharedConsumerMutex is_transfer_done_shared_mutex(NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); + SharedConsumerMutex is_transfer_data_ready_shared_mutex(NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS); std::chrono::time_point clock_start = std::chrono::high_resolution_clock::now(); - CypressOptimizeNew3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data = new CypressOptimizeNew3DSDeviceCaptureReceivedData[NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS]; - for(int i = 0; i < NUM_OPTIMIZE_NEW_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { + CypressOptimize3DSDeviceCaptureReceivedData* cypress_device_capture_recv_data = new CypressOptimize3DSDeviceCaptureReceivedData[NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS]; + for(int i = 0; i < NUM_OPTIMIZE_3DS_CYPRESS_CONCURRENTLY_RUNNING_BUFFERS; i++) { cypress_device_capture_recv_data[i].array_ptr = cypress_device_capture_recv_data; cypress_device_capture_recv_data[i].in_use = false; cypress_device_capture_recv_data[i].to_process = false; @@ -613,7 +613,7 @@ void cyopn_device_acquisition_main_loop(CaptureData* capture_data) { cb_queue.push_back(&cypress_device_capture_recv_data[i].cb_data); } CypressSetupCypressDeviceAsyncThread(handlers, cb_queue, &async_processing_thread, &is_done_thread); - bool proper_return = cyopn_device_acquisition_loop(capture_data, cypress_device_capture_recv_data, stored_video_data_type, stored_is_3d); + bool proper_return = cyop_device_acquisition_loop(capture_data, cypress_device_capture_recv_data, stored_video_data_type, stored_is_3d); wait_all_cypress_device_buffers_free(capture_data, cypress_device_capture_recv_data); CypressEndCypressDeviceAsyncThread(handlers, cb_queue, &async_processing_thread, &is_done_thread); delete []cypress_device_capture_recv_data; @@ -626,18 +626,18 @@ void cyopn_device_acquisition_main_loop(CaptureData* capture_data) { capture_end(handlers, usb_device_desc); } -void usb_cyopn_device_acquisition_cleanup(CaptureData* capture_data) { +void usb_cyop_device_acquisition_cleanup(CaptureData* capture_data) { if(!usb_is_initialized()) return; - cypress_optimize_new_3ds_connection_end((cy_device_device_handlers*)capture_data->handle, (const cyopn_device_usb_device*)capture_data->status.device.descriptor); + cypress_optimize_3ds_connection_end((cy_device_device_handlers*)capture_data->handle, (const cyop_device_usb_device*)capture_data->status.device.descriptor); capture_data->handle = NULL; } -void usb_cyopn_device_init() { +void usb_cyop_device_init() { return usb_init(); } -void usb_cyopn_device_close() { +void usb_cyop_device_close() { usb_close(); } diff --git a/source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.cpp b/source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.cpp similarity index 67% rename from source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.cpp rename to source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.cpp index d84b5a6..9a11c1f 100644 --- a/source/CaptureDeviceSpecific/Optimize_New_3DS/cypress_optimize_new_3ds_communications.cpp +++ b/source/CaptureDeviceSpecific/Optimize_3DS/cypress_optimize_3ds_communications.cpp @@ -1,13 +1,17 @@ #include "frontend.hpp" -#include "cypress_optimize_new_3ds_communications.hpp" +#include "cypress_optimize_3ds_communications.hpp" #include "cypress_shared_communications.hpp" -#include "cypress_optimize_new_3ds_acquisition_general.hpp" +#include "cypress_optimize_3ds_acquisition_general.hpp" #include "usb_generic.hpp" #include "optimize_new_3ds_fw.h" #include "optimize_new_3ds_565_fpga_pl.h" #include "optimize_new_3ds_888_fpga_pl.h" +#include "optimize_old_3ds_fw.h" +#include "optimize_old_3ds_565_fpga_pl.h" +#include "optimize_old_3ds_888_fpga_pl.h" + #include #include #include @@ -23,17 +27,23 @@ #define CYPRESS_BASE_USB_PACKET_LIMIT 64 #define CYPRESS_OPTIMIZE_NEW_3DS_USB_PACKET_LIMIT 512 +#define CYPRESS_OPTIMIZE_OLD_3DS_USB_PACKET_LIMIT 512 #define OPTIMIZE_NEW_3DS_WANTED_VALUE_BASE 0xFE00 +#define OPTIMIZE_OLD_3DS_WANTED_VALUE_BASE 0xFD00 -static const cyopn_device_usb_device cypress_optimize_new_3ds_generic_device = { +const uint8_t start_capture_third_buffer_565_new[] = { 0x61, 0x07, 0x00, 0x0F, 0x00, 0x3E, 0x00, 0xF8, 0x00, 0x38, 0x00, 0x51, 0x80, 0x5C, 0x01, 0x00 }; +const uint8_t start_capture_third_buffer_888_new[] = { 0x61, 0x07, 0x00, 0xA6, 0x00, 0x28, 0x00, 0x62, 0x00, 0x3A, 0x00, 0x51, 0x80, 0x5C, 0x01, 0x00 }; +const uint8_t start_capture_third_buffer_565_old[] = { 0x61, 0x07, 0x00, 0x26, 0x00, 0x22, 0x00, 0x98, 0x00, 0x08, 0x00, 0xDE, 0x00, 0xF9, 0x18, 0x0F }; +const uint8_t start_capture_third_buffer_888_old[] = { 0x61, 0x07, 0x00, 0xA6, 0x00, 0x20, 0x00, 0x98, 0x00, 0x08, 0x00, 0xDE, 0x00, 0xF9, 0x18, 0x0F }; + +static const cyop_device_usb_device cypress_optimize_new_3ds_generic_device = { .name = "EZ-USB -> Optimize New 3DS", .long_name = "EZ-USB -> Optimize New 3DS", .device_type = CYPRESS_OPTIMIZE_NEW_3DS_BLANK_DEVICE, .firmware_to_load = optimize_new_3ds_fw, .firmware_size = optimize_new_3ds_fw_len, .fpga_pl_565 = NULL, .fpga_pl_565_size = 0, -.fpga_pl_565_3d = NULL, .fpga_pl_565_3d_size = 0, .fpga_pl_888 = NULL, .fpga_pl_888_size = 0, -.fpga_pl_888_3d = NULL, .fpga_pl_888_3d_size = 0, +.is_new_device = true, .next_device = CYPRESS_OPTIMIZE_NEW_3DS_INSTANTIATED_DEVICE, .has_bcd_device_serial = false, .usb_device_info = { @@ -46,21 +56,20 @@ static const cyopn_device_usb_device cypress_optimize_new_3ds_generic_device = { .do_pipe_clear_reset = false, .alt_interface = 1, .full_data = &cypress_optimize_new_3ds_generic_device, - .get_serial_fn = cypress_optimize_new_3ds_get_serial, - .create_device_fn = cypress_optimize_new_3ds_create_device, + .get_serial_fn = cypress_optimize_3ds_get_serial, + .create_device_fn = cypress_optimize_3ds_create_device, .bcd_device_mask = 0x0000, .bcd_device_wanted_value = 0x0000 } }; -static const cyopn_device_usb_device cypress_optimize_new_3ds_instantiated_device = { +static const cyop_device_usb_device cypress_optimize_new_3ds_instantiated_device = { .name = "Optimize New 3DS", .long_name = "Optimize New 3DS", .device_type = CYPRESS_OPTIMIZE_NEW_3DS_INSTANTIATED_DEVICE, .firmware_to_load = NULL, .firmware_size = 0, .fpga_pl_565 = optimize_new_3ds_565_fpga_pl, .fpga_pl_565_size = optimize_new_3ds_565_fpga_pl_len, -.fpga_pl_565_3d = NULL, .fpga_pl_565_3d_size = 0, .fpga_pl_888 = optimize_new_3ds_888_fpga_pl, .fpga_pl_888_size = optimize_new_3ds_888_fpga_pl_len, -.fpga_pl_888_3d = NULL, .fpga_pl_888_3d_size = 0, +.is_new_device = true, .next_device = CYPRESS_OPTIMIZE_NEW_3DS_INSTANTIATED_DEVICE, .has_bcd_device_serial = true, .usb_device_info = { @@ -73,42 +82,96 @@ static const cyopn_device_usb_device cypress_optimize_new_3ds_instantiated_devic .do_pipe_clear_reset = true, .alt_interface = 0, .full_data = &cypress_optimize_new_3ds_instantiated_device, - .get_serial_fn = cypress_optimize_new_3ds_get_serial, - .create_device_fn = cypress_optimize_new_3ds_create_device, + .get_serial_fn = cypress_optimize_3ds_get_serial, + .create_device_fn = cypress_optimize_3ds_create_device, .bcd_device_mask = 0xFF00, .bcd_device_wanted_value = OPTIMIZE_NEW_3DS_WANTED_VALUE_BASE } }; -static const cyopn_device_usb_device* all_usb_cyopn_device_devices_desc[] = { - &cypress_optimize_new_3ds_generic_device, - &cypress_optimize_new_3ds_instantiated_device, +static const cyop_device_usb_device cypress_optimize_old_3ds_generic_device = { +.name = "EZ-USB -> Optimize Old 3DS", .long_name = "EZ-USB -> Optimize Old 3DS", +.device_type = CYPRESS_OPTIMIZE_OLD_3DS_BLANK_DEVICE, +.firmware_to_load = optimize_old_3ds_fw, .firmware_size = optimize_old_3ds_fw_len, +.fpga_pl_565 = NULL, .fpga_pl_565_size = 0, +.fpga_pl_888 = NULL, .fpga_pl_888_size = 0, +.is_new_device = false, +.next_device = CYPRESS_OPTIMIZE_OLD_3DS_INSTANTIATED_DEVICE, +.has_bcd_device_serial = false, +.usb_device_info = { + .vid = 0x04B4, .pid = 0x8613, + .default_config = 1, .default_interface = 0, + .bulk_timeout = 500, + .ep_ctrl_bulk_in = 0, .ep_ctrl_bulk_out = 0, + .ep_bulk_in = 0, + .max_usb_packet_size = CYPRESS_BASE_USB_PACKET_LIMIT, + .do_pipe_clear_reset = false, + .alt_interface = 1, + .full_data = &cypress_optimize_old_3ds_generic_device, + .get_serial_fn = cypress_optimize_3ds_get_serial, + .create_device_fn = cypress_optimize_3ds_create_device, + .bcd_device_mask = 0x0000, + .bcd_device_wanted_value = 0x0000 +} }; -const cy_device_usb_device* get_cy_usb_info(const cyopn_device_usb_device* usb_device_desc) { +static const cyop_device_usb_device cypress_optimize_old_3ds_instantiated_device = { +.name = "Optimize Old 3DS", .long_name = "Optimize Old 3DS", +.device_type = CYPRESS_OPTIMIZE_OLD_3DS_INSTANTIATED_DEVICE, +.firmware_to_load = NULL, .firmware_size = 0, +.fpga_pl_565 = optimize_old_3ds_565_fpga_pl, .fpga_pl_565_size = optimize_old_3ds_565_fpga_pl_len, +.fpga_pl_888 = optimize_old_3ds_888_fpga_pl, .fpga_pl_888_size = optimize_old_3ds_888_fpga_pl_len, +.is_new_device = false, +.next_device = CYPRESS_OPTIMIZE_OLD_3DS_INSTANTIATED_DEVICE, +.has_bcd_device_serial = true, +.usb_device_info = { + .vid = 0x04B4, .pid = 0x1004, + .default_config = 1, .default_interface = 0, + .bulk_timeout = 500, + .ep_ctrl_bulk_in = 1 | LIBUSB_ENDPOINT_IN, .ep_ctrl_bulk_out = 1 | LIBUSB_ENDPOINT_OUT, + .ep_bulk_in = 2 | LIBUSB_ENDPOINT_IN, + .max_usb_packet_size = CYPRESS_OPTIMIZE_OLD_3DS_USB_PACKET_LIMIT, + .do_pipe_clear_reset = true, + .alt_interface = 0, + .full_data = &cypress_optimize_old_3ds_instantiated_device, + .get_serial_fn = cypress_optimize_3ds_get_serial, + .create_device_fn = cypress_optimize_3ds_create_device, + .bcd_device_mask = 0xFF00, + .bcd_device_wanted_value = OPTIMIZE_OLD_3DS_WANTED_VALUE_BASE +} +}; + +static const cyop_device_usb_device* all_usb_cyop_device_devices_desc[] = { + &cypress_optimize_new_3ds_generic_device, + &cypress_optimize_new_3ds_instantiated_device, + &cypress_optimize_old_3ds_generic_device, + &cypress_optimize_old_3ds_instantiated_device, +}; + +const cy_device_usb_device* get_cy_usb_info(const cyop_device_usb_device* usb_device_desc) { return &usb_device_desc->usb_device_info; } -int GetNumCyOpNDeviceDesc() { - return sizeof(all_usb_cyopn_device_devices_desc) / sizeof(all_usb_cyopn_device_devices_desc[0]); +int GetNumCyOpDeviceDesc() { + return sizeof(all_usb_cyop_device_devices_desc) / sizeof(all_usb_cyop_device_devices_desc[0]); } -const cyopn_device_usb_device* GetCyOpNDeviceDesc(int index) { - if((index < 0) || (index >= GetNumCyOpNDeviceDesc())) +const cyop_device_usb_device* GetCyOpDeviceDesc(int index) { + if((index < 0) || (index >= GetNumCyOpDeviceDesc())) index = 0; - return all_usb_cyopn_device_devices_desc[index]; + return all_usb_cyop_device_devices_desc[index]; } -const cyopn_device_usb_device* GetNextDeviceDesc(const cyopn_device_usb_device* device) { - for(int i = 0; i < GetNumCyOpNDeviceDesc(); i++) { - const cyopn_device_usb_device* examined_device = GetCyOpNDeviceDesc(i); +const cyop_device_usb_device* GetNextDeviceDesc(const cyop_device_usb_device* device) { + for(int i = 0; i < GetNumCyOpDeviceDesc(); i++) { + const cyop_device_usb_device* examined_device = GetCyOpDeviceDesc(i); if(examined_device->device_type == device->next_device) return examined_device; } return NULL; } -bool has_to_load_firmware(const cyopn_device_usb_device* device) { +bool has_to_load_firmware(const cyop_device_usb_device* device) { return !((device->firmware_to_load == NULL) || (device->firmware_size == 0)); } @@ -117,16 +180,20 @@ static bool free_firmware_and_return(uint8_t* fw_data, bool retval) { return retval; } -bool load_firmware(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint8_t patch_id) { +bool load_firmware(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint8_t patch_id) { if(!has_to_load_firmware(device)) return true; + const cyop_device_usb_device* next_device = GetNextDeviceDesc(device); + if((next_device == NULL) || (next_device == device)) + return true; int transferred = 0; + uint16_t base_patch_value = next_device->usb_device_info.bcd_device_wanted_value; uint8_t* fw_data = new uint8_t[device->firmware_size]; memcpy(fw_data, device->firmware_to_load, device->firmware_size); int num_patches = read_le16(fw_data, 1); for(int i = 0; i < num_patches; i++) { int pos_patch = read_le16(fw_data, 2 + i); - write_le16(fw_data + pos_patch, patch_id | OPTIMIZE_NEW_3DS_WANTED_VALUE_BASE); + write_le16(fw_data + pos_patch, patch_id | base_patch_value); } uint8_t buffer[0x8000]; buffer[0] = 1; @@ -157,19 +224,16 @@ bool load_firmware(cy_device_device_handlers* handlers, const cyopn_device_usb_d return free_firmware_and_return(fw_data, true); } -static int read_device_info(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device) { - const uint8_t first_out_buffer[] = { 0x65 }; +static int read_device_info(cy_device_device_handlers* handlers, const cyop_device_usb_device* device) { const int read_block_size = 0x10; const int num_reads = 8; uint8_t in_buffer[read_block_size * num_reads]; int transferred = 0; - int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_out_buffer, sizeof(first_out_buffer), &transferred); - if(ret < 0) - return ret; - uint8_t second_out_buffer[] = { 0x38, 0x00, 0x10, 0x30 }; + int ret = 0; + uint8_t first_out_buffer[] = { 0x38, 0x00, 0x10, 0x30 }; for(int i = 0; i < num_reads; i++) { - second_out_buffer[1] = i * read_block_size; - ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), second_out_buffer, sizeof(second_out_buffer), &transferred); + first_out_buffer[1] = i * read_block_size; + ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_out_buffer, sizeof(first_out_buffer), &transferred); if(ret < 0) return ret; ret = cypress_ctrl_bulk_in_transfer(handlers, get_cy_usb_info(device), in_buffer + (i * read_block_size), read_block_size, &transferred); @@ -181,7 +245,7 @@ static int read_device_info(cy_device_device_handlers* handlers, const cyopn_dev return ret; } -static int read_second_device_id(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint64_t &second_device_id) { +static int read_second_device_id(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint64_t &second_device_id) { const uint8_t first_out_buffer[] = { 0x60, 0x02, 0x30, 0xFF, 0x60, 0xD0, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xCB, 0x60, 0x02, 0x00, 0xFF, 0x00, 0xFF }; uint8_t in_buffer[sizeof(uint64_t)]; int transferred = 0; @@ -201,7 +265,7 @@ static int read_second_device_id(cy_device_device_handlers* handlers, const cyop return ret; } -static int read_device_id(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint64_t &device_id, bool &is_full_0s) { +static int read_device_id(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint64_t &device_id, bool &is_full_0s) { const uint8_t out_buffer[] = { 0x70 }; uint8_t in_buffer[0x10]; int transferred = 0; @@ -223,7 +287,7 @@ static int read_device_id(cy_device_device_handlers* handlers, const cyopn_devic return ret; } -static int read_first_unk_value(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint32_t &value) { +static int read_first_unk_value(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint32_t &value) { const uint8_t out_buffer[] = { 0x60, 0x02, 0x30, 0xFF, 0x60, 0xC9, 0x60, 0x01, 0x20, 0xFF, 0x61, 0x04, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x80, 0xFF, 0x60, 0x01, 0x01, 0xFF }; uint8_t in_buffer[sizeof(uint32_t)]; int transferred = 0; @@ -239,18 +303,29 @@ static int read_first_unk_value(cy_device_device_handlers* handlers, const cyopn return ret; } -static int dual_first_unk_value_setup_read(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint32_t &value32, uint64_t &device_id, uint64_t &second_device_id) { +static int start_command_send(cy_device_device_handlers* handlers, const cyop_device_usb_device* device) { + int transferred = 0; + const uint8_t mono_out_buffer [] = { 0x65 }; + int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), mono_out_buffer, sizeof(mono_out_buffer), &transferred); + if(ret < 0) + return ret; + return ret; +} + +static int dual_first_unk_value_setup_read(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint32_t &value32, uint64_t &device_id, uint64_t &second_device_id) { const uint8_t first_buffer[] = { 0x64, 0x60, 0x01, 0xFF, 0xFF, 0x60, 0x02, 0x00, 0xFF, 0x00, 0xFF }; int transferred = 0; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_buffer, sizeof(first_buffer), &transferred); if(ret < 0) return ret; - ret = read_first_unk_value(handlers, device, value32); - if(ret < 0) - return ret; - ret = read_first_unk_value(handlers, device, value32); - if(ret < 0) - return ret; + if(device->is_new_device) { + ret = read_first_unk_value(handlers, device, value32); + if(ret < 0) + return ret; + ret = read_first_unk_value(handlers, device, value32); + if(ret < 0) + return ret; + } bool is_full_0s = false; ret = read_device_id(handlers, device, device_id, is_full_0s); if(ret < 0) @@ -262,7 +337,7 @@ static int dual_first_unk_value_setup_read(cy_device_device_handlers* handlers, return ret; } -static int fpga_pl_load(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint8_t* fpga_pl, size_t fpga_pl_size) { +static int fpga_pl_load(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint8_t* fpga_pl, size_t fpga_pl_size) { const uint8_t first_buffer[] = { 0x60, 0x02, 0x00, 0xFF, 0x00, 0xFF, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xCB, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xC5, 0x66, 0x64, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xC5 }; int transferred = 0; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_buffer, sizeof(first_buffer), &transferred); @@ -329,21 +404,25 @@ static int fpga_pl_load(cy_device_device_handlers* handlers, const cyopn_device_ return ret; } -static int insert_device_id(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, uint64_t device_id) { +static int insert_device_id(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, uint64_t device_id) { const uint8_t first_buffer[] = { 0x60, 0x02, 0x30, 0xFF, 0x60, 0xCC, 0x60, 0x02, 0x00, 0xFF, 0x00, 0xFF, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xFF, 0x60, 0x02, 0x30, 0xFF, 0x60, 0xFF }; int transferred = 0; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_buffer, sizeof(first_buffer), &transferred); if(ret < 0) return ret; - uint8_t device_id_buffer[] = {0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC3, 0x00, 0x00, 0x02, 0x30, 0xFF, 0x60, 0x65 }; - write_le64(device_id_buffer + 1, device_id); - ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), device_id_buffer, sizeof(device_id_buffer), &transferred); + uint8_t device_id_buffer_new_3ds[] = {0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xC3, 0x00, 0x00, 0x02, 0x30, 0xFF, 0x60, 0x65 }; + uint8_t device_id_buffer_old_3ds[] = {0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2A, 0x0B, 0x01, 0x00, 0x02, 0x30, 0xFF, 0x60, 0x65 }; + uint8_t* target_device_id_buffer = device_id_buffer_new_3ds; + if(!device->is_new_device) + target_device_id_buffer = device_id_buffer_old_3ds; + write_le64(target_device_id_buffer + 1, device_id); + ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), target_device_id_buffer, sizeof(device_id_buffer_new_3ds), &transferred); if(ret < 0) return ret; return ret; } -static int final_capture_start_transfer(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device) { +static int final_capture_start_transfer(cy_device_device_handlers* handlers, const cyop_device_usb_device* device) { const uint8_t first_buffer[] = { 0x5B, 0x59, 0x03 }; int transferred = 0; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), first_buffer, sizeof(first_buffer), &transferred); @@ -352,7 +431,7 @@ static int final_capture_start_transfer(cy_device_device_handlers* handlers, con return ret; } -int capture_start(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, bool is_first_load, bool is_rgb888) { +int capture_start(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, bool is_first_load, bool is_rgb888) { int transferred = 0; int ret = 0; uint32_t value32 = 0; @@ -367,9 +446,14 @@ int capture_start(cy_device_device_handlers* handlers, const cyopn_device_usb_de if(ret < 0) return ret; } - ret = read_device_info(handlers, device); + ret = start_command_send(handlers, device); if(ret < 0) return ret; + if(device->is_new_device) { + ret = read_device_info(handlers, device); + if(ret < 0) + return ret; + } cypress_pipe_reset_ctrl_bulk_in(handlers, get_cy_usb_info(device)); cypress_pipe_reset_ctrl_bulk_out(handlers, get_cy_usb_info(device)); ret = dual_first_unk_value_setup_read(handlers, device, value32, device_id, second_device_id); @@ -400,10 +484,20 @@ int capture_start(cy_device_device_handlers* handlers, const cyopn_device_usb_de return ret; } -int StartCaptureDma(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device, bool is_rgb888) { - uint8_t mono_buffer[0x1]; +static const uint8_t* get_start_capture_third_buffer(const cyop_device_usb_device* device, bool is_rgb888) { + if(device->is_new_device) { + if(is_rgb888) + return start_capture_third_buffer_888_new; + return start_capture_third_buffer_565_new; + } + if(is_rgb888) + return start_capture_third_buffer_888_old; + return start_capture_third_buffer_565_old; +} + +int StartCaptureDma(cy_device_device_handlers* handlers, const cyop_device_usb_device* device, bool is_rgb888) { + const uint8_t mono_buffer[] = { 0x40 }; int transferred = 0; - mono_buffer[0] = 0x40; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), mono_buffer, sizeof(mono_buffer), &transferred); if(ret < 0) return ret; @@ -411,26 +505,23 @@ int StartCaptureDma(cy_device_device_handlers* handlers, const cyopn_device_usb_ ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), second_buffer, sizeof(second_buffer), &transferred); if(ret < 0) return ret; - const uint8_t third_buffer_565[] = { 0x61, 0x07, 0x00, 0x0F, 0x00, 0x3E, 0x00, 0xF8, 0x00, 0x38, 0x00, 0x51, 0x80, 0x5C, 0x01, 0x00 }; - const uint8_t third_buffer_888[] = { 0x61, 0x07, 0x00, 0xA6, 0x00, 0x28, 0x00, 0x62, 0x00, 0x3A, 0x00, 0x51, 0x80, 0x5C, 0x01, 0x00 }; - const uint8_t* third_buffer = third_buffer_565; - if(is_rgb888) - third_buffer = third_buffer_888; - ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), third_buffer, sizeof(third_buffer_565), &transferred); + const uint8_t* third_buffer = get_start_capture_third_buffer(device, is_rgb888); + uint8_t real_third_buffer[sizeof(start_capture_third_buffer_888_new)]; + memcpy(real_third_buffer, third_buffer, sizeof(real_third_buffer)); + ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), real_third_buffer, sizeof(real_third_buffer), &transferred); if(ret < 0) return ret; uint8_t in_buffer[7]; ret = cypress_ctrl_bulk_in_transfer(handlers, get_cy_usb_info(device), in_buffer, sizeof(in_buffer), &transferred); if(ret < 0) return ret; - mono_buffer[0] = 0x65; - ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), mono_buffer, sizeof(mono_buffer), &transferred); + ret = start_command_send(handlers, device); if(ret < 0) return ret; return ret; } -int capture_end(cy_device_device_handlers* handlers, const cyopn_device_usb_device* device) { +int capture_end(cy_device_device_handlers* handlers, const cyop_device_usb_device* device) { int transferred = 0; uint8_t buffer[] = { 0x41 }; int ret = cypress_ctrl_bulk_out_transfer(handlers, get_cy_usb_info(device), buffer, sizeof(buffer), &transferred); @@ -442,7 +533,7 @@ int capture_end(cy_device_device_handlers* handlers, const cyopn_device_usb_devi return ret; } -int ReadFrame(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyopn_device_usb_device* device_desc) { +int ReadFrame(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyop_device_usb_device* device_desc) { // Maybe making this async would be better for lower end hardware... int num_bytes = 0; int ret = cypress_bulk_in_transfer(handlers, get_cy_usb_info(device_desc), buf, length, &num_bytes); @@ -451,6 +542,6 @@ int ReadFrame(cy_device_device_handlers* handlers, uint8_t* buf, int length, con return ret; } -int ReadFrameAsync(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyopn_device_usb_device* device_desc, cy_async_callback_data* cb_data) { +int ReadFrameAsync(cy_device_device_handlers* handlers, uint8_t* buf, int length, const cyop_device_usb_device* device_desc, cy_async_callback_data* cb_data) { return cypress_bulk_in_async(handlers, get_cy_usb_info(device_desc), buf, length, cb_data); } diff --git a/source/conversions.cpp b/source/conversions.cpp index aff23ad..5e5057e 100755 --- a/source/conversions.cpp +++ b/source/conversions.cpp @@ -68,8 +68,6 @@ struct twl_2bit_pixels { uint8_t fourth_b : 1; }; -static void usb_new_3ds_optimize_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d, const bool is_big_endian, bool interleaved_3d, bool requested_3d, bool is_rgb888); - // Optimized de-interleave methods... static inline uint16_t _reverse_endianness(uint16_t data) { @@ -436,7 +434,7 @@ static inline void usb_oldDSconvertVideoToOutputHalfLineDirectOptBE(USBOldDSCapt usb_rgb565convertInterleaveVideoToOutputDirectOptBE(out_ptr_top, out_ptr_bottom, in_ptr, halfline_iters, input_halfline, output_halfline); } -static inline void usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptLE(USB565New3DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { +static inline void usb_3DS565OptimizeconvertVideoToOutputLineDirectOptLE(USB5653DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { //de-interleave pixels const int pixels_size = 2; const int num_screens = 2; @@ -464,7 +462,7 @@ static inline void usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptLE(USB5 } } -static inline void usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptBE(USB565New3DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { +static inline void usb_3DS565OptimizeconvertVideoToOutputLineDirectOptBE(USB5653DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { //de-interleave pixels const int pixels_size = 2; const int num_screens = 2; @@ -492,7 +490,7 @@ static inline void usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptBE(USB5 } } -static inline void usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptLE(USB565New3DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { +static inline void usb_3DS565Optimizeconvert3DVideoToOutputLineDirectOptLE(USB5653DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { //de-interleave pixels const int pixels_size = 2; const int num_screens = 3; @@ -527,7 +525,7 @@ static inline void usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptLE(US } } -static inline void usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptBE(USB565New3DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { +static inline void usb_3DS565Optimizeconvert3DVideoToOutputLineDirectOptBE(USB5653DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { //de-interleave pixels const int pixels_size = 2; const int num_screens = 3; @@ -562,7 +560,7 @@ static inline void usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptBE(US } } -static inline void usb_new3DS888OptimizeconvertVideoToOutputLineDirectOpt(USB888New3DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { +static inline void usb_3DS888OptimizeconvertVideoToOutputLineDirectOpt(USB8883DSOptimizeCaptureReceived *p_in, VideoOutputData *p_out, int column) { //de-interleave pixels const int pixels_size = 3; const size_t column_start_bot_pos = (SCREEN_WIDTH_FIRST_PIXEL_BOTTOM_3DS * 2) + 2; @@ -589,7 +587,7 @@ static inline void usb_new3DS888OptimizeconvertVideoToOutputLineDirectOpt(USB888 } } -static inline void usb_new3DS888Optimizeconvert3DVideoToOutputLineDirectOpt(USB888New3DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { +static inline void usb_3DS888Optimizeconvert3DVideoToOutputLineDirectOpt(USB8883DSOptimizeCaptureReceived_3D *p_in, VideoOutputData *p_out, int column, bool interleaved_3d) { //de-interleave pixels const int pixels_size = 3; const size_t column_start_bot_pos = (SCREEN_WIDTH_FIRST_PIXEL_BOTTOM_3DS * 2) + 2; @@ -720,35 +718,35 @@ static void usb_cypress_nisetro_ds_convertVideoToOutput(CaptureReceived *p_in, V } } -static void usb_new_3ds_optimize_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d, const bool is_big_endian, bool interleaved_3d, bool requested_3d, bool is_rgb888) { +static void usb_3ds_optimize_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d, const bool is_big_endian, bool interleaved_3d, bool requested_3d, bool is_rgb888) { if(!is_rgb888) { if(!enabled_3d) { if(!is_big_endian) for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptLE(&p_in->cypress_new_optimize_received_565, p_out, i); + usb_3DS565OptimizeconvertVideoToOutputLineDirectOptLE(&p_in->cypress_optimize_received_565, p_out, i); else for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS565OptimizeconvertVideoToOutputLineDirectOptBE(&p_in->cypress_new_optimize_received_565, p_out, i); + usb_3DS565OptimizeconvertVideoToOutputLineDirectOptBE(&p_in->cypress_optimize_received_565, p_out, i); expand_2d_to_3d_convertVideoToOutput((uint8_t*)p_out->screen_data, 2, interleaved_3d, requested_3d); } else { if(!is_big_endian) for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptLE(&p_in->cypress_new_optimize_received_565_3d, p_out, i, interleaved_3d); + usb_3DS565Optimizeconvert3DVideoToOutputLineDirectOptLE(&p_in->cypress_optimize_received_565_3d, p_out, i, interleaved_3d); else for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS565Optimizeconvert3DVideoToOutputLineDirectOptBE(&p_in->cypress_new_optimize_received_565_3d, p_out, i, interleaved_3d); + usb_3DS565Optimizeconvert3DVideoToOutputLineDirectOptBE(&p_in->cypress_optimize_received_565_3d, p_out, i, interleaved_3d); } } else { if(!enabled_3d) { for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS888OptimizeconvertVideoToOutputLineDirectOpt(&p_in->cypress_new_optimize_received_888, p_out, i); + usb_3DS888OptimizeconvertVideoToOutputLineDirectOpt(&p_in->cypress_optimize_received_888, p_out, i); expand_2d_to_3d_convertVideoToOutput((uint8_t*)p_out->screen_data, 3, interleaved_3d, requested_3d); } else { for(int i = 0; i < (TOP_WIDTH_3DS + 1); i++) - usb_new3DS888Optimizeconvert3DVideoToOutputLineDirectOpt(&p_in->cypress_new_optimize_received_888_3d, p_out, i, interleaved_3d); + usb_3DS888Optimizeconvert3DVideoToOutputLineDirectOpt(&p_in->cypress_optimize_received_888_3d, p_out, i, interleaved_3d); } } } @@ -839,37 +837,37 @@ bool convertVideoToOutput(VideoOutputData *p_out, const bool is_big_endian, Capt converted = true; } #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(status->device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) { + #ifdef USE_CYPRESS_OPTIMIZE + if(status->device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) { bool is_rgb888 = video_data_type == VIDEO_DATA_RGB; - usb_new_3ds_optimize_convertVideoToOutput(p_in, p_out, is_data_3d, is_big_endian, interleaved_3d, is_3d_requested, is_rgb888); + usb_3ds_optimize_convertVideoToOutput(p_in, p_out, is_data_3d, is_big_endian, interleaved_3d, is_3d_requested, is_rgb888); converted = true; } #endif return converted; } -static USBNew3DSOptimizeHeaderSoundData* getAudioHeaderPtrNewOptimize3DS(CaptureReceived* buffer, bool is_rgb888, bool is_data_3d, int column) { +static USB3DSOptimizeHeaderSoundData* getAudioHeaderPtrOptimize3DS(CaptureReceived* buffer, bool is_rgb888, bool is_data_3d, int column) { if(!is_rgb888) { if(!is_data_3d) - return &buffer->cypress_new_optimize_received_565.columns_data[column].header_sound; - return &buffer->cypress_new_optimize_received_565_3d.columns_data[column].header_sound; + return &buffer->cypress_optimize_received_565.columns_data[column].header_sound; + return &buffer->cypress_optimize_received_565_3d.columns_data[column].header_sound; } if(!is_data_3d) - return &buffer->cypress_new_optimize_received_888.columns_data[column].header_sound; - return &buffer->cypress_new_optimize_received_888_3d.columns_data[column].header_sound; + return &buffer->cypress_optimize_received_888.columns_data[column].header_sound; + return &buffer->cypress_optimize_received_888_3d.columns_data[column].header_sound; } -static inline uint16_t read_sample_indexLE(USBNew3DSOptimizeSingleSoundData* sample) { - return sample->sample_index % OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE; +static inline uint16_t read_sample_indexLE(USB3DSOptimizeSingleSoundData* sample) { + return sample->sample_index % OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE; } -static inline uint16_t read_sample_indexBE(USBNew3DSOptimizeSingleSoundData* sample) { - return _reverse_endianness(sample->sample_index) % OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE; +static inline uint16_t read_sample_indexBE(USB3DSOptimizeSingleSoundData* sample) { + return _reverse_endianness(sample->sample_index) % OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE; } -static inline void copyAudioFromSoundDataNewOptimize3DSLE(std::int16_t *p_out, USBNew3DSOptimizeSingleSoundData* sample, uint64_t& num_inserted, int& last_inserted_index) { - uint16_t read_index = read_sample_indexLE(sample) % OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE; +static inline void copyAudioFromSoundDataOptimize3DSLE(std::int16_t *p_out, USB3DSOptimizeSingleSoundData* sample, uint64_t& num_inserted, int& last_inserted_index) { + uint16_t read_index = read_sample_indexLE(sample) % OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE; if(read_index == last_inserted_index) return; p_out[num_inserted * 2] = sample->sample_l; @@ -878,8 +876,8 @@ static inline void copyAudioFromSoundDataNewOptimize3DSLE(std::int16_t *p_out, U last_inserted_index = read_index; } -static inline void copyAudioFromSoundDataNewOptimize3DSBE(std::int16_t *p_out, USBNew3DSOptimizeSingleSoundData* sample, uint64_t& num_inserted, int& last_inserted_index) { - uint16_t read_index = read_sample_indexBE(sample) % OPTIMIZE_NEW_3DS_AUDIO_BUFFER_MAX_SIZE; +static inline void copyAudioFromSoundDataOptimize3DSBE(std::int16_t *p_out, USB3DSOptimizeSingleSoundData* sample, uint64_t& num_inserted, int& last_inserted_index) { + uint16_t read_index = read_sample_indexBE(sample) % OPTIMIZE_3DS_AUDIO_BUFFER_MAX_SIZE; if(read_index == last_inserted_index) return; p_out[num_inserted * 2] = _reverse_endianness(sample->sample_l); @@ -888,27 +886,27 @@ static inline void copyAudioFromSoundDataNewOptimize3DSBE(std::int16_t *p_out, U last_inserted_index = read_index; } -static void copyAudioNewOptimize3DSLE(std::int16_t *p_out, uint64_t &n_samples, uint16_t &last_buffer_index, CaptureReceived* buffer, bool is_rgb888, bool is_data_3d) { - USBNew3DSOptimizeHeaderSoundData* first_column_data = getAudioHeaderPtrNewOptimize3DS(buffer, is_rgb888, is_data_3d, 0); +static void copyAudioOptimize3DSLE(std::int16_t *p_out, uint64_t &n_samples, uint16_t &last_buffer_index, CaptureReceived* buffer, bool is_rgb888, bool is_data_3d) { + USB3DSOptimizeHeaderSoundData* first_column_data = getAudioHeaderPtrOptimize3DS(buffer, is_rgb888, is_data_3d, 0); uint64_t num_inserted = 0; int last_inserted_index = last_buffer_index; for(int i = 0; i < TOP_WIDTH_3DS; i++) { - USBNew3DSOptimizeHeaderSoundData* curr_column_data = getAudioHeaderPtrNewOptimize3DS(buffer, is_rgb888, is_data_3d, i); - copyAudioFromSoundDataNewOptimize3DSLE(p_out, &curr_column_data->samples[0], num_inserted, last_inserted_index); - copyAudioFromSoundDataNewOptimize3DSLE(p_out, &curr_column_data->samples[1], num_inserted, last_inserted_index); + USB3DSOptimizeHeaderSoundData* curr_column_data = getAudioHeaderPtrOptimize3DS(buffer, is_rgb888, is_data_3d, i); + copyAudioFromSoundDataOptimize3DSLE(p_out, &curr_column_data->samples[0], num_inserted, last_inserted_index); + copyAudioFromSoundDataOptimize3DSLE(p_out, &curr_column_data->samples[1], num_inserted, last_inserted_index); } last_buffer_index = last_inserted_index; n_samples = num_inserted * 2; } -static void copyAudioNewOptimize3DSBE(std::int16_t *p_out, uint64_t &n_samples, uint16_t &last_buffer_index, CaptureReceived* buffer, bool is_rgb888, bool is_data_3d) { - USBNew3DSOptimizeHeaderSoundData* first_column_data = getAudioHeaderPtrNewOptimize3DS(buffer, is_rgb888, is_data_3d, 0); +static void copyAudioOptimize3DSBE(std::int16_t *p_out, uint64_t &n_samples, uint16_t &last_buffer_index, CaptureReceived* buffer, bool is_rgb888, bool is_data_3d) { + USB3DSOptimizeHeaderSoundData* first_column_data = getAudioHeaderPtrOptimize3DS(buffer, is_rgb888, is_data_3d, 0); uint64_t num_inserted = 0; int last_inserted_index = last_buffer_index; for(int i = 0; i < TOP_WIDTH_3DS; i++) { - USBNew3DSOptimizeHeaderSoundData* curr_column_data = getAudioHeaderPtrNewOptimize3DS(buffer, is_rgb888, is_data_3d, i); - copyAudioFromSoundDataNewOptimize3DSBE(p_out, &curr_column_data->samples[0], num_inserted, last_inserted_index); - copyAudioFromSoundDataNewOptimize3DSBE(p_out, &curr_column_data->samples[1], num_inserted, last_inserted_index); + USB3DSOptimizeHeaderSoundData* curr_column_data = getAudioHeaderPtrOptimize3DS(buffer, is_rgb888, is_data_3d, i); + copyAudioFromSoundDataOptimize3DSBE(p_out, &curr_column_data->samples[0], num_inserted, last_inserted_index); + copyAudioFromSoundDataOptimize3DSBE(p_out, &curr_column_data->samples[1], num_inserted, last_inserted_index); } last_buffer_index = last_inserted_index; n_samples = num_inserted * 2; @@ -959,13 +957,13 @@ bool convertAudioToOutput(std::int16_t *p_out, uint64_t &n_samples, uint16_t &la } #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(status->device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) { + #ifdef USE_CYPRESS_OPTIMIZE + if(status->device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) { bool is_rgb888 = video_data_type == VIDEO_DATA_RGB; if(is_big_endian) - copyAudioNewOptimize3DSBE(p_out, n_samples, last_buffer_index, &data_buffer->capture_buf, is_rgb888, is_data_3d); + copyAudioOptimize3DSBE(p_out, n_samples, last_buffer_index, &data_buffer->capture_buf, is_rgb888, is_data_3d); else - copyAudioNewOptimize3DSLE(p_out, n_samples, last_buffer_index, &data_buffer->capture_buf, is_rgb888, is_data_3d); + copyAudioOptimize3DSLE(p_out, n_samples, last_buffer_index, &data_buffer->capture_buf, is_rgb888, is_data_3d); return true; } #endif diff --git a/source/devicecapture.cpp b/source/devicecapture.cpp index 63f5ddf..75f8d5f 100755 --- a/source/devicecapture.cpp +++ b/source/devicecapture.cpp @@ -4,7 +4,7 @@ #include "usb_ds_3ds_capture.hpp" #include "usb_is_device_acquisition.hpp" #include "cypress_nisetro_acquisition.hpp" -#include "cypress_optimize_new_3ds_acquisition.hpp" +#include "cypress_optimize_3ds_acquisition.hpp" #include #include @@ -88,8 +88,8 @@ bool connect(bool print_failed, CaptureData* capture_data, FrontendData* fronten #ifdef USE_CYNI_USB list_devices_cyni_device(devices_list, no_access_list); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - list_devices_cyopn_device(devices_list, no_access_list); + #ifdef USE_CYPRESS_OPTIMIZE + list_devices_cyop_device(devices_list, no_access_list); #endif #ifdef USE_FTD3 list_devices_ftd3(devices_list, no_access_list); @@ -132,8 +132,8 @@ bool connect(bool print_failed, CaptureData* capture_data, FrontendData* fronten if((devices_list[chosen_device].cc_type == CAPTURE_CONN_CYPRESS_NISETRO) && (!cyni_device_connect_usb(print_failed, capture_data, &devices_list[chosen_device]))) return false; #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if((devices_list[chosen_device].cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) && (!cyopn_device_connect_usb(print_failed, capture_data, &devices_list[chosen_device]))) + #ifdef USE_CYPRESS_OPTIMIZE + if((devices_list[chosen_device].cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) && (!cyop_device_connect_usb(print_failed, capture_data, &devices_list[chosen_device]))) return false; #endif #ifdef USE_FTD3 @@ -176,9 +176,9 @@ void captureCall(CaptureData* capture_data) { if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NISETRO) cyni_device_acquisition_main_loop(capture_data); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) - cyopn_device_acquisition_main_loop(capture_data); + #ifdef USE_CYPRESS_OPTIMIZE + if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) + cyop_device_acquisition_main_loop(capture_data); #endif #ifdef USE_FTD3 if(capture_data->status.device.cc_type == CAPTURE_CONN_FTD3) @@ -210,9 +210,9 @@ void captureCall(CaptureData* capture_data) { if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NISETRO) usb_cyni_device_acquisition_cleanup(capture_data); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) - usb_cyopn_device_acquisition_cleanup(capture_data); + #ifdef USE_CYPRESS_OPTIMIZE + if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) + usb_cyop_device_acquisition_cleanup(capture_data); #endif #ifdef USE_FTD3 if(capture_data->status.device.cc_type == CAPTURE_CONN_FTD3) @@ -241,8 +241,8 @@ void captureCall(CaptureData* capture_data) { uint64_t get_audio_n_samples(CaptureData* capture_data, CaptureDataSingleBuffer* data_buffer) { if(!capture_data->status.device.has_audio) return 0; - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) + #ifdef USE_CYPRESS_OPTIMIZE + if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) return -1; #endif uint64_t n_samples = (data_buffer->read - get_video_in_size(capture_data, data_buffer->is_3d, data_buffer->buffer_video_data_type)) / 2; @@ -259,9 +259,9 @@ uint64_t get_video_in_size(CaptureData* capture_data, bool is_3d, InputVideoData if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NISETRO) return cyni_device_get_video_in_size(capture_data); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_NEW_OPTIMIZE) - return cyopn_device_get_video_in_size(capture_data, is_3d, video_data_type); + #ifdef USE_CYPRESS_OPTIMIZE + if(capture_data->status.device.cc_type == CAPTURE_CONN_CYPRESS_OPTIMIZE) + return cyop_device_get_video_in_size(capture_data, is_3d, video_data_type); #endif #ifdef USE_FTD3 if(capture_data->status.device.cc_type == CAPTURE_CONN_FTD3) @@ -364,8 +364,8 @@ void capture_init() { #ifdef USE_CYNI_USB usb_cyni_device_init(); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - usb_cyopn_device_init(); + #ifdef USE_CYPRESS_OPTIMIZE + usb_cyop_device_init(); #endif } @@ -382,7 +382,7 @@ void capture_close() { #ifdef USE_CYNI_USB usb_cyni_device_close(); #endif - #ifdef USE_CYPRESS_NEW_OPTIMIZE - usb_cyopn_device_close(); + #ifdef USE_CYPRESS_OPTIMIZE + usb_cyop_device_close(); #endif }