void video_manager::save_active_screen_snapshots()
{
// if we're native, then write one snapshot per visible screen
if (m_snap_native)
{
// write one snapshot per visible screen
screen_device_iterator iter(machine().root_device());
for (screen_device *screen = iter.first(); screen != nullptr; screen = iter.next())
if (machine().render().is_live(*screen))
{
emu_file file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
osd_file::error filerr = open_next(file, "png");
if (filerr == osd_file::error::NONE)
save_snapshot(screen, file);
}
}
// otherwise, just write a single snapshot
else
{
emu_file file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
osd_file::error filerr = open_next(file, "png");
if (filerr == osd_file::error::NONE)
save_snapshot(nullptr, file);
}
}
void video_manager::save_active_screen_snapshots()
{
// if we're native, then write one snapshot per visible screen
if (m_snap_native)
{
// write one snapshot per visible screen
for (screen_device *screen = machine().first_screen(); screen != NULL; screen = screen->next_screen())
if (machine().render().is_live(*screen))
{
emu_file file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
file_error filerr = open_next(file, "png");
if (filerr == FILERR_NONE)
save_snapshot(screen, file);
}
}
// otherwise, just write a single snapshot
else
{
emu_file file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
file_error filerr = open_next(file, "png");
if (filerr == FILERR_NONE)
save_snapshot(NULL, file);
}
}
void root_node(shared_ptr<Net<Dtype> > net, int iters, Dtype lr)
{
const std::vector<Blob<Dtype>*>& result = net -> output_blobs();
boost::posix_time::ptime timer = boost::posix_time::microsec_clock::local_time();
MPI_Status status;
std::vector<Blob<Dtype>*> bottom_vec;
float loss;
init_buffer(iters, FLAGS_snapshot_intv, net);
for (int i = 0; i < iters; i++) {
MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
ApplyUpdate(net, lr, status.MPI_SOURCE);
std::cout << i << std::endl;
if (i % FLAGS_snapshot_intv == 0)
snapshot(net, i, (boost::posix_time::microsec_clock::local_time() - timer).total_milliseconds());
}
save_snapshot(FLAGS_snap_path);
}
void video_manager::recompute_speed(const attotime &emutime)
{
// if we don't have a starting time yet, or if we're paused, reset our starting point
if (m_speed_last_realtime == 0 || machine().paused())
{
m_speed_last_realtime = osd_ticks();
m_speed_last_emutime = emutime;
}
// if it has been more than the update interval, update the time
attotime delta_emutime = emutime - m_speed_last_emutime;
if (delta_emutime > attotime(0, ATTOSECONDS_PER_SPEED_UPDATE))
{
// convert from ticks to attoseconds
osd_ticks_t realtime = osd_ticks();
osd_ticks_t delta_realtime = realtime - m_speed_last_realtime;
osd_ticks_t tps = osd_ticks_per_second();
m_speed_percent = delta_emutime.as_double() * (double)tps / (double)delta_realtime;
// remember the last times
m_speed_last_realtime = realtime;
m_speed_last_emutime = emutime;
// if we're throttled, this time period counts for overall speed; otherwise, we reset the counter
if (!m_fastforward)
m_overall_valid_counter++;
else
m_overall_valid_counter = 0;
// if we've had at least 4 consecutive valid periods, accumulate stats
if (m_overall_valid_counter >= 4)
{
m_overall_real_ticks += delta_realtime;
while (m_overall_real_ticks >= tps)
{
m_overall_real_ticks -= tps;
m_overall_real_seconds++;
}
m_overall_emutime += delta_emutime;
}
}
// if we're past the "time-to-execute" requested, signal an exit
if (m_seconds_to_run != 0 && emutime.seconds() >= m_seconds_to_run)
{
screen_device *screen = machine().first_screen();
if (screen != nullptr)
{
// create a final screenshot
emu_file file(machine().options().snapshot_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
osd_file::error filerr = file.open(machine().basename(), PATH_SEPARATOR "final.png");
if (filerr == osd_file::error::NONE)
save_snapshot(screen, file);
}
//printf("Scheduled exit at %f\n", emutime.as_double());
// schedule our demise
machine().schedule_exit();
}
}
void update_inputport(void)
{
int i;
UINT32 buttons;
buttons = poll_gamepad();
if (readHomeButton())
{
showmenu();
setup_autofire();
buttons = poll_gamepad();
}
else if ((buttons & PSP_CTRL_RTRIGGER) && (buttons & PSP_CTRL_SELECT))
{
commandlist(1);
buttons = poll_gamepad();
}
buttons = update_autofire(buttons);
for (i = 0; i < MAX_INPUTS; i++)
input_flag[i] = (buttons & input_map[i]) != 0;
update_inputport0();
update_inputport1();
update_inputport2();
if (input_flag[SNAPSHOT])
{
save_snapshot();
}
if (input_flag[SWPLAYER])
{
if (!input_ui_wait)
{
option_controller ^= 1;
ui_popup(TEXT(CONTROLLER_PLAYERx), option_controller + 1);
input_ui_wait = 30;
}
}
if (input_ui_wait > 0) input_ui_wait--;
}
void
hibernate_page_list_setall_machine(hibernate_page_list_t * page_list,
hibernate_page_list_t * page_list_wired,
uint32_t * pagesOut)
{
uint32_t page, count, PCAsize;
/* Get total size of PCA table */
PCAsize = round_page((hash_table_size / PerProcTable[0].ppe_vaddr->pf.pfPTEG)
* sizeof(PCA_t));
page = atop_64(hash_table_base - PCAsize);
count = atop_64(hash_table_size + PCAsize);
hibernate_set_page_state(page_list, page_list_wired, page, count, 0);
pagesOut -= count;
HIBLOG("removed hash, pca: %d pages\n", count);
save_snapshot();
}
void update_inputport(void)
{
int i;
UINT32 buttons;
#ifdef ADHOC
if (adhoc_enable)
{
#if !ADHOC_UPDATE_EVERY_FRAME
if (adhoc_frame & 1)
{
adhoc_frame++;
}
else
#endif
{
while (adhoc_update && Loop == LOOP_EXEC)
{
sceKernelDelayThread(1);
}
cps2_port_value[0] = send_data.port_value[0] & recv_data.port_value[0];
cps2_port_value[1] = send_data.port_value[1] & recv_data.port_value[1];
cps2_port_value[2] = send_data.port_value[2] & recv_data.port_value[2];
cps2_port_value[3] = send_data.port_value[3] & recv_data.port_value[3];
if (Loop == LOOP_EXEC)
Loop = recv_data.loop_flag;
if (recv_data.paused)
adhoc_paused = recv_data.paused;
if (adhoc_paused)
{
adhoc_pause();
}
service_switch = 0;
p12_start_pressed = 0;
if (driver->inp_eeprom) check_eeprom_settings(0);
buttons = poll_gamepad();
if (readHomeButton())
{
buttons = 0;
adhoc_paused = adhoc_server + 1;
}
else if ((buttons & PSP_CTRL_LTRIGGER) && (buttons & PSP_CTRL_RTRIGGER))
{
if (buttons & PSP_CTRL_SELECT)
{
buttons &= ~(PSP_CTRL_SELECT | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER);
service_switch = 1;
}
else if (buttons & PSP_CTRL_START)
{
buttons &= ~(PSP_CTRL_START | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER);
p12_start_pressed = 1;
}
}
buttons = adjust_input(buttons);
buttons = update_autofire(buttons);
for (i = 0; i < MAX_INPUTS; i++)
input_flag[i] = (buttons & input_map[i]) != 0;
update_inputport0();
update_inputport1();
update_inputport2();
if (machine_input_type == INPTYPE_pzloop2) update_inputport3();
send_data.buttons = buttons;
send_data.paused = adhoc_paused;
send_data.loop_flag = Loop;
send_data.frame = adhoc_frame++;
sceKernelDelayThread(100);
adhoc_update = 1;
}
}
else
#endif
{
service_switch = 0;
p12_start_pressed = 0;
if (driver->inp_eeprom) check_eeprom_settings(1);
buttons = poll_gamepad();
if (readHomeButton())
{
showmenu();
setup_autofire();
buttons = poll_gamepad();
}
if ((buttons & PSP_CTRL_LTRIGGER) && (buttons & PSP_CTRL_RTRIGGER))
{
if (buttons & PSP_CTRL_SELECT)
{
buttons &= ~(PSP_CTRL_SELECT | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER);
service_switch = 1;
}
else if (buttons & PSP_CTRL_START)
{
buttons &= ~(PSP_CTRL_START | PSP_CTRL_LTRIGGER | PSP_CTRL_RTRIGGER);
p12_start_pressed = 1;
}
}
buttons = adjust_input(buttons);
buttons = update_autofire(buttons);
for (i = 0; i < MAX_INPUTS; i++)
input_flag[i] = (buttons & input_map[i]) != 0;
update_inputport0();
update_inputport1();
update_inputport2();
if (machine_input_type == INPTYPE_pzloop2) update_inputport3();
if (input_flag[SNAPSHOT])
{
save_snapshot();
}
if (input_flag[SWPLAYER])
{
if (!input_ui_wait)
{
option_controller++;
if (option_controller == input_max_players)
option_controller = INPUT_PLAYER1;
ui_popup(TEXT(CONTROLLER_PLAYERx), option_controller + 1);
input_ui_wait = 30;
}
}
if (input_ui_wait > 0) input_ui_wait--;
}
}
int main (int argc, char ** argv) {
if (argc != 3) {
return 1;
}
// initialize
const char * const INPUT_FILENAME = argv[1];
const char * const OUTPUT_FILENAME = argv[2];
int ok = 0;
av_register_all();
printf("%s\n", INPUT_FILENAME);
InputContext * input_context = input_context_new(INPUT_FILENAME);
if (!input_context) {
ok = EXIT_FAILURE;
goto failed;
}
int64_t sts = START_SECOND;
int counter = 0;
while (sts < input_context->duration) {
// seek keyframe
int64_t ffts = av_rescale(sts, input_context->time_base->den, input_context->time_base->num);
ok = av_seek_frame(input_context->format_context, input_context->stream_index, ffts, AVSEEK_FLAG_BACKWARD);
if (ok < 0) {
printf("seek failed\n");
goto next_time;
}
avcodec_flush_buffers(input_context->codec_context);
AVFrame * pf = av_frame_alloc();
ok = seek_snapshot(input_context->format_context, input_context->codec_context, pf, input_context->stream_index);
if (ok != 0) {
ok = 1;
goto close_frame;
}
char filename[4096] = "";
snprintf(filename, sizeof(filename), OUTPUT_FILENAME, counter);
ok = save_snapshot(filename, input_context->codec_context, pf);
if (ok != 0) {
ok = 1;
goto close_frame;
}
printf("take %d\n", counter);
close_frame:
av_frame_free(&pf);
next_time:
sts += INTERVAL_SECOND;
counter += 1;
}
ok = EXIT_SUCCESS;
input_context_delete(&input_context);
failed:
printf("result %d\n", ok);
return ok;
}
