Leahnaya/cc3dsfs
1
0
Fork 0
mirror of https://github.com/Lorenzooone/cc3dsfs.git synced 2026-03-21 17:55:00 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add support for Partner CTR frame conversion

Browse Source
This commit is contained in:
Lorenzooone 2026-01-05 04:13:53 +01:00
parent 142d204243
commit 735bf4fbf0
5 changed files with 282 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
include/capture_structs.hpp
View File

@ -23,11 +23,11 @@
#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_OPTIMIZE };
enum CaptureConnectionType { CAPTURE_CONN_FTD3, CAPTURE_CONN_USB, CAPTURE_CONN_FTD2, CAPTURE_CONN_IS_NITRO, CAPTURE_CONN_CYPRESS_NISETRO, CAPTURE_CONN_CYPRESS_OPTIMIZE, CAPTURE_CONN_PARTNER_CTR };
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 };
enum PossibleCaptureDevices { CC_LOOPY_OLD_DS, CC_LOOPY_NEW_DS, CC_LOOPY_OLD_3DS, CC_LOOPY_NEW_N3DSXL, CC_IS_NITRO_EMULATOR, CC_IS_NITRO_CAPTURE, CC_IS_TWL_CAPTURE, CC_NISETRO_DS, CC_OPTIMIZE_O3DS, CC_OPTIMIZE_N3DS, CC_POSSIBLE_DEVICES_END };
enum PossibleCaptureDevices { CC_LOOPY_OLD_DS, CC_LOOPY_NEW_DS, CC_LOOPY_OLD_3DS, CC_LOOPY_NEW_N3DSXL, CC_IS_NITRO_EMULATOR, CC_IS_NITRO_CAPTURE, CC_IS_TWL_CAPTURE, CC_NISETRO_DS, CC_OPTIMIZE_O3DS, CC_OPTIMIZE_N3DS, CC_PARTNER_CTR, CC_POSSIBLE_DEVICES_END };
// Readers are Audio and Video. So 2.
// Use 6 extra buffers. 5 for async writing in case the other 2 are busy,
@ -222,6 +222,35 @@ struct ALIGNED(16) PACKED ISTWLCaptureReceived {
ISTWLCaptureAudioReceived audio_capture_in[TWL_CAPTURE_MAX_SAMPLES_CHUNK_NUM];
};
// Shared basic command structure for Kyoto MicroComputer Partner CTR Capture
struct ALIGNED(8) PACKED PartnerCTRCaptureCommand {
uint16_t magic; // 0xE007, little endian, like everything...
uint16_t command;
uint32_t payload_size;
};
// Input data, maybe...? Sent before every screen... Usually empty?
struct ALIGNED(8) PACKED PartnerCTRCaptureCommandHeader0F {
PartnerCTRCaptureCommand command;
uint16_t unk[4];
};
// C4, C5 and C6. C4 is top screen. C5 second top screen. C6 bottom screen.
struct ALIGNED(8) PACKED PartnerCTRCaptureCommandHeaderCxScreen {
PartnerCTRCaptureCommand command;
uint8_t index_kind; // Reflects C4, C5 and C6, so either 04, 05 or 06
uint8_t index;
uint16_t unk[3];
};
// Sound data, maybe...? Sent every 3 screens in 2D...
// Every 4 screens in 3D...?
struct ALIGNED(8) PACKED PartnerCTRCaptureCommandHeaderC7 {
PartnerCTRCaptureCommand command;
uint32_t index;
uint32_t unk[5];
};
struct ALIGNED(16) PACKED USB5653DSOptimizeCaptureReceived {
USB5653DSOptimizeInputColumnData columns_data[TOP_WIDTH_3DS];
USB5653DSOptimizePixelData bottom_only_column[HEIGHT_3DS][2];
@ -317,6 +346,9 @@ struct CaptureDevice {
int firmware_id = 0;
uint32_t usb_speed = 0x200;
bool is_rgb_888 = false;
bool is_horizontally_flipped = false;
bool is_vertically_flipped = false;
bool continuous_3d_screens = true;
};
struct CaptureStatus {

8
include/hw_defs.hpp
View File

@ -77,7 +77,13 @@
#define MAX_IN_VIDEO_WIDTH IN_VIDEO_WIDTH_3DS_ROT
#define MAX_IN_VIDEO_HEIGHT IN_VIDEO_HEIGHT_3DS_3D
#define MAX_IN_VIDEO_SIZE (MAX_IN_VIDEO_WIDTH * MAX_IN_VIDEO_HEIGHT)
// While this is technically correct, it is extremely wasteful.
//#define MAX_IN_VIDEO_SIZE (MAX_IN_VIDEO_WIDTH * MAX_IN_VIDEO_HEIGHT)
// The real MAX_IN_VIDEO_SIZE is the max between
// IN_VIDEO_SIZE_DS, IN_VIDEO_SIZE_3DS_3D and IN_VIDEO_SIZE_3DS_3D_ROT...
// As such, I am forcing this to be IN_VIDEO_SIZE_3DS_3D_ROT,
// as it is the greatest (due to the wasted space it has)...
#define MAX_IN_VIDEO_SIZE IN_VIDEO_SIZE_3DS_3D_ROT
#define MAX_IN_VIDEO_BPP_SIZE IN_VIDEO_BPP_SIZE_3DS
#define MAX_IN_VIDEO_WIDTH_TOP IN_VIDEO_WIDTH_3DS_ROT

15
source/WindowScreen.cpp
View File

@ -686,8 +686,12 @@ void WindowScreen::execute_single_update_texture(bool &manually_converted, bool
bot_width = WIDTH_DS;
bot_height = HEIGHT_DS;
}
if(get_3d_enabled(this->capture_status))
top_width *= 2;
if(get_3d_enabled(this->capture_status)) {
if(this->capture_status->device.continuous_3d_screens)
top_width *= 2;
else
top_height *= 2;
}
if(is_vertically_rotated(this->capture_status->device.base_rotation)) {
std::swap(top_width, top_height);
@ -967,6 +971,13 @@ void WindowScreen::post_texture_conversion_processing(sf::RectangleShape &rect_d
sf::IntRect text_coords_rect = final_in_rect.getTextureRect();
text_coords_rect.position.x += this->curr_frame_texture_pos * MAX_IN_VIDEO_WIDTH;
final_in_rect.setTextureRect(text_coords_rect);
float x_scale = 1;
float y_scale = 1;
if(capture_status->connected && capture_status->device.is_horizontally_flipped)
x_scale = -1;
if(capture_status->connected && capture_status->device.is_vertically_flipped)
y_scale = -1;
final_in_rect.setScale({x_scale, y_scale});
if(this->capture_status->connected && actually_draw) {
bool use_default_shader = !(this->apply_shaders_to_input(rect_data, to_process_tex_data, backup_tex_data, final_in_rect, is_top));
if(use_default_shader)

10
source/cc3dsfs.cpp
View File

@ -467,10 +467,12 @@ static void soundCall(AudioData *audio_data, CaptureData* capture_data, volatile
bool conversion_success = convertAudioToOutput(out_buf[audio_buf_counter], n_samples, last_buffer_index, endianness, data_buffer, &capture_data->status);
if(!conversion_success)
audio_data->signal_conversion_error();
audio.samples.emplace(out_buf[audio_buf_counter], n_samples, out_time);
if(++audio_buf_counter >= NUM_CONCURRENT_AUDIO_BUFFERS)
audio_buf_counter = 0;
audio.samples_wait.unlock();
if(n_samples > 0) {
audio.samples.emplace(out_buf[audio_buf_counter], n_samples, out_time);
if(++audio_buf_counter >= NUM_CONCURRENT_AUDIO_BUFFERS)
audio_buf_counter = 0;
audio.samples_wait.unlock();
}
}
capture_data->data_buffers.ReleaseReaderBuffer(CAPTURE_READER_AUDIO);
}

222
source/conversions.cpp
View File

@ -786,6 +786,179 @@ static void usb_is_device_convertVideoToOutput(CaptureReceived *p_in, VideoOutpu
}
}
// To be moved to the appropriate header, later...
#define PARTNER_CTR_CAPTURE_BASE_COMMAND 0xE007
#define PARTNER_CTR_CAPTURE_COMMAND_INPUT 0x000F
#define PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN 0x00C4
#define PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN 0x00C5
#define PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN 0x00C6
#define PARTNER_CTR_CAPTURE_COMMAND_AUDIO 0x00C7
static PartnerCTRCaptureCommand read_partner_ctr_base_command(uint8_t* data) {
PartnerCTRCaptureCommand out_cmd;
// Important: Ensure the data after the buffers for a single frame
// is stopped by wrong magic value...
out_cmd.magic = read_le16(data, 0);
out_cmd.command = read_le16(data, 1);
out_cmd.payload_size = read_le32(data, 1);
return out_cmd;
}
static size_t get_partner_ctr_size_command_header(PartnerCTRCaptureCommand read_command) {
switch (read_command.command) {
case PARTNER_CTR_CAPTURE_COMMAND_INPUT:
return sizeof(PartnerCTRCaptureCommandHeader0F);
case PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN:
return sizeof(PartnerCTRCaptureCommandHeaderCxScreen);
case PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN:
return sizeof(PartnerCTRCaptureCommandHeaderCxScreen);
case PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN:
return sizeof(PartnerCTRCaptureCommandHeaderCxScreen);
case PARTNER_CTR_CAPTURE_COMMAND_AUDIO:
return sizeof(PartnerCTRCaptureCommandHeaderC7);
default:
ActualConsoleOutTextError("Partner CTR Capture: Unknown command found! " + std::to_string(read_command.command));
return sizeof(PartnerCTRCaptureCommandHeader0F);
}
}
static uint8_t* get_ptr_next_command_partner_ctr(uint8_t* data) {
PartnerCTRCaptureCommand read_command = read_partner_ctr_base_command(data);
return data + get_partner_ctr_size_command_header(read_command) + read_command.payload_size;
}
static uint8_t* find_partner_ctr_x_screen(uint8_t* data) {
PartnerCTRCaptureCommand read_command = read_partner_ctr_base_command(data);
if(read_command.magic != PARTNER_CTR_CAPTURE_BASE_COMMAND)
return NULL;
if((read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN))
return data;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_AUDIO)
data = get_ptr_next_command_partner_ctr(data);
read_command = read_partner_ctr_base_command(data);
if(read_command.magic != PARTNER_CTR_CAPTURE_BASE_COMMAND)
return NULL;
if((read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN))
return data;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_INPUT)
data = get_ptr_next_command_partner_ctr(data);
read_command = read_partner_ctr_base_command(data);
if(read_command.magic != PARTNER_CTR_CAPTURE_BASE_COMMAND)
return NULL;
if((read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN) || (read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN))
return data;
ActualConsoleOutTextError("Partner CTR Capture: Unknown command found! " + std::to_string(read_command.command));
return NULL;
}
static bool is_valid_frame_partner_ctr(uint8_t* data, bool enabled_3d, uint8_t** first_screen, uint8_t** second_screen, uint8_t** third_screen) {
bool has_top = false;
bool has_top_second = !enabled_3d;
bool has_bottom = false;
*first_screen = find_partner_ctr_x_screen(data);
if(*first_screen == NULL)
return false;
PartnerCTRCaptureCommand read_command = read_partner_ctr_base_command(*first_screen);
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN)
has_top = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN)
has_bottom = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN)
has_top_second = true;
*second_screen = find_partner_ctr_x_screen(get_ptr_next_command_partner_ctr(*first_screen));
if(*second_screen == NULL)
return false;
read_command = read_partner_ctr_base_command(*second_screen);
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN)
has_top = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN)
has_bottom = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN)
has_top_second = true;
if(!enabled_3d)
return has_top && has_bottom;
*third_screen = find_partner_ctr_x_screen(get_ptr_next_command_partner_ctr(*second_screen));
if(*third_screen == NULL)
return false;
read_command = read_partner_ctr_base_command(*third_screen);
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN)
has_top = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN)
has_bottom = true;
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_SECOND_TOP_SCREEN)
has_top_second = true;
return has_top && has_top_second && has_bottom;
}
static void convert_partner_ctr_screen_x(uint8_t* screen_ptr, VideoOutputData *p_out) {
if(screen_ptr == NULL)
return;
PartnerCTRCaptureCommand read_command = read_partner_ctr_base_command(screen_ptr);
VideoPixelRGB* out_screen_data = &p_out->rgb_video_output_data.screen_data[0];
screen_ptr += get_partner_ctr_size_command_header(read_command);
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_BOT_SCREEN) {
for(size_t i = 0; i < HEIGHT_3DS; i++)
memcpy(&out_screen_data[i * TOP_WIDTH_3DS], screen_ptr + (i * BOT_WIDTH_3DS * sizeof(VideoPixelRGB)), BOT_WIDTH_3DS * sizeof(VideoPixelRGB));
return;
}
if(read_command.command == PARTNER_CTR_CAPTURE_COMMAND_TOP_SCREEN) {
memcpy(&out_screen_data[TOP_WIDTH_3DS * HEIGHT_3DS], screen_ptr, TOP_WIDTH_3DS * HEIGHT_3DS * sizeof(VideoPixelRGB));
return;
}
memcpy(&out_screen_data[2 * TOP_WIDTH_3DS * HEIGHT_3DS], screen_ptr, TOP_WIDTH_3DS * HEIGHT_3DS * sizeof(VideoPixelRGB));
}
static void usb_partner_ctr_interleave_3d(VideoOutputData *p_out) {
VideoPixelRGB buffer_data[TOP_WIDTH_3DS * 2];
VideoPixelRGB* out_top_screen = &p_out->rgb_video_output_data.screen_data[TOP_WIDTH_3DS * HEIGHT_3DS];
VideoPixelRGB* out_second_top_screen = &p_out->rgb_video_output_data.screen_data[2 * TOP_WIDTH_3DS * HEIGHT_3DS];
for(size_t i = 0; i < HEIGHT_3DS; i++) {
for(size_t j = 0; j < TOP_WIDTH_3DS; j++) {
buffer_data[j * 2] = out_top_screen[(i * TOP_WIDTH_3DS) + j];
buffer_data[(j * 2) + 1] = out_second_top_screen[(i * TOP_WIDTH_3DS) + j];
}
memcpy(&out_top_screen[i * TOP_WIDTH_3DS], &buffer_data[0], TOP_WIDTH_3DS * sizeof(VideoPixelRGB));
memcpy(&out_second_top_screen[i * TOP_WIDTH_3DS], &buffer_data[TOP_WIDTH_3DS], TOP_WIDTH_3DS * sizeof(VideoPixelRGB));
}
}
static void usb_partner_ctr_convertVideoToOutput(CaptureReceived *p_in, VideoOutputData *p_out, bool enabled_3d, bool interleaved_3d, bool requested_3d) {
uint8_t* data = (uint8_t*)p_in;
uint8_t* first_screen = NULL;
uint8_t* second_screen = NULL;
uint8_t* third_screen = NULL;
if(!is_valid_frame_partner_ctr(data, enabled_3d, &first_screen, &second_screen, &third_screen))
return;
convert_partner_ctr_screen_x(first_screen, p_out);
convert_partner_ctr_screen_x(second_screen, p_out);
convert_partner_ctr_screen_x(third_screen, p_out);
if(requested_3d && (!enabled_3d))
memcpy(&p_out->rgb_video_output_data.screen_data[2 * TOP_WIDTH_3DS * HEIGHT_3DS], &p_out->rgb_video_output_data.screen_data[TOP_WIDTH_3DS * HEIGHT_3DS], TOP_WIDTH_3DS * HEIGHT_3DS * sizeof(VideoPixelRGB));
if(requested_3d && interleaved_3d)
usb_partner_ctr_interleave_3d(p_out);
}
bool convertVideoToOutput(VideoOutputData *p_out, const bool is_big_endian, CaptureDataSingleBuffer* data_buffer, CaptureStatus* status, bool interleaved_3d) {
CaptureReceived* p_in = (CaptureReceived*)(((uint8_t*)&data_buffer->capture_buf) + data_buffer->unused_offset);
bool converted = false;
@ -832,6 +1005,12 @@ bool convertVideoToOutput(VideoOutputData *p_out, const bool is_big_endian, Capt
converted = true;
}
#endif
#ifdef USE_PARTNER_CTR
if(status->device.cc_type == CAPTURE_CONN_PARTNER_CTR) {
usb_partner_ctr_convertVideoToOutput(p_in, p_out, is_data_3d, interleaved_3d, is_3d_requested);
converted = true;
}
#endif
return converted;
}
@ -985,6 +1164,43 @@ static void copyAudioOptimize3DS3DForced2DBE(std::int16_t *p_out, uint64_t &n_sa
n_samples = num_inserted * 2;
}
static void usb_partner_ctr_copyBufferToAudio(uint8_t* buffer_ptr, std::int16_t *p_out, uint64_t &n_samples, const bool is_big_endian) {
PartnerCTRCaptureCommand read_command = read_partner_ctr_base_command(buffer_ptr);
if(read_command.magic != PARTNER_CTR_CAPTURE_BASE_COMMAND)
return;
if(read_command.command != PARTNER_CTR_CAPTURE_COMMAND_AUDIO)
return;
buffer_ptr += get_partner_ctr_size_command_header(read_command);
memcpy_data_u16le_origin((uint16_t*)p_out + n_samples, buffer_ptr, (size_t)read_command.payload_size / 2, is_big_endian);
n_samples += read_command.payload_size / 2;
}
static void usb_partner_ctr_copyBufferAfterCommandToAudio(uint8_t* buffer_ptr, std::int16_t *p_out, uint64_t &n_samples, const bool is_big_endian) {
if(buffer_ptr == NULL)
return;
usb_partner_ctr_copyBufferToAudio(get_ptr_next_command_partner_ctr(buffer_ptr), p_out, n_samples, is_big_endian);
}
static void usb_partner_ctr_convertAudioToOutput(CaptureReceived *p_in, std::int16_t *p_out, uint64_t &n_samples, bool enabled_3d, const bool is_big_endian) {
uint8_t* data = (uint8_t*)p_in;
uint8_t* first_screen = NULL;
uint8_t* second_screen = NULL;
uint8_t* third_screen = NULL;
n_samples = 0;
if(!is_valid_frame_partner_ctr(data, enabled_3d, &first_screen, &second_screen, &third_screen))
return;
usb_partner_ctr_copyBufferToAudio(data, p_out, n_samples, is_big_endian);
usb_partner_ctr_copyBufferAfterCommandToAudio(first_screen, p_out, n_samples, is_big_endian);
usb_partner_ctr_copyBufferAfterCommandToAudio(second_screen, p_out, n_samples, is_big_endian);
usb_partner_ctr_copyBufferAfterCommandToAudio(third_screen, p_out, n_samples, is_big_endian);
}
bool convertAudioToOutput(std::int16_t *p_out, uint64_t &n_samples, uint16_t &last_buffer_index, const bool is_big_endian, CaptureDataSingleBuffer* data_buffer, CaptureStatus* status) {
if(!status->device.has_audio)
return true;
@ -1057,6 +1273,12 @@ bool convertAudioToOutput(std::int16_t *p_out, uint64_t &n_samples, uint16_t &la
return true;
}
#endif
#ifdef USE_PARTNER_CTR
if(status->device.cc_type == CAPTURE_CONN_PARTNER_CTR) {
usb_partner_ctr_convertAudioToOutput(p_in, p_out, n_samples, is_data_3d, is_big_endian);
return true;
}
#endif
if(base_ptr == NULL)
return false;
memcpy_data_u16le_origin((uint16_t*)p_out, base_ptr, (size_t)n_samples, is_big_endian);