/* --------------------------------------------------------------------------------- Implementation file of Greenzone class Copyright (c) 2011-2013 AnS (The MIT License) Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------------ Greenzone - Access zone [Single instance] * stores array of savestates, used for faster movie navigation by Playback cursor * also stores LagLog of current movie Input * saves and loads the data from a project file. On error: truncates Greenzone to last successfully read savestate * regularly checks if there's a savestate of current emulation state, if there's no such savestate in array then creates one and updates lag info for previous frame * implements the working of "Auto-adjust Input according to lag" feature * regularly runs gradual cleaning of the savestates array (for memory saving), deleting oldest savestates * on demand: (when movie Input was changed) truncates the size of Greenzone, deleting savestates that became irrelevant because of new Input. After truncating it may also move Playback cursor (which must always reside within Greenzone) and may launch Playback seeking * stores resources: save id, properties of gradual cleaning, timing of cleaning ------------------------------------------------------------------------------------ */ #include "taseditor_project.h" #include "state.h" #include "zlib.h" extern TASEDITOR_CONFIG taseditorConfig; extern TASEDITOR_PROJECT project; extern PLAYBACK playback; extern HISTORY history; extern BOOKMARKS bookmarks; extern MARKERS_MANAGER markersManager; extern PIANO_ROLL pianoRoll; extern SELECTION selection; extern char lagFlag; char greenzone_save_id[GREENZONE_ID_LEN] = "GREENZONE"; char greenzone_skipsave_id[GREENZONE_ID_LEN] = "GREENZONX"; GREENZONE::GREENZONE() { } void GREENZONE::init() { reset(); nextCleaningTime = clock() + TIME_BETWEEN_CLEANINGS; } void GREENZONE::free() { savestates.resize(0); greenzoneSize = 0; lagLog.reset(); } void GREENZONE::reset() { free(); } void GREENZONE::update() { // keep collecting savestates, this code must be executed at the end of every frame if (taseditorConfig.enableGreenzoning) { collectCurrentState(); } else { // just update Greenzone upper limit if (greenzoneSize <= currFrameCounter) greenzoneSize = currFrameCounter + 1; } // run cleaning from time to time if (clock() > nextCleaningTime) runGreenzoneCleaning(); // also log lag frames if (currFrameCounter > 0) { // lagFlag indicates that lag was in previous frame int old_lagFlag = lagLog.getLagInfoAtFrame(currFrameCounter - 1); // Auto-adjust Input according to lag if (taseditorConfig.autoAdjustInputAccordingToLag && old_lagFlag != LAGGED_UNKNOWN) { if ((old_lagFlag == LAGGED_YES) && !lagFlag) { // there's no more lag on previous frame - shift Input up 1 or more frames adjustUp(); } else if ((old_lagFlag == LAGGED_NO) && lagFlag) { // there's new lag on previous frame - shift Input down 1 frame adjustDown(); } } else { if (lagFlag && (old_lagFlag != LAGGED_YES)) { lagLog.setLagInfo(currFrameCounter - 1, true); // keep current snapshot laglog in touch history.getCurrentSnapshot().laglog.setLagInfo(currFrameCounter - 1, true); } else if (!lagFlag && old_lagFlag != LAGGED_NO) { lagLog.setLagInfo(currFrameCounter - 1, false); // keep current snapshot laglog in touch history.getCurrentSnapshot().laglog.setLagInfo(currFrameCounter - 1, false); } } } } void GREENZONE::collectCurrentState() { if ((int)savestates.size() <= currFrameCounter) savestates.resize(currFrameCounter + 1); // if frame is not saved - log savestate if (!savestates[currFrameCounter].size()) { EMUFILE_MEMORY ms(&savestates[currFrameCounter]); FCEUSS_SaveMS(&ms, Z_DEFAULT_COMPRESSION); ms.trim(); } if (greenzoneSize <= currFrameCounter) greenzoneSize = currFrameCounter + 1; } bool GREENZONE::loadSavestateOfFrame(unsigned int frame) { if (frame >= savestates.size() || !savestates[frame].size()) return false; EMUFILE_MEMORY ms(&savestates[frame]); return FCEUSS_LoadFP(&ms, SSLOADPARAM_NOBACKUP); } void GREENZONE::runGreenzoneCleaning() { bool changed = false; int i = currFrameCounter - taseditorConfig.greenzoneCapacity; if (i <= 0) goto finish; // zeroth frame should not be cleaned int limit; // 2x of 1/2 limit = i - 2 * taseditorConfig.greenzoneCapacity; if (limit < 0) limit = 0; for (; i > limit; i--) { if (i & 0x1) changed = changed | clearSavestateAndFreeMemory(i); } if (i < 0) goto finish; // 4x of 1/4 limit = i - 4 * taseditorConfig.greenzoneCapacity; if (limit < 0) limit = 0; for (; i > limit; i--) { if (i & 0x3) changed = changed | clearSavestateAndFreeMemory(i); } if (i < 0) goto finish; // 8x of 1/8 limit = i - 8 * taseditorConfig.greenzoneCapacity; if (limit < 0) limit = 0; for (; i > limit; i--) { if (i & 0x7) changed = changed | clearSavestateAndFreeMemory(i); } if (i < 0) goto finish; // 16x of 1/16 limit = i - 16 * taseditorConfig.greenzoneCapacity; if (limit < 0) limit = 0; for (; i > limit; i--) { if (i & 0xF) changed = changed | clearSavestateAndFreeMemory(i); } // clear all remaining for (; i > 0; i--) { changed = changed | clearSavestateAndFreeMemory(i); } finish: if (changed) { pianoRoll.redraw(); bookmarks.redrawBookmarksList(); } // shedule next cleaning nextCleaningTime = clock() + TIME_BETWEEN_CLEANINGS; } // returns true if actually cleared savestate data bool GREENZONE::clearSavestateOfFrame(unsigned int frame) { if (frame < savestates.size() && savestates[frame].size()) { savestates[frame].resize(0); return true; } else { return false; } } bool GREENZONE::clearSavestateAndFreeMemory(unsigned int frame) { if (frame < savestates.size() && savestates[frame].size()) { savestates[frame].swap(std::vector()); return true; } else { return false; } } void GREENZONE::ungreenzoneSelectedFrames() { RowsSelection* current_selection = selection.getCopyOfCurrentRowsSelection(); if (current_selection->size() == 0) return; bool changed = false; int size = savestates.size(); int start_index = *current_selection->begin(); int end_index = *current_selection->rbegin(); RowsSelection::reverse_iterator current_selection_rend = current_selection->rend(); // degreenzone frames, going backwards for (RowsSelection::reverse_iterator it(current_selection->rbegin()); it != current_selection_rend; it++) changed = changed | clearSavestateAndFreeMemory(*it); if (changed) { pianoRoll.redraw(); bookmarks.redrawBookmarksList(); } } void GREENZONE::save(EMUFILE *os, int save_type) { if (save_type != GREENZONE_SAVING_MODE_NO) { collectCurrentState(); // in case the project is being saved before the greenzone.update() was called within current frame runGreenzoneCleaning(); if (greenzoneSize > (int)savestates.size()) greenzoneSize = savestates.size(); // write "GREENZONE" string os->fwrite(greenzone_save_id, GREENZONE_ID_LEN); // write LagLog lagLog.save(os); // write size write32le(greenzoneSize, os); // write Playback cursor position write32le(currFrameCounter, os); } int frame, size; int last_tick = 0; switch (save_type) { case GREENZONE_SAVING_MODE_ALL: { // write savestates for (frame = 0; frame < greenzoneSize; ++frame) { // update TASEditor progressbar from time to time if (frame / PROGRESSBAR_UPDATE_RATE > last_tick) { playback.setProgressbar(frame, greenzoneSize); last_tick = frame / PROGRESSBAR_UPDATE_RATE; } if (!savestates[frame].size()) continue; write32le(frame, os); // write savestate size = savestates[frame].size(); write32le(size, os); os->fwrite(&savestates[frame][0], size); } // write -1 as eof for greenzone write32le(-1, os); break; } case GREENZONE_SAVING_MODE_16TH: { // write savestates for (frame = 0; frame < greenzoneSize; ++frame) { if (!(frame & 0xF) || frame == currFrameCounter) { // update TASEditor progressbar from time to time if (frame / PROGRESSBAR_UPDATE_RATE > last_tick) { playback.setProgressbar(frame, greenzoneSize); last_tick = frame / PROGRESSBAR_UPDATE_RATE; } if (!savestates[frame].size()) continue; write32le(frame, os); // write savestate size = savestates[frame].size(); write32le(size, os); os->fwrite(&savestates[frame][0], size); } } // write -1 as eof for greenzone write32le(-1, os); break; } case GREENZONE_SAVING_MODE_MARKED: { // write savestates for (frame = 0; frame < greenzoneSize; ++frame) { if (markersManager.getMarkerAtFrame(frame) || frame == currFrameCounter) { // update TASEditor progressbar from time to time if (frame / PROGRESSBAR_UPDATE_RATE > last_tick) { playback.setProgressbar(frame, greenzoneSize); last_tick = frame / PROGRESSBAR_UPDATE_RATE; } if (!savestates[frame].size()) continue; write32le(frame, os); // write savestate size = savestates[frame].size(); write32le(size, os); os->fwrite(&savestates[frame][0], size); } } // write -1 as eof for greenzone write32le(-1, os); break; } case GREENZONE_SAVING_MODE_NO: { // write "GREENZONX" string os->fwrite(greenzone_skipsave_id, GREENZONE_ID_LEN); // write LagLog lagLog.save(os); // write Playback cursor position write32le(currFrameCounter, os); if (currFrameCounter > 0) { // write ONE savestate for currFrameCounter collectCurrentState(); int size = savestates[currFrameCounter].size(); write32le(size, os); os->fwrite(&savestates[currFrameCounter][0], size); } break; } } } // returns true if couldn't load bool GREENZONE::load(EMUFILE *is, unsigned int offset) { free(); if (offset) { if (is->fseek(offset, SEEK_SET)) goto error; } else { reset(); playback.restartPlaybackFromZeroGround(); // reset Playback cursor to frame 0 return false; } int frame = 0, prev_frame = -1, size = 0; int last_tick = 0; // read "GREENZONE" string char save_id[GREENZONE_ID_LEN]; if ((int)is->fread(save_id, GREENZONE_ID_LEN) < GREENZONE_ID_LEN) goto error; if (!strcmp(greenzone_skipsave_id, save_id)) { // string says to skip loading Greenzone // read LagLog lagLog.load(is); // read Playback cursor position if (read32le(&frame, is)) { currFrameCounter = frame; greenzoneSize = currFrameCounter + 1; savestates.resize(greenzoneSize); if (currFrameCounter) { // there must be one savestate in the file if (read32le(&size, is) && size >= 0) { savestates[frame].resize(size); if (is->fread(&savestates[frame][0], size) == size) { if (loadSavestateOfFrame(currFrameCounter)) { FCEU_printf("No Greenzone in the file\n"); return false; } } } } else { // literally no Greenzone in the file, but this is still not a error reset(); playback.restartPlaybackFromZeroGround(); // reset Playback cursor to frame 0 FCEU_printf("No Greenzone in the file, Playback at frame 0\n"); return false; } } goto error; } if (strcmp(greenzone_save_id, save_id)) goto error; // string is not valid // read LagLog lagLog.load(is); // read size if (read32le(&size, is) && size >= 0 && size <= currMovieData.getNumRecords()) { greenzoneSize = size; savestates.resize(greenzoneSize); // read Playback cursor position if (read32le(&frame, is)) { currFrameCounter = frame; int greenzone_tail_frame = currFrameCounter - taseditorConfig.greenzoneCapacity; int greenzone_tail_frame2 = greenzone_tail_frame - 2 * taseditorConfig.greenzoneCapacity; int greenzone_tail_frame4 = greenzone_tail_frame - 4 * taseditorConfig.greenzoneCapacity; int greenzone_tail_frame8 = greenzone_tail_frame - 8 * taseditorConfig.greenzoneCapacity; int greenzone_tail_frame16 = greenzone_tail_frame - 16 * taseditorConfig.greenzoneCapacity; // read savestates while(1) { if (!read32le(&frame, is)) break; if (frame < 0) break; // -1 = eof // update TASEditor progressbar from time to time if (frame / PROGRESSBAR_UPDATE_RATE > last_tick) { playback.setProgressbar(frame, greenzoneSize); last_tick = frame / PROGRESSBAR_UPDATE_RATE; } // read savestate if (!read32le(&size, is)) break; if (size < 0) break; if (frame <= greenzone_tail_frame16 || (frame <= greenzone_tail_frame8 && (frame & 0xF)) || (frame <= greenzone_tail_frame4 && (frame & 0x7)) || (frame <= greenzone_tail_frame2 && (frame & 0x3)) || (frame <= greenzone_tail_frame && (frame & 0x1))) { // skip loading this savestate if (is->fseek(size, SEEK_CUR) != 0) break; } else { // load this savestate if ((int)savestates.size() <= frame) savestates.resize(frame + 1); savestates[frame].resize(size); if ((int)is->fread(&savestates[frame][0], size) < size) break; prev_frame = frame; // successfully read one Greenzone frame info } } if (prev_frame+1 == greenzoneSize) { // everything went fine - load savestate at cursor position if (loadSavestateOfFrame(currFrameCounter)) return false; } // uh, okay, but maybe we managed to read at least something useful from the file // first see if original position of currFrameCounter was read successfully if (loadSavestateOfFrame(currFrameCounter)) { greenzoneSize = prev_frame+1; // cut greenZoneCount to last good frame FCEU_printf("Greenzone loaded partially\n"); return false; } // then at least jump to some frame that was read successfully for (; prev_frame >= 0; prev_frame--) { if (loadSavestateOfFrame(prev_frame)) { currFrameCounter = prev_frame; greenzoneSize = prev_frame+1; // cut greenZoneCount to this good frame FCEU_printf("Greenzone loaded partially, Playback moved to the end of greenzone\n"); return false; } } } } error: FCEU_printf("Error loading Greenzone\n"); reset(); playback.restartPlaybackFromZeroGround(); // reset Playback cursor to frame 0 return true; } // ------------------------------------------------------------------------------------------------- void GREENZONE::adjustUp() { int at = currFrameCounter - 1; // at = the frame above currFrameCounter // find how many consequent lag frames there are int num_frames_to_erase = 0; while (lagLog.getLagInfoAtFrame(at++) == LAGGED_YES) num_frames_to_erase++; if (num_frames_to_erase > 0) { bool markers_changed = false; // delete these frames of lag currMovieData.eraseRecords(currFrameCounter - 1, num_frames_to_erase); lagLog.eraseFrame(currFrameCounter - 1, num_frames_to_erase); if (taseditorConfig.bindMarkersToInput) { if (markersManager.eraseMarker(currFrameCounter - 1, num_frames_to_erase)) markers_changed = true; } // update movie data size, because Playback cursor must always be inside the movie // if movie length is less or equal to currFrame, pad it with empty frames if (((int)currMovieData.records.size() - 1) <= currFrameCounter) currMovieData.insertEmpty(-1, currFrameCounter - ((int)currMovieData.records.size() - 1)); // update Piano Roll (reduce it if needed) pianoRoll.updateLinesCount(); // register changes int first_input_changes = history.registerAdjustLag(currFrameCounter - 1, 0 - num_frames_to_erase); // if Input in the frame above currFrameCounter has changed then invalidate Greenzone (rewind 1 frame back) // also if the frame above currFrameCounter is lag frame then rewind 1 frame (invalidate Greenzone), because maybe this frame also needs lag removal if ((first_input_changes >= 0 && first_input_changes < currFrameCounter) || (lagLog.getLagInfoAtFrame(currFrameCounter - 1) != LAGGED_NO)) { // custom invalidation procedure, not retriggering LostPosition/PauseFrame invalidate(first_input_changes); bool emu_was_paused = (FCEUI_EmulationPaused() != 0); int saved_pause_frame = playback.getPauseFrame(); playback.ensurePlaybackIsInsideGreenzone(); if (saved_pause_frame >= 0) playback.startSeekingToFrame(saved_pause_frame); if (emu_was_paused) playback.pauseEmulation(); } else { // just invalidate Greenzone after currFrameCounter (this is necessary in order to force user to re-emulate everything after the point, because the lag log data after the currFrameCounter is now in unknown state and it should be collected again) invalidate(currFrameCounter); } if (markers_changed) selection.mustFindCurrentMarker = playback.mustFindCurrentMarker = true; } } void GREENZONE::adjustDown() { int at = currFrameCounter - 1; bool markers_changed = false; // clone frame and insert lag currMovieData.cloneRegion(at, 1); lagLog.insertFrame(at, true, 1); if (taseditorConfig.bindMarkersToInput) { if (markersManager.insertEmpty(at, 1)) markers_changed = true; } // register changes int first_input_changes = history.registerAdjustLag(at, +1); // If Input in the frame above currFrameCounter has changed then invalidate Greenzone (rewind 1 frame back) // This should never actually happen, because we clone the frame, so the Input doesn't change // But the check should remain, in case we decide to insert blank frame instead of cloning if (first_input_changes >= 0 && first_input_changes < currFrameCounter) { // custom invalidation procedure, not retriggering LostPosition/PauseFrame invalidate(first_input_changes); bool emu_was_paused = (FCEUI_EmulationPaused() != 0); int saved_pause_frame = playback.getPauseFrame(); playback.ensurePlaybackIsInsideGreenzone(); if (saved_pause_frame >= 0) playback.startSeekingToFrame(saved_pause_frame); if (emu_was_paused) playback.pauseEmulation(); } else { // just invalidate Greenzone after currFrameCounter invalidate(currFrameCounter); } if (markers_changed) selection.mustFindCurrentMarker = playback.mustFindCurrentMarker = true; } // ------------------------------------------------------------------------------------------------- // This version doesn't restore playback, may be used only by Branching, Recording and AdjustLag functions! void GREENZONE::invalidate(int after) { if (after >= 0) { if (after >= currMovieData.getNumRecords()) after = currMovieData.getNumRecords() - 1; // clear all savestates that became irrelevant for (int i = savestates.size() - 1; i > after; i--) clearSavestateOfFrame(i); if (greenzoneSize > after + 1) { greenzoneSize = after + 1; FCEUMOV_IncrementRerecordCount(); } } // redraw Piano Roll even if Greenzone didn't change pianoRoll.redraw(); bookmarks.redrawBookmarksList(); } // invalidate and restore playback void GREENZONE::invalidateAndUpdatePlayback(int after) { if (after >= 0) { if (after >= currMovieData.getNumRecords()) after = currMovieData.getNumRecords() - 1; // clear all savestates that became irrelevant for (int i = savestates.size() - 1; i > after; i--) clearSavestateOfFrame(i); if (greenzoneSize > after + 1 || currFrameCounter > after) { greenzoneSize = after + 1; FCEUMOV_IncrementRerecordCount(); // either set Playback cursor to be inside the Greenzone or run seeking to restore Playback cursor position if (currFrameCounter >= greenzoneSize) { if (playback.getPauseFrame() >= 0 && !FCEUI_EmulationPaused()) { // emulator was running, so continue seeking, but don't follow the Playback cursor playback.jump(playback.getPauseFrame(), false, true, false); } else { playback.setLastPosition(currFrameCounter); if (taseditorConfig.autoRestoreLastPlaybackPosition) // start seeking to the green arrow, but don't follow the Playback cursor playback.jump(playback.getLastPosition(), false, true, false); else playback.ensurePlaybackIsInsideGreenzone(); } } } } // redraw Piano Roll even if Greenzone didn't change pianoRoll.redraw(); bookmarks.redrawBookmarksList(); } // ------------------------------------------------------------------------------------------------- int GREENZONE::findFirstGreenzonedFrame(int starting_index) { for (int i = starting_index; i < greenzoneSize; ++i) if (savestates[i].size()) return i; return -1; // error } // getters int GREENZONE::getSize() { return greenzoneSize; } // this should only be used by Bookmark Set procedure std::vector& GREENZONE::getSavestateOfFrame(int frame) { return savestates[frame]; } // this function should only be used by Bookmark Deploy procedure void GREENZONE::writeSavestateForFrame(int frame, std::vector& savestate) { if ((int)savestates.size() <= frame) savestates.resize(frame + 1); savestates[frame] = savestate; if (greenzoneSize <= frame) greenzoneSize = frame + 1; } bool GREENZONE::isSavestateEmpty(unsigned int frame) { if ((int)frame < greenzoneSize && frame < savestates.size() && savestates[frame].size()) return false; else return true; }