int main() {
sysUtilRegisterCallback(SYSUTIL_EVENT_SLOT0, sysutil_callback, NULL);
void *host_addr = memalign(1024*1024, HOST_SIZE);
init_screen(host_addr, HOST_SIZE);
setRenderTarget(curr_fb);
int payload = payload_status();
/*
char dlgmsg[256];
sprintf(dlgmsg, "Payload: %d", payload);
showDialog(dlgmsg);
*/
if(payload == ZERO_PAYLOAD) {
s32 fd = 0;
int bdemu = bdemu_version(&fd);
if(bdemu == 0) {
//Wrong or inexistent file.
lv2buzzer(0x1004, 0xa, 0x1b6);
showDialog("Couldn't find correct \"BDEMU.BIN\".");
}
else {
int fw_version = get_version();
if(fw_version == FW_355_VALUE) {
if(bdemu == 2) {
payload_sky(fd);
}
else {
payload_dean(fd);
}
}
else if(fw_version == FW_341_VALUE && bdemu == 2) {
payload_hermes(fd);
}
else {
lv2buzzer(0x1004, 0xa, 0x1b6);
showDialog("BDEMU.BIN doesn't suppoort your firmware.");
}
}
}
msgDialogAbort();
gcmSetWaitFlip(context);
rsxFinish(context, 1);
//Launch Application on exit.
sysProcessExitSpawn2(APP_LAUNCH, NULL, NULL, NULL, 0, 1001, SYS_PROCESS_SPAWN_STACK_SIZE_1M);
return 0;
}
void server_loop(void)
{
int client_connected;
msgType dialog_type;
char *message = (char *) malloc(512);
// did the disc change?
if (bd_contains_sacd_disc && bd_disc_changed)
{
bd_contains_sacd_disc = 0;
}
// by default we have no user controls
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_DISABLE_CANCEL_ON);
if (!bd_contains_sacd_disc)
{
union net_ctl_info info;
if(netCtlGetInfo(NET_CTL_INFO_IP_ADDRESS, &info) == 0)
{
sprintf(message, " SACD Daemon %s\n\n"
"Status: Active\n"
"IP Address: %s (port 2002)\n"
"Client: %s\n"
"Disc: %s",
SACD_RIPPER_VERSION_STRING, info.ip_address,
(is_client_connected() ? "connected" : "none"),
(bd_disc_changed == -1 ? "empty" : "inserted"));
}
else
{
sprintf(message, "No active network connection was detected.\n\nPress OK to refresh.");
dialog_type |= MSG_DIALOG_BTN_TYPE_OK;
}
}
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
dialog_action = 0;
bd_disc_changed = 0;
client_connected = is_client_connected();
while (!dialog_action && !user_requested_exit() && bd_disc_changed == 0 && client_connected == is_client_connected())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
free(message);
}
void show_version(void)
{
msgType dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "SACD-Ripper, Version " SACD_RIPPER_VERSION_STRING, dialog_handler, NULL, NULL);
msgDialogClose(5000.0f);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
}
int user_select_server_mode(void)
{
msgType dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_YESNO | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "Would you like to run in server mode?", dialog_handler, NULL, NULL);
msgDialogClose(5000.0f);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
return dialog_action != 2;
}
static int check_disc_space(sacd_reader_t *sacd_reader, scarletbook_handle_t *handle, int ripping_flags)
{
uint64_t needed_sectors = 0;
if (ripping_flags & RIP_ISO)
{
needed_sectors = sacd_get_total_sectors(sacd_reader);
}
else if (has_two_channel(handle) && ripping_flags & RIP_2CH)
{
needed_sectors = get_two_channel(handle)->track_end - get_two_channel(handle)->track_start;
}
else if (has_both_channels(handle) && ripping_flags & RIP_MCH)
{
needed_sectors = get_multi_channel(handle)->track_end - get_multi_channel(handle)->track_start;
}
if (needed_sectors > output_device_sectors)
{
msgType dialog_type;
char *message = (char *) malloc(512);
LOG(lm_main, LOG_ERROR, ("no enough disc space on %s (%llu), needs: %llu", output_device, output_device_sectors, needed_sectors));
snprintf(message, 512, "Ripping aborted.\nYou do not have enough disc space on [%s (%.2fGB available)].", output_device, output_device_space);
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
dialog_action = 0;
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
while (!user_requested_exit() && !dialog_action)
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
free(message);
return 0;
}
return 1;
}
int install_modules(void)
{
msgType dialogType;
int installed;
if (has_all_modules_installed() != 0)
{
do
{
dialogType = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK);
msgDialogOpen2(dialogType, "The SACD authentication and DST decoder modules need to be extracted.\n"
"Make sure you have the PS3 keys (app-pub-355, iso-iv-355, etc..) in the"
" root of an external USB/flash disc."
, dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
if (user_requested_exit())
return 1;
if (dialog_action != 1)
return -1;
installed = (install_sac_module() == 0 && install_decoder_module() == 0);
if (installed)
{
dialogType = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialogType, "The modules were successfully extracted.", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
}
else
{
dialogType = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK);
msgDialogOpen2(dialogType, "ERROR: The keys were not found or the modules could not be extracted.\n"
"Please try again."
, dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
if (dialog_action != 1)
return -1;
}
} while (!installed && !user_requested_exit());
}
return 0;
}
int main(int argc, char *argv[])
{
int ret, server_mode;
void *host_addr = memalign(1024 * 1024, HOST_SIZE);
msgType dialog_type;
sys_ppu_thread_t id; // start server thread
load_modules();
init_logging();
netInitialize();
netCtlInit();
// Initialize SPUs
LOG(lm_main, LOG_DEBUG, ("Initializing SPUs\n"));
ret = sysSpuInitialize(MAX_PHYSICAL_SPU, MAX_RAW_SPU);
if (ret != 0)
{
LOG(lm_main, LOG_ERROR, ("sysSpuInitialize failed: %d\n", ret));
goto quit;
}
init_screen(host_addr, HOST_SIZE);
ioPadInit(7);
ret = initialize_exit_handlers();
if (ret != 0)
goto quit;
show_version();
if (user_requested_exit())
goto quit;
u64 CEX=0x4345580000000000ULL;
u64 DEX=0x4445580000000000ULL;
u64 DEH=0x4445480000000000ULL;
if(lv2peek(0x80000000002E79C8ULL)==DEX) {dex_mode=2; c_firmware=3.41f;}
else
if(lv2peek(0x80000000002CFF98ULL)==CEX) {dex_mode=0; c_firmware=3.41f;}
else
if(lv2peek(0x80000000002EFE20ULL)==DEX) {dex_mode=2; c_firmware=3.55f;}
else
if(lv2peek(0x80000000002D83D0ULL)==CEX) {dex_mode=0; c_firmware=3.55f;}
else
if(lv2peek(0x8000000000302D88ULL)==DEX) {dex_mode=2; c_firmware=4.21f;}
else
if(lv2peek(0x80000000002E8610ULL)==CEX) {dex_mode=0; c_firmware=4.21f;}
else
if(lv2peek(0x80000000002E9F08ULL)==CEX) {dex_mode=0; c_firmware=4.30f;}
else
if(lv2peek(0x8000000000304630ULL)==DEX) {dex_mode=2; c_firmware=4.30f;}
else
if(lv2peek(0x80000000002E9F18ULL)==CEX) {dex_mode=0; c_firmware=4.31f;}
else
if(lv2peek(0x80000000002EA488ULL)==CEX) {dex_mode=0; c_firmware=4.40f;}
else
if(lv2peek(0x80000000002EA498ULL)==CEX) {dex_mode=0; c_firmware=4.41f;}
else
if(lv2peek(0x8000000000304EF0ULL)==DEX) {dex_mode=2; c_firmware=4.41f;}
else
if(lv2peek(0x80000000002EA9B8ULL)==CEX) {dex_mode=0; c_firmware=4.46f;}
else
if(lv2peek(0x8000000000305410ULL)==DEX) {dex_mode=2; c_firmware=4.46f;}
else
if(lv2peek(0x80000000002E9BE0ULL)==CEX) {dex_mode=0; c_firmware=4.50f;}
else
if(lv2peek(0x8000000000309698ULL)==DEX) {dex_mode=2; c_firmware=4.50f;}
else
if(lv2peek(0x80000000002E9D70ULL)==CEX) {dex_mode=0; c_firmware=4.53f;}
else
if(lv2peek(0x80000000002EC5E0ULL)==CEX) {dex_mode=0; c_firmware=4.55f;}
else
if(lv2peek(0x80000000002ED850ULL)==CEX) {dex_mode=0; c_firmware=4.60f;}
else
if(lv2peek(0x80000000002ED860ULL)==CEX) {dex_mode=0; c_firmware=4.65f;}
else
if(lv2peek(0x800000000030F1A8ULL)==DEX) {dex_mode=2; c_firmware=4.65f;}
else
if(lv2peek(0x80000000002ED778ULL)==CEX) {dex_mode=0; c_firmware=4.70f;}
else
if(lv2peek(0x800000000030F240ULL)==DEX) {dex_mode=2; c_firmware=4.70f;}
else
if(lv2peek(0x80000000002ED818ULL)==CEX) {dex_mode=0; c_firmware=4.75f;}
else
if(lv2peek(0x800000000030F2D0ULL)==DEX) {dex_mode=2; c_firmware=4.75f;}
else
if(lv2peek(0x80000000002ED808ULL)==CEX) {dex_mode=0; c_firmware=4.80f;}
else
if(lv2peek(0x800000000030F3A0ULL)==DEX) {dex_mode=2; c_firmware=4.80f;}
else
if(lv2peek(0x800000000030F3B0ULL)==DEX) {dex_mode=2; c_firmware=4.81f;}
else
if(lv2peek(0x800000000032EB60ULL)==DEH) {deh_mode=2; c_firmware=4.81f;}
else
c_firmware=0.00f;
if(c_firmware==3.55f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_355D;
}
else
if(c_firmware==3.55f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_355;
}
else
if(c_firmware==4.21f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_421;
}
else
if(c_firmware==4.30f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_430;
}
else
if(c_firmware==4.30f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_430D;
}
else
if(c_firmware==4.31f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_431;
}
else
if(c_firmware==4.40f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_440;
}
else
if(c_firmware==4.41f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_441;
}
else
if(c_firmware==4.41f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_441D;
}
else
if(c_firmware==4.46f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_446;
}
else
if(c_firmware==4.50f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_450;
}
else
if(c_firmware==4.53f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_453;
}
else
if(c_firmware==4.55f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_455;
}
else
if(c_firmware==4.60f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_460;
}
else
if(c_firmware==4.65f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_465;
}
else
if(c_firmware==4.65f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_465D;
}
else
if(c_firmware==4.70f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_470;
}
else
if(c_firmware==4.70f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_470D;
}
else
if(c_firmware==4.75f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_475;
}
else
if(c_firmware==4.80f && !dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_480;
}
else
if(c_firmware==4.80f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_480D;
}
else
if(c_firmware==4.75f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_475D;
}
else
if(c_firmware==4.81f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_481D;
}
else
if(c_firmware==4.46f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_446D;
}
else
if(c_firmware==4.50f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_450D;
}
else
if(c_firmware==4.21f && dex_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_421D;
}
else
if(c_firmware==3.41f)
{
SYSCALL_TABLE = SYSCALL_TABLE_341;
}
else
if(c_firmware==4.81f && deh_mode)
{
SYSCALL_TABLE = SYSCALL_TABLE_481H;
}
/*
if(c_firmware>=4.20f && SYSCALL_TABLE)
{
// add and enable lv2 peek/poke + lv1 peek/poke
lv2poke(0x800000000000171CULL, 0x7C0802A6F8010010ULL);
lv2poke(0x800000000000171CULL + 8, 0x396000B644000022ULL);
lv2poke(0x800000000000171CULL + 16, 0x7C832378E8010010ULL);
lv2poke(0x800000000000171CULL + 24, 0x7C0803A64E800020ULL);
lv2poke(0x800000000000171CULL + 32, 0x7C0802A6F8010010ULL);
lv2poke(0x800000000000171CULL + 40, 0x396000B744000022ULL);
lv2poke(0x800000000000171CULL + 48, 0x38600000E8010010ULL);
lv2poke(0x800000000000171CULL + 56, 0x7C0803A64E800020ULL);
lv2poke(0x800000000000171CULL + 64, 0x7C0802A6F8010010ULL);
lv2poke(0x800000000000171CULL + 72, 0x7D4B537844000022ULL);
lv2poke(0x800000000000171CULL + 80, 0xE80100107C0803A6ULL);
lv2poke(0x800000000000171CULL + 88, 0x4E80002080000000ULL);
lv2poke(0x800000000000171CULL + 96, 0x0000170C80000000ULL);
lv2poke(0x800000000000171CULL + 104, 0x0000171480000000ULL);
lv2poke(0x800000000000171CULL + 112, 0x0000171C80000000ULL);
lv2poke(0x800000000000171CULL + 120, 0x0000173C80000000ULL);
lv2poke(0x800000000000171CULL + 128, 0x0000175C00000000ULL);
lv2poke(SYSCALL_PTR( 6), 0x8000000000001778ULL); //sc6
lv2poke(SYSCALL_PTR( 7), 0x8000000000001780ULL); //sc7
lv2poke(SYSCALL_PTR( 8), 0x8000000000001788ULL); //sc8
lv2poke(SYSCALL_PTR( 9), 0x8000000000001790ULL); //sc9
lv2poke(SYSCALL_PTR(10), 0x8000000000001798ULL); //sc10
}*/
// remove patch protection
if(c_firmware==3.55f)
remove_protection();
if(c_firmware==0.00f)
ret = -1;
else
ret = patch_lv1_ss_services();
if (ret < 0)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "ERROR: Couldn't patch lv1 services, returning to the XMB.\nMake sure you are running a firmware which allows patching!", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
goto quit;
}
// patch syscall 864 to allow drive re-init
if(c_firmware==0.0f)
ret = -1;
else
ret = patch_syscall_864();
if (ret < 0)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "ERROR: Couldn't patch syscall 864, returning to the XMB.\nMake sure you are running a firmware which allows patching!", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
goto quit;
}
// install the necessary modules
ret = install_modules();
if (ret < 0)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "Installation was aborted, returning to the XMB.", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
goto quit;
}
if (user_requested_exit())
goto quit;
// reset & re-authenticate the BD drive
sys_storage_reset_bd();
sys_storage_authenticate_bd();
// eject current disc
{
int fd;
ret = sys_storage_open(BD_DEVICE, &fd);
if (ret == 0)
{
ioctl_eject(fd);
sys_storage_close(fd);
}
}
ret = sysDiscRegisterDiscChangeCallback(&bd_eject_disc_callback, &bd_insert_disc_callback);
// poll for an output_device
poll_output_devices();
server_mode = user_select_server_mode();
if (user_requested_exit())
goto quit;
if (server_mode)
{
#ifdef ENABLE_LOGGING
if (output_device)
{
char file_path[100];
sprintf(file_path, "%s/daemon_log.txt", output_device);
set_log_file(file_path);
}
#endif
sysThreadCreate(&id, listener_thread, NULL, 1500, 0x400, 0, "listener");
while (1)
{
// server loop
server_loop();
// break out of the loop when requested
if (user_requested_exit())
break;
}
}
else
{
while (1)
{
// main loop
main_loop();
// break out of the loop when requested
if (user_requested_exit())
break;
}
}
ret = sysDiscUnregisterDiscChangeCallback();
quit:
unpatch_lv1_ss_services();
destroy_logging();
netDeinitialize();
unload_modules();
free(host_addr);
return 0;
}
void main_loop(void)
{
msgType dialog_type;
char *message = (char *) malloc(512);
sacd_reader_t *sacd_reader;
scarletbook_handle_t *sb_handle = 0;
int idx = 0;
if (output_device_changed && output_device)
{
char file_path[100];
sprintf(file_path, "%s/sacd_log.txt", output_device);
set_log_file(file_path);
LOG(lm_main, LOG_NOTICE, ("SACD-Ripper Version " SACD_RIPPER_VERSION_STRING));
}
// did the disc change?
if (bd_contains_sacd_disc && bd_disc_changed)
{
// open the BD device
sacd_reader = sacd_open("/dev_bdvd");
if (sacd_reader)
{
// read the scarletbook information
sb_handle = scarletbook_open(sacd_reader, 0);
if (sb_handle)
{
master_text_t *master_text = &sb_handle->master_text;
master_toc_t *mtoc = sb_handle->master_toc;
if (master_text->disc_title || master_text->disc_title_phonetic)
{
idx += snprintf(message_info + idx, 60, "Title: %s\n", substr((master_text->disc_title ? master_text->disc_title : master_text->disc_title_phonetic), 0, 50));
LOG(lm_main, LOG_NOTICE, ("Album Title: %s", substr((master_text->disc_title ? master_text->disc_title : master_text->disc_title_phonetic), 0, 50)));
}
if (message_info[idx - 1] != '\n') { message_info[idx++] = '\n'; message_info[idx] = '\0'; }
if (master_text->disc_artist || master_text->disc_artist_phonetic)
{
idx += snprintf(message_info + idx, 60, "Artist: %s\n", substr((master_text->disc_artist ? master_text->disc_artist : master_text->disc_artist_phonetic), 0, 50));
LOG(lm_main, LOG_NOTICE, ("Album Artist: %s", substr((master_text->disc_artist ? master_text->disc_artist : master_text->disc_artist_phonetic), 0, 50)));
}
if (message_info[idx - 1] != '\n') { message_info[idx++] = '\n'; message_info[idx] = '\0'; }
idx += snprintf(message_info + idx, 20, "Version: %02i.%02i\n", mtoc->version.major, mtoc->version.minor);
LOG(lm_main, LOG_NOTICE, ("Disc Version: %02i.%02i\n", mtoc->version.major, mtoc->version.minor));
idx += snprintf(message_info + idx, 25, "Created: %4i-%02i-%02i\n", mtoc->disc_date_year, mtoc->disc_date_month, mtoc->disc_date_day);
idx += snprintf(message_info + idx, 15, "Area 0:\n");
idx += snprintf(message_info + idx, 35, " Speakers: %s\n", get_speaker_config_string(sb_handle->area[0].area_toc));
idx += snprintf(message_info + idx, 35, " Encoding: %s\n", get_frame_format_string(sb_handle->area[0].area_toc));
idx += snprintf(message_info + idx, 25, " Tracks: %d (%.2fGB)\n", sb_handle->area[0].area_toc->track_count, ((double) (sb_handle->area[0].area_toc->track_end - sb_handle->area[0].area_toc->track_start) * SACD_LSN_SIZE) / 1073741824.00);
if (has_both_channels(sb_handle))
{
idx += snprintf(message_info + idx, 2, "\n");
idx += snprintf(message_info + idx, 15, "Area 1:\n");
idx += snprintf(message_info + idx, 35, " Speakers: %s\n", get_speaker_config_string(sb_handle->area[1].area_toc));
idx += snprintf(message_info + idx, 35, " Encoding: %s\n", get_frame_format_string(sb_handle->area[1].area_toc));
idx += snprintf(message_info + idx, 25, " Tracks: %d (%.2fGB)\n", sb_handle->area[1].area_toc->track_count, ((double) (sb_handle->area[1].area_toc->track_end - sb_handle->area[1].area_toc->track_start) * SACD_LSN_SIZE) / 1073741824.00);
}
idx += snprintf(message_info + idx, 50, "\nclick X to start ripping, O to change output");
current_ripping_flags = 0;
if (has_two_channel(sb_handle))
{
current_ripping_flags |= RIP_2CH;
if (sb_handle->area[sb_handle->twoch_area_idx].area_toc->frame_format == FRAME_FORMAT_DST)
{
current_ripping_flags |= RIP_2CH_DST;
}
}
if (has_multi_channel(sb_handle))
{
current_ripping_flags |= RIP_MCH;
}
// validate output format as the ripping flags have changed
output_format_changed = 1;
validate_output_format();
scarletbook_close(sb_handle);
sb_handle = 0;
}
else
{
bd_contains_sacd_disc = 0;
}
// close the input device asap
sacd_close(sacd_reader);
sacd_reader = 0;
}
else
{
bd_contains_sacd_disc = 0;
}
}
if (output_device_changed || output_format_changed)
{
// output device
if (output_device)
idx = snprintf(message_output, 35, "Output: %s %.2fGB\n", output_device, output_device_space);
else
idx = snprintf(message_output, 35, "Output: NO DEVICE\n");
// output format
idx += snprintf(message_output + idx, 20, "Format: ");
switch (output_format)
{
case 0:
idx += snprintf(message_output + idx, 20, "2ch DSDIFF (DSD)\n");
break;
case 1:
idx += snprintf(message_output + idx, 20, "2ch DSDIFF (DST)\n");
break;
case 2:
idx += snprintf(message_output + idx, 20, "2ch DSF (DSD)\n");
break;
case 3:
idx += snprintf(message_output + idx, 20, "mch DSDIFF (DSD)\n");
break;
case 4:
idx += snprintf(message_output + idx, 20, "mch DSDIFF (DST)\n");
break;
case 5:
idx += snprintf(message_output + idx, 20, "mch DSF (DSF)\n");
break;
case 6:
idx += snprintf(message_output + idx, 20, "ISO\n");
break;
}
idx += snprintf(message_output + idx, 2, "\n");
}
// by default we have no user controls
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_DISABLE_CANCEL_ON);
if (bd_contains_sacd_disc)
{
snprintf(message, 512, "%s%s", message_output, message_info);
}
else
{
snprintf(message, 512, "The current disc is empty or not recognized as an SACD, please re-insert.\n\n%s"
, (output_device ? "" : "(Also make sure you connect an external fat32 formatted harddisk!)"));
}
// can we start ripping?
if (bd_contains_sacd_disc)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK);
}
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
dialog_action = 0;
bd_disc_changed = 0;
output_device_changed = 0;
output_format_changed = 0;
while (!dialog_action && !user_requested_exit() && bd_disc_changed == 0 && output_device_changed == 0)
{
// poll for new output devices
poll_output_devices();
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
// did user request to start the ripping process?
if (dialog_action == 1 && bd_contains_sacd_disc)
{
start_ripping_gui(output_format_options[output_format]);
reset_output_devices();
// action is handled
dialog_action = 0;
}
else if (dialog_action == 2)
{
#if 0
output_format++;
// max of 7 output options
if (output_format > 6)
{
output_format = 0;
}
#endif
// is the current selection valid?
validate_output_format();
// action is handled
output_format_changed = 1;
dialog_action = 0;
}
free(message);
}
int start_ripping_gui(int ripping_flags)
{
char *albumdir, *musicfilename, *file_path = 0;
sacd_reader_t *sacd_reader;
scarletbook_handle_t *handle;
scarletbook_output_t *output;
msgType dialog_type;
int area_idx, i, ret;
uint32_t prev_upper_progress = 0;
uint32_t prev_lower_progress = 0;
uint32_t delta;
int prev_current_track = 0;
uint32_t prev_stats_total_sectors_processed = 0;
uint32_t prev_stats_current_file_sectors_processed = 0;
uint64_t tb_start, tb_freq;
uint64_t tmp_total_ripping_sectors = 0;
char progress_message[64];
sysAtomicSet(&stats_total_sectors, 0);
sysAtomicSet(&stats_total_sectors_processed, 0);
sysAtomicSet(&stats_current_file_total_sectors, 0);
sysAtomicSet(&stats_current_file_sectors_processed, 0);
sysAtomicSet(&stats_current_track, 0);
sysAtomicSet(&stats_total_tracks, 0);
sacd_reader = sacd_open("/dev_bdvd");
if (sacd_reader)
{
handle = scarletbook_open(sacd_reader, 0);
if (check_disc_space(sacd_reader, handle, ripping_flags))
{
ret = sacd_authenticate(sacd_reader);
if (ret != 0)
{
LOG(lm_main, LOG_ERROR, ("authentication failed: %x", ret));
}
// select the channel area
area_idx = ((has_multi_channel(handle) && ripping_flags & RIP_MCH) || !has_two_channel(handle)) ? handle->mulch_area_idx : handle->twoch_area_idx;
albumdir = get_album_dir(handle);
output = scarletbook_output_create(handle, handle_status_update_track_callback, handle_status_update_progress_callback, safe_fwprintf);
if (ripping_flags & RIP_ISO)
{
#define FAT32_SECTOR_LIMIT 2090000
uint32_t total_sectors = sacd_get_total_sectors(sacd_reader);
uint32_t sector_size = FAT32_SECTOR_LIMIT;
uint32_t sector_offset = 0;
if (total_sectors > FAT32_SECTOR_LIMIT)
{
musicfilename = (char *) malloc(512);
file_path = make_filename(output_device, 0, albumdir, "iso");
for (i = 1; total_sectors != 0; i++)
{
sector_size = min(total_sectors, FAT32_SECTOR_LIMIT);
snprintf(musicfilename, 512, "%s.%03d", file_path, i);
scarletbook_output_enqueue_raw_sectors(output, sector_offset, sector_size, musicfilename, "iso");
sector_offset += sector_size;
total_sectors -= sector_size;
}
free(file_path);
free(musicfilename);
}
else
{
file_path = make_filename(output_device, 0, albumdir, "iso");
scarletbook_output_enqueue_raw_sectors(output, 0, total_sectors, file_path, "iso");
free(file_path);
}
tmp_total_ripping_sectors = sacd_get_total_sectors(sacd_reader);
}
else
{
// do not overwrite previous dump
get_unique_dir(output_device, &albumdir);
// fill the queue with items to rip
for (i = 0; i < handle->area[area_idx].area_toc->track_count; i++)
{
musicfilename = get_music_filename(handle, area_idx, i, 0);
if (ripping_flags & RIP_DSF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dsf");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsf",
1 /* always decode to DSD */);
}
else if (ripping_flags & RIP_DSDIFF)
{
file_path = make_filename(output_device, albumdir, musicfilename, "dff");
scarletbook_output_enqueue_track(output, area_idx, i, file_path, "dsdiff",
((ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST) ? 0 : 1));
}
tmp_total_ripping_sectors += handle->area[area_idx].area_tracklist_offset->track_length_lsn[i];
free(musicfilename);
free(file_path);
}
file_path = make_filename(output_device, albumdir, 0, 0);
LOG(lm_main, LOG_NOTICE, ("setting output folder to: %s", file_path));
recursive_mkdir(file_path, 0777);
free(file_path);
}
scarletbook_output_start(output);
tb_freq = sysGetTimebaseFrequency();
tb_start = __gettime();
{
char *message = (char *) malloc(512);
file_path = make_filename(output_device, albumdir, 0, 0);
snprintf(message, 512, "Title: %s\nOutput: %s\nFormat: %s\nSize: %.2fGB\nArea: %s\nEncoding: %s",
substr(albumdir, 0, 100),
file_path,
(ripping_flags & RIP_DSDIFF ? "DSDIFF" : (ripping_flags & RIP_DSF ? "DSF" : "ISO")),
((double) ((tmp_total_ripping_sectors * SACD_LSN_SIZE) / 1073741824.00)),
(ripping_flags & RIP_2CH ? "2ch" : "mch"),
(ripping_flags & RIP_2CH_DST || ripping_flags & RIP_MCH_DST ? "DST" : (ripping_flags & RIP_ISO ? "DECRYPTED" : "DSD"))
);
free(file_path);
dialog_action = 0;
dialog_type = MSG_DIALOG_MUTE_ON | MSG_DIALOG_DOUBLE_PROGRESSBAR;
msgDialogOpen2(dialog_type, message, dialog_handler, NULL, NULL);
while (!user_requested_exit() && dialog_action == 0 && scarletbook_output_is_busy(output))
{
uint32_t tmp_stats_total_sectors_processed = sysAtomicRead(&stats_total_sectors_processed);
uint32_t tmp_stats_total_sectors = sysAtomicRead(&stats_total_sectors);
uint32_t tmp_stats_current_file_sectors_processed = sysAtomicRead(&stats_current_file_sectors_processed);
uint32_t tmp_stats_current_file_total_sectors = sysAtomicRead(&stats_current_file_total_sectors);
int tmp_current_track = sysAtomicRead(&stats_current_track);
if (tmp_current_track != 0 && tmp_current_track != prev_current_track)
{
memset(progress_message, 0, 64);
musicfilename = get_music_filename(handle, area_idx, tmp_current_track - 1, 0);
// HACK: substr is not thread safe, but it's only used in this thread..
snprintf(progress_message, 63, "Track (%d/%d): [%s...]", tmp_current_track, sysAtomicRead(&stats_total_tracks), substr(musicfilename, 0, 40));
free(musicfilename);
msgDialogProgressBarReset(MSG_PROGRESSBAR_INDEX0);
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX1, progress_message);
prev_upper_progress = 0;
prev_stats_current_file_sectors_processed = 0;
prev_current_track = tmp_current_track;
}
if (tmp_stats_total_sectors != 0 && prev_stats_total_sectors_processed != tmp_stats_total_sectors_processed)
{
delta = (tmp_stats_current_file_sectors_processed + (tmp_stats_current_file_sectors_processed - prev_stats_current_file_sectors_processed)) * 100 / tmp_stats_current_file_total_sectors - prev_upper_progress;
prev_upper_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX0, delta);
delta = (tmp_stats_total_sectors_processed + (tmp_stats_total_sectors_processed - prev_stats_total_sectors_processed)) * 100 / tmp_stats_total_sectors - prev_lower_progress;
prev_lower_progress += delta;
msgDialogProgressBarInc(MSG_PROGRESSBAR_INDEX1, delta);
snprintf(progress_message, 64, "Ripping %.1fMB/%.1fMB at %.2fMB/sec",
((float)(tmp_stats_current_file_sectors_processed * SACD_LSN_SIZE) / 1048576.00),
((float)(tmp_stats_current_file_total_sectors * SACD_LSN_SIZE) / 1048576.00),
(float)((float) tmp_stats_total_sectors_processed * SACD_LSN_SIZE / 1048576.00) / (float)((__gettime() - tb_start) / (float)(tb_freq)));
msgDialogProgressBarSetMsg(MSG_PROGRESSBAR_INDEX0, progress_message);
prev_stats_total_sectors_processed = tmp_stats_total_sectors_processed;
prev_stats_current_file_sectors_processed = tmp_stats_current_file_sectors_processed;
}
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
free(message);
}
free(albumdir);
scarletbook_output_destroy(output);
}
scarletbook_close(handle);
}
sacd_close(sacd_reader);
if (user_requested_exit())
{
return 0;
}
else if (1)
{
dialog_type = (MSG_DIALOG_NORMAL | MSG_DIALOG_BTN_TYPE_OK | MSG_DIALOG_DISABLE_CANCEL_ON);
msgDialogOpen2(dialog_type, "ripping process completed.", dialog_handler, NULL, NULL);
dialog_action = 0;
while (!dialog_action && !user_requested_exit())
{
sysUtilCheckCallback();
flip();
}
msgDialogAbort();
}
return 0;
}
int copy_async_gbl(char *path1, char *path2, u64 size, char *progress_string1, char *progress_string2)
{
int ret = 0;
FILE *fp = NULL;
FILE *fp2 = NULL;
float parts = 0;
float cpart;
char buffer[16384];
use_async_fd = 128;
my_f_async.flags = 0;
single_bar(progress_string1);
parts = (size == 0) ? 0.0f : 100.0f / ((double) size / (double) sizeof(buffer));
cpart = 0;
fp = fopen(path1, "rb");
if(!fp) {ret = -1; goto err;}
fp2 = fopen(path2, "wb");
if(!fp2) {ret = -2; goto err;}
int acum = 0;
while (size != 0ULL) {
int recv = (size > 16384) ? 16384 : size;
recv = fread(buffer, 1, recv, fp);
if (recv <= 0) break;
if (recv > 0) {
loop_write:
if(use_async_fd == 128) {
use_async_fd = 1;
my_f_async.flags = 0;
my_f_async.size = recv;
my_f_async.fp = fp2;
my_f_async.mem = malloc(recv);
if(my_f_async.mem) memcpy(my_f_async.mem, (void *) buffer, recv);
my_f_async.ret = -1;
my_f_async.flags = ASYNC_ENABLE;
event_thread_send(0x555ULL, (u64) my_func_async, (u64) &my_f_async);
} else {
if(!(my_f_async.flags & ASYNC_ENABLE)) {
if(my_f_async.flags & ASYNC_ERROR) {
fclose(fp2); fp2 = NULL; ret = -6; goto err;
}
my_f_async.flags = 0;
my_f_async.size = recv;
my_f_async.fp = fp2;
my_f_async.mem = malloc(recv);
if(my_f_async.mem) memcpy(my_f_async.mem, (void *) buffer, recv);
my_f_async.ret = -1;
my_f_async.flags = ASYNC_ENABLE;
event_thread_send(0x555ULL, (u64) my_func_async, (u64) &my_f_async);
} else {
goto loop_write;
}
}
///////////////////
size -= recv;
acum+= recv;
}
if(progress_action == 2) {ret = -0x555; goto err;}
pad_last_time = 0;
if(1) {
if(acum >= sizeof(buffer)) {
acum-= sizeof(buffer);
cpart += parts;
if(cpart >= 1.0f) {
update_bar((u32) cpart);
cpart-= (float) ((u32) cpart);
}
}
}
}
ret = 0;
err:
if(my_f_async.flags & ASYNC_ENABLE){
wait_event_thread();
if(my_f_async.flags & ASYNC_ERROR) {
if(fp2) fclose(fp2); fp2 = NULL; ret = -6;
}
my_f_async.flags = 0;
}
event_thread_send(0x555ULL, (u64) 0, 0);
msgDialogAbort();
if(fp) {
fclose(fp);
}
if(fp2) {
fclose(fp2);
if(ret < 0) unlink_secure(path2);
}
return ret;
}
static int download_file(char *url, char *file, int mode, u64 *size)
{
int flags = 0;
int ret = 0;
void *http_p = NULL;
void *uri_p = NULL;
httpUri uri;
s32 transID = 0;
s32 clientID;
int pool_size = 0;
int recv = -1;
u64 length = 0;
int code = 0;
FILE *fp = NULL;
float parts = 0;
float cpart;
char buffer[16384];
use_async_fd = 128;
my_f_async.flags = 0;
if(mode == 2) {
if(size) sprintf(temp_buffer + 4096, "File Size: %u MB\n%s", (u32) (*size/0x100000ULL), strrchr(file, '/') + 1);
else sprintf(temp_buffer + 4096, "File: %s", strrchr(file, '/') + 1);
single_bar(temp_buffer + 4096);
}
http_p = malloc(0x10000);
if(!http_p) {ret= -1; goto err;}
ret = httpInit(http_p, 0x10000);
if(ret < 0) goto err;
flags|= 1;
ret = httpCreateClient(&clientID);
if(ret < 0) goto err;
flags|= 2;
httpClientSetConnTimeout(clientID, 10000000);
ret = httpUtilParseUri(NULL, url, NULL, 0, &pool_size);
if (ret < 0) goto err;
uri_p = malloc(pool_size);
if (!uri_p) goto err;
ret = httpUtilParseUri(&uri, url, uri_p, pool_size, NULL);
if (ret < 0) goto err;
ret = httpCreateTransaction(&transID, clientID, HTTP_METHOD_GET, &uri);
if (ret < 0) goto err;
free(uri_p);
uri_p = NULL;
ret = httpSendRequest(transID, NULL, 0, NULL);
if (ret < 0) goto err;
ret = httpResponseGetStatusCode(transID, &code);
if (ret < 0) goto err;
if (code == 404 || code == 403) {ret=-4; goto err;}
ret = httpResponseGetContentLength(transID, &length);
if (ret < 0) {
if (ret == HTTP_STATUS_CODE_No_Content) {
length = 0ULL;
ret = 0;
} else goto err;
}
if(size) *size = length;
if(mode == 1) goto err; // get only the size
if(mode == 2) {
parts = (length == 0) ? 0.0f : 100.0f / ((double) length / (double) sizeof(buffer));
cpart = 0;
}
fp = fopen(file, "wb");
if(!fp) goto err;
int acum = 0;
while (recv != 0 && length != 0ULL) {
memset(buffer, 0x0, sizeof(buffer));
if (httpRecvResponse(transID, buffer, sizeof(buffer) - 1, &recv) < 0) {fclose(fp); ret = -5; goto err;}
if (recv == 0) break;
if (recv > 0) {
//if(fwrite(buffer, 1, recv, fp) != recv) {fclose(fp); fp = NULL; ret = -6; goto err;}
///////////////////
loop_write:
if(use_async_fd == 128) {
use_async_fd = 1;
my_f_async.flags = 0;
my_f_async.size = recv;
my_f_async.fp = fp;
my_f_async.mem = malloc(recv);
if(my_f_async.mem) memcpy(my_f_async.mem, (void *) buffer, recv);
my_f_async.ret = -1;
my_f_async.flags = ASYNC_ENABLE;
event_thread_send(0x555ULL, (u64) my_func_async, (u64) &my_f_async);
} else {
if(!(my_f_async.flags & ASYNC_ENABLE)) {
if(my_f_async.flags & ASYNC_ERROR) {
fclose(fp); fp = NULL; ret = -6; goto err;
}
my_f_async.flags = 0;
my_f_async.size = recv;
my_f_async.fp = fp;
my_f_async.mem = malloc(recv);
if(my_f_async.mem) memcpy(my_f_async.mem, (void *) buffer, recv);
my_f_async.ret = -1;
my_f_async.flags = ASYNC_ENABLE;
event_thread_send(0x555ULL, (u64) my_func_async, (u64) &my_f_async);
} else {
goto loop_write;
}
}
///////////////////
length -= recv;
acum+= recv;
}
if(mode == 2 && progress_action == 2) {ret = -0x555; goto err;}
pad_last_time = 0;
if(mode == 2) {
if(acum >= sizeof(buffer)) {
acum-= sizeof(buffer);
cpart += parts;
if(cpart >= 1.0f) {
update_bar((u32) cpart);
cpart-= (float) ((u32) cpart);
}
}
}
}
ret = 0;
err:
if(my_f_async.flags & ASYNC_ENABLE){
wait_event_thread();
if(my_f_async.flags & ASYNC_ERROR) {
if(fp) fclose(fp); fp = NULL; ret = -6;
}
my_f_async.flags = 0;
}
event_thread_send(0x555ULL, (u64) 0, 0);
if(mode == 2) {
msgDialogAbort();
}
if(fp) {
fclose(fp);
if(ret < 0) unlink_secure(file);
}
if(transID) httpDestroyTransaction(transID);
if(flags & 2) httpDestroyClient(clientID);
if(flags & 1) httpEnd();
if(http_p) free(http_p);
if(uri_p) free(uri_p);
return ret;
}