citra-emu
/
citra-nightly
Archived
1
0
Fork 0
Code

core: Add read-only mode and separate savestate slots for movies 

The read-only mode switch affects how movies interact with savestates after you start a movie playback and load a savestate. When you are in read-only mode, the movie will resume playing from the loaded savestate. When you are in read+write mode however, your input will be recorded over the original movie ('rerecording'). If you wish to start rerecording immediately, you should switch to R+W mode, save a state and then load it.

To make this more user-friendly, I also added a unique ID to the movies, which allows each movie to have an individual set of savestate slots (plus another set for when not doing any movies). This is as recommended by staff at TASVideos.
This commit is contained in:
zhupengfei 2020-06-29 22:32:24 +08:00
parent 2e3834f880
commit ebaa225bcb
No known key found for this signature in database
GPG Key ID: DD129E108BD09378
3 changed files with 102 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
src/core/movie.cpp
View File

@ -3,10 +3,12 @@
// Refer to the license.txt file included.
#include <cstring>
#include <stdexcept>
#include <string>
#include <vector>
#include <boost/optional.hpp>
#include <cryptopp/hex.h>
#include <cryptopp/osrng.h>
#include "common/bit_field.h"
#include "common/common_types.h"
#include "common/file_util.h"
@ -117,12 +119,61 @@ struct CTMHeader {
u64_le program_id; /// ID of the ROM being executed. Also called title_id
std::array<u8, 20> revision; /// Git hash of the revision this movie was created with
u64_le clock_init_time; /// The init time of the system clock
// Unique identifier of the movie, used to support separate savestate slots for TASing
u64_le id;
std::array<u8, 216> reserved; /// Make heading 256 bytes so it has consistent size
std::array<u8, 208> reserved; /// Make heading 256 bytes so it has consistent size
};
static_assert(sizeof(CTMHeader) == 256, "CTMHeader should be 256 bytes");
#pragma pack(pop)
template <class Archive>
void Movie::serialize(Archive& ar, const unsigned int file_version) {
// Only serialize what's needed to make savestates useful for TAS:
u64 _current_byte = static_cast<u64>(current_byte);
ar& _current_byte;
current_byte = static_cast<std::size_t>(_current_byte);
std::vector<u8> recorded_input_ = recorded_input;
ar& recorded_input_;
ar& init_time;
if (file_version > 0) {
if (Archive::is_loading::value) {
u64 savestate_movie_id;
ar& savestate_movie_id;
if (id != savestate_movie_id) {
if (savestate_movie_id == 0) {
throw std::runtime_error("You must close your movie to load this state");
} else {
throw std::runtime_error("You must load the same movie to load this state");
}
}
} else {
ar& id;
}
}
if (Archive::is_loading::value && id != 0) {
if (read_only) { // Do not replace the previously recorded input.
if (play_mode == PlayMode::Recording) {
SaveMovie();
}
if (current_byte >= recorded_input.size()) {
throw std::runtime_error(
"This savestate was created at a later point and must be loaded in R+W mode");
}
play_mode = PlayMode::Playing;
} else {
recorded_input = std::move(recorded_input_);
play_mode = PlayMode::Recording;
}
}
}
SERIALIZE_IMPL(Movie)
bool Movie::IsPlayingInput() const {
return play_mode == PlayMode::Playing;
}
@ -135,6 +186,7 @@ void Movie::CheckInputEnd() {
LOG_INFO(Movie, "Playback finished");
play_mode = PlayMode::None;
init_time = 0;
id = 0;
playback_completion_callback();
}
}
@ -394,6 +446,7 @@ void Movie::SaveMovie() {
CTMHeader header = {};
header.filetype = header_magic_bytes;
header.clock_init_time = init_time;
header.id = id;
Core::System::GetInstance().GetAppLoader().ReadProgramId(header.program_id);
@ -421,10 +474,14 @@ void Movie::StartPlayback(const std::string& movie_file,
save_record.ReadArray(&header, 1);
if (ValidateHeader(header) != ValidationResult::Invalid) {
play_mode = PlayMode::Playing;
record_movie_file = movie_file;
recorded_input.resize(size - sizeof(CTMHeader));
save_record.ReadArray(recorded_input.data(), recorded_input.size());
current_byte = 0;
id = header.id;
playback_completion_callback = completion_callback;
LOG_INFO(Movie, "Loaded Movie, ID: {:016X}", id);
}
} else {
LOG_ERROR(Movie, "Failed to playback movie: Unable to open '{}'", movie_file);
@ -432,9 +489,18 @@ void Movie::StartPlayback(const std::string& movie_file,
}
void Movie::StartRecording(const std::string& movie_file) {
LOG_INFO(Movie, "Enabling Movie recording");
play_mode = PlayMode::Recording;
record_movie_file = movie_file;
// Generate a random ID
CryptoPP::AutoSeededRandomPool rng;
rng.GenerateBlock(reinterpret_cast<CryptoPP::byte*>(&id), sizeof(id));
LOG_INFO(Movie, "Enabling Movie recording, ID: {:016X}", id);
}
void Movie::SetReadOnly(bool read_only_) {
read_only = read_only_;
}
static boost::optional<CTMHeader> ReadHeader(const std::string& movie_file) {
@ -496,6 +562,7 @@ void Movie::Shutdown() {
record_movie_file.clear();
current_byte = 0;
init_time = 0;
id = 0;
}
template <typename... Targs>

32
src/core/movie.h
View File

@ -46,6 +46,18 @@ public:
const std::string& movie_file, std::function<void()> completion_callback = [] {});
void StartRecording(const std::string& movie_file);
/**
* Sets the read-only status.
* When true, movies will be opened in read-only mode. Loading a state will resume playback
* from that state.
* When false, movies will be opened in read/write mode. Loading a state will start recording
* from that state (rerecording). To start rerecording without loading a state, one can save
* and then immediately load while in R/W.
*
* The default is true.
*/
void SetReadOnly(bool read_only);
/// Prepare to override the clock before playing back movies
void PrepareForPlayback(const std::string& movie_file);
@ -58,6 +70,11 @@ public:
u64 GetOverrideInitTime() const;
u64 GetMovieProgramID(const std::string& movie_file) const;
/// Get the current movie's unique ID. Used to provide separate savestate slots for movies.
u64 GetCurrentMovieID() const {
return id;
}
void Shutdown();
/**
@ -133,16 +150,13 @@ private:
u64 init_time;
std::function<void()> playback_completion_callback;
std::size_t current_byte = 0;
u64 id = 0; // ID of the current movie loaded
bool read_only = true;
template <class Archive>
void serialize(Archive& ar, const unsigned int) {
// Only serialize what's needed to make savestates useful for TAS:
u64 _current_byte = static_cast<u64>(current_byte);
ar& _current_byte;
current_byte = static_cast<std::size_t>(_current_byte);
ar& recorded_input;
ar& init_time;
}
void serialize(Archive& ar, const unsigned int file_version);
friend class boost::serialization::access;
};
} // namespace Core
} // namespace Core
BOOST_CLASS_VERSION(Core::Movie, 1)

12
src/core/savestate.cpp
View File

@ -11,6 +11,7 @@
#include "common/zstd_compression.h"
#include "core/cheats/cheats.h"
#include "core/core.h"
#include "core/movie.h"
#include "core/savestate.h"
#include "network/network.h"
#include "video_core/video_core.h"
@ -37,8 +38,15 @@ static_assert(sizeof(CSTHeader) == 256, "CSTHeader should be 256 bytes");
constexpr std::array<u8, 4> header_magic_bytes{{'C', 'S', 'T', 0x1B}};
std::string GetSaveStatePath(u64 program_id, u32 slot) {
return fmt::format("{}{:016X}.{:02d}.cst", FileUtil::GetUserPath(FileUtil::UserPath::StatesDir),
program_id, slot);
const u64 movie_id = Movie::GetInstance().GetCurrentMovieID();
if (movie_id) {
return fmt::format("{}{:016X}.movie{:016X}.{:02d}.cst",
FileUtil::GetUserPath(FileUtil::UserPath::StatesDir), program_id,
movie_id, slot);
} else {
return fmt::format("{}{:016X}.{:02d}.cst",
FileUtil::GetUserPath(FileUtil::UserPath::StatesDir), program_id, slot);
}
}
std::vector<SaveStateInfo> ListSaveStates(u64 program_id) {