838 lines
18 KiB
C#
838 lines
18 KiB
C#
using System;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
using BizHawk.Common;
|
|
using BizHawk.Emulation.Common;
|
|
|
|
namespace BizHawk.Client.Common
|
|
{
|
|
public class Movie : IMovie
|
|
{
|
|
private readonly MovieLog _log = new MovieLog();
|
|
private readonly PlatformFrameRates _frameRates = new PlatformFrameRates();
|
|
|
|
private Moviemode _mode = Moviemode.Inactive;
|
|
private int _preloadFramecount; // Not a a reliable number, used for preloading (when no log has yet been loaded), this is only for quick stat compilation for dialogs such as play movie
|
|
private bool _changes;
|
|
private int? _loopOffset;
|
|
|
|
public Movie(string filename, bool startsFromSavestate = false)
|
|
: this(startsFromSavestate)
|
|
{
|
|
Header.Rerecords = 0;
|
|
Filename = filename;
|
|
Loaded = !string.IsNullOrWhiteSpace(filename);
|
|
}
|
|
|
|
public Movie(bool startsFromSavestate = false)
|
|
{
|
|
Header = new MovieHeader();
|
|
Filename = string.Empty;
|
|
_preloadFramecount = 0;
|
|
Header.StartsFromSavestate = startsFromSavestate;
|
|
|
|
IsCountingRerecords = true;
|
|
_mode = Moviemode.Inactive;
|
|
MakeBackup = true;
|
|
}
|
|
|
|
private enum Moviemode { Inactive, Play, Record, Finished }
|
|
|
|
#region Properties
|
|
|
|
public string PreferredExtension { get { return "bkm"; } }
|
|
|
|
public static string Extension { get { return "bkm"; } }
|
|
|
|
public IMovieHeader Header { get; private set; }
|
|
|
|
public bool MakeBackup { get; set; }
|
|
public string Filename { get; set; }
|
|
public bool IsCountingRerecords { get; set; }
|
|
|
|
public bool Loaded { get; private set; }
|
|
|
|
public int InputLogLength
|
|
{
|
|
get { return _log.Length; }
|
|
}
|
|
|
|
public double FrameCount
|
|
{
|
|
get
|
|
{
|
|
if (_loopOffset.HasValue)
|
|
{
|
|
return double.PositiveInfinity;
|
|
}
|
|
|
|
if (Loaded)
|
|
{
|
|
return _log.Length;
|
|
}
|
|
|
|
return _preloadFramecount;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Mode API
|
|
|
|
public bool IsPlaying
|
|
{
|
|
get { return _mode == Moviemode.Play || _mode == Moviemode.Finished; }
|
|
}
|
|
|
|
public bool IsRecording
|
|
{
|
|
get { return _mode == Moviemode.Record; }
|
|
}
|
|
|
|
public bool IsActive
|
|
{
|
|
get { return _mode != Moviemode.Inactive; }
|
|
}
|
|
|
|
public bool IsFinished
|
|
{
|
|
get { return _mode == Moviemode.Finished; }
|
|
}
|
|
|
|
public bool Changes
|
|
{
|
|
get { return _changes; }
|
|
}
|
|
|
|
public void StartNewRecording()
|
|
{
|
|
// adelikat: ClearSaveRam shouldn't be here at all most likely, especially considering this is an implementation detail
|
|
// If Starting a new recording requires clearing sram it shoudl be done at a higher layer and not rely on all IMovies doing this
|
|
// Haven't removed it yet because I coudln't guarantee that power-on movies coudl live without it
|
|
// And the immediate fire is that Savestate movies are breaking
|
|
if (!Header.StartsFromSavestate) // && Global.Emulator.SystemId != "WSWAN")
|
|
{
|
|
Global.Emulator.ClearSaveRam();
|
|
}
|
|
|
|
_mode = Moviemode.Record;
|
|
if (Global.Config.EnableBackupMovies && MakeBackup && _log.Length > 0)
|
|
{
|
|
SaveBackup();
|
|
MakeBackup = false;
|
|
}
|
|
|
|
_log.Clear();
|
|
}
|
|
|
|
public void StartNewPlayback()
|
|
{
|
|
// See StartNewRecording for details as to why this savestate check is here
|
|
if (!Header.StartsFromSavestate) // && Global.Emulator.SystemId != "WSWAN")
|
|
{
|
|
Global.Emulator.ClearSaveRam();
|
|
}
|
|
|
|
_mode = Moviemode.Play;
|
|
}
|
|
|
|
public void SwitchToRecord()
|
|
{
|
|
_mode = Moviemode.Record;
|
|
}
|
|
|
|
public void SwitchToPlay()
|
|
{
|
|
_mode = Moviemode.Play;
|
|
Save();
|
|
}
|
|
|
|
public void Stop(bool saveChanges = true)
|
|
{
|
|
if (saveChanges)
|
|
{
|
|
if (_mode == Moviemode.Record || _changes)
|
|
{
|
|
Save();
|
|
}
|
|
}
|
|
|
|
_changes = false;
|
|
_mode = Moviemode.Inactive;
|
|
}
|
|
|
|
/// <summary>
|
|
/// If a movie is in playback mode, this will set it to movie finished
|
|
/// </summary>
|
|
private void Finish()
|
|
{
|
|
if (_mode == Moviemode.Play)
|
|
{
|
|
_mode = Moviemode.Finished;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public File Handling
|
|
|
|
public void SaveAs(string path)
|
|
{
|
|
Filename = path;
|
|
if (!Loaded)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var directory_info = new FileInfo(Filename).Directory;
|
|
if (directory_info != null)
|
|
{
|
|
Directory.CreateDirectory(directory_info.FullName);
|
|
}
|
|
|
|
Write(Filename);
|
|
}
|
|
|
|
public void Save()
|
|
{
|
|
if (!Loaded || string.IsNullOrWhiteSpace(Filename))
|
|
{
|
|
return;
|
|
}
|
|
|
|
SaveAs(Filename);
|
|
_changes = false;
|
|
}
|
|
|
|
public void SaveBackup()
|
|
{
|
|
if (!Loaded || string.IsNullOrWhiteSpace(Filename))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var backupName = Filename;
|
|
backupName = backupName.Insert(Filename.LastIndexOf("."), string.Format(".{0:yyyy-MM-dd HH.mm.ss}", DateTime.Now));
|
|
backupName = Path.Combine(Global.Config.PathEntries["Global", "Movie backups"].Path, Path.GetFileName(backupName) ?? string.Empty);
|
|
|
|
var directory_info = new FileInfo(backupName).Directory;
|
|
if (directory_info != null)
|
|
{
|
|
Directory.CreateDirectory(directory_info.FullName);
|
|
}
|
|
|
|
Write(backupName);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load Header information only for displaying file information in dialogs such as play movie
|
|
/// TODO - consider not loading the SavestateBinaryBase64Blob key?
|
|
/// </summary>
|
|
public bool PreLoadText(HawkFile hawkFile)
|
|
{
|
|
Loaded = false;
|
|
var file = new FileInfo(hawkFile.CanonicalFullPath);
|
|
|
|
if (file.Exists == false)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
Header.Clear();
|
|
_log.Clear();
|
|
|
|
var origStreamPosn = hawkFile.GetStream().Position;
|
|
hawkFile.GetStream().Position = 0; // Reset to start
|
|
|
|
// No using block because we're sharing the stream and need to give it back undisposed.
|
|
var sr = new StreamReader(hawkFile.GetStream());
|
|
|
|
for(;;)
|
|
{
|
|
//read to first space (key/value delimeter), or pipe, or EOF
|
|
int first = sr.Read();
|
|
|
|
if (first == -1) break; //EOF
|
|
else if(first == '|') //pipe: begin input log
|
|
{
|
|
//NOTE - this code is a bit convoluted due to its predating the basic outline of the parser which was upgraded in may 2014
|
|
string line = '|' + sr.ReadLine();
|
|
|
|
//how many bytes are left, total?
|
|
long remain = sr.BaseStream.Length - sr.BaseStream.Position;
|
|
|
|
//try to find out whether we use \r\n or \n
|
|
//but only look for 1K characters.
|
|
bool usesR = false;
|
|
for (int i = 0; i < 1024; i++)
|
|
{
|
|
int c = sr.Read();
|
|
if (c == -1)
|
|
break;
|
|
if (c == '\r')
|
|
{
|
|
usesR = true;
|
|
break;
|
|
}
|
|
if (c == '\n')
|
|
break;
|
|
}
|
|
|
|
int lineLen = line.Length + 1; //account for \n
|
|
if (usesR) lineLen++; //account for \r
|
|
|
|
_preloadFramecount = (int)(remain / lineLen); //length is remaining bytes / length per line
|
|
_preloadFramecount++; //account for the current line
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//a header line. finish reading key token, to make sure it isn't one of the FORBIDDEN keys
|
|
StringBuilder sbLine = new StringBuilder();
|
|
sbLine.Append((char)first);
|
|
for (; ; )
|
|
{
|
|
int c = sr.Read();
|
|
if (c == -1) break;
|
|
if (c == '\n') break;
|
|
if (c == ' ') break;
|
|
sbLine.Append((char)c);
|
|
}
|
|
|
|
string line = sbLine.ToString();
|
|
|
|
//ignore these suckers, theyre way too big for preloading. seriously, we will get out of memory errors.
|
|
bool skip = false;
|
|
if (line == HeaderKeys.SAVESTATEBINARYBASE64BLOB) skip = true;
|
|
|
|
if (skip)
|
|
{
|
|
//skip remainder of the line
|
|
sr.DiscardBufferedData();
|
|
var stream = sr.BaseStream;
|
|
for (; ; )
|
|
{
|
|
int c = stream.ReadByte();
|
|
if (c == -1) break;
|
|
if (c == '\n') break;
|
|
}
|
|
//proceed to next line
|
|
continue;
|
|
}
|
|
|
|
|
|
string remainder = sr.ReadLine();
|
|
sbLine.Append(' ');
|
|
sbLine.Append(remainder);
|
|
line = sbLine.ToString();
|
|
|
|
if (string.IsNullOrWhiteSpace(line) || Header.ParseLineFromFile(line))
|
|
continue;
|
|
Header.Comments.Add(line);
|
|
}
|
|
}
|
|
|
|
hawkFile.GetStream().Position = origStreamPosn;
|
|
|
|
return true;
|
|
}
|
|
|
|
public bool Load()
|
|
{
|
|
var file = new FileInfo(Filename);
|
|
|
|
if (file.Exists == false)
|
|
{
|
|
Loaded = false;
|
|
return false;
|
|
}
|
|
|
|
Header.Clear();
|
|
_log.Clear();
|
|
|
|
using (var sr = file.OpenText())
|
|
{
|
|
string line;
|
|
|
|
while ((line = sr.ReadLine()) != null)
|
|
{
|
|
if (line == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (line.Contains("LoopOffset"))
|
|
{
|
|
try
|
|
{
|
|
_loopOffset = int.Parse(line.Split(new[] { ' ' }, 2)[1]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if (Header.ParseLineFromFile(line))
|
|
{
|
|
continue;
|
|
}
|
|
else if (line.StartsWith("|"))
|
|
{
|
|
_log.AppendFrame(line);
|
|
}
|
|
else
|
|
{
|
|
Header.Comments.Add(line);
|
|
}
|
|
}
|
|
}
|
|
|
|
Loaded = true;
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Log Editing
|
|
|
|
public string GetInput(int frame)
|
|
{
|
|
if (frame < FrameCount)
|
|
{
|
|
if (frame >= 0)
|
|
{
|
|
int getframe;
|
|
|
|
if (_loopOffset.HasValue)
|
|
{
|
|
if (frame < _log.Length)
|
|
{
|
|
getframe = frame;
|
|
}
|
|
else
|
|
{
|
|
getframe = ((frame - _loopOffset.Value) % (_log.Length - _loopOffset.Value)) + _loopOffset.Value;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
getframe = frame;
|
|
}
|
|
|
|
return _log[getframe];
|
|
}
|
|
|
|
return string.Empty;
|
|
}
|
|
|
|
Finish();
|
|
return string.Empty;
|
|
}
|
|
|
|
public void ClearFrame(int frame)
|
|
{
|
|
_log.SetFrameAt(frame, new MnemonicsGenerator().EmptyMnemonic);
|
|
_changes = true;
|
|
}
|
|
|
|
public void AppendFrame(IController source)
|
|
{
|
|
var mg = new MnemonicsGenerator();
|
|
mg.SetSource(source);
|
|
_log.AppendFrame(mg.GetControllersAsMnemonic());
|
|
_changes = true;
|
|
}
|
|
|
|
public void Truncate(int frame)
|
|
{
|
|
_log.TruncateMovie(frame);
|
|
_log.TruncateStates(frame);
|
|
_changes = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Public Misc Methods
|
|
|
|
public void PokeFrame(int frame, IController source)
|
|
{
|
|
var mg = new MnemonicsGenerator();
|
|
mg.SetSource(source);
|
|
|
|
_changes = true;
|
|
_log.SetFrameAt(frame, mg.GetControllersAsMnemonic());
|
|
}
|
|
|
|
public void RecordFrame(int frame, IController source)
|
|
{
|
|
// Note: Truncation here instead of loadstate will make VBA style loadstates
|
|
// (Where an entire movie is loaded then truncated on the next frame
|
|
// this allows users to restore a movie with any savestate from that "timeline"
|
|
if (Global.Config.VBAStyleMovieLoadState)
|
|
{
|
|
if (Global.Emulator.Frame < _log.Length)
|
|
{
|
|
_log.TruncateMovie(Global.Emulator.Frame);
|
|
}
|
|
}
|
|
|
|
var mg = new MnemonicsGenerator();
|
|
mg.SetSource(source);
|
|
|
|
_changes = true;
|
|
_log.SetFrameAt(frame, mg.GetControllersAsMnemonic());
|
|
}
|
|
|
|
public string GetInputLog()
|
|
{
|
|
var sb = new StringBuilder();
|
|
|
|
sb.AppendLine("[Input]");
|
|
|
|
foreach (var record in _log)
|
|
{
|
|
sb.AppendLine(record);
|
|
}
|
|
|
|
sb.AppendLine("[/Input]");
|
|
|
|
return sb.ToString();
|
|
}
|
|
|
|
public bool ExtractInputLog(TextReader reader, out string errorMessage)
|
|
{
|
|
errorMessage = string.Empty;
|
|
int? stateFrame = null;
|
|
|
|
// We are in record mode so replace the movie log with the one from the savestate
|
|
if (!Global.MovieSession.MultiTrack.IsActive)
|
|
{
|
|
if (Global.Config.EnableBackupMovies && MakeBackup && _log.Length > 0)
|
|
{
|
|
SaveBackup();
|
|
MakeBackup = false;
|
|
}
|
|
|
|
_log.Clear();
|
|
while (true)
|
|
{
|
|
var line = reader.ReadLine();
|
|
if (line == null)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (line.Trim() == string.Empty || line == "[Input]")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (line == "[/Input]")
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (line.Contains("Frame 0x")) // NES stores frame count in hex, yay
|
|
{
|
|
var strs = line.Split('x');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1], NumberStyles.HexNumber);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line.Contains("Frame "))
|
|
{
|
|
var strs = line.Split(' ');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1]);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line[0] == '|')
|
|
{
|
|
_log.AppendFrame(line);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var i = 0;
|
|
while (true)
|
|
{
|
|
var line = reader.ReadLine();
|
|
if (line == null)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (line.Trim() == string.Empty || line == "[Input]")
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (line == "[/Input]")
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (line.Contains("Frame 0x")) // NES stores frame count in hex, yay
|
|
{
|
|
var strs = line.Split('x');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1], NumberStyles.HexNumber);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line.Contains("Frame "))
|
|
{
|
|
var strs = line.Split(' ');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1]);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line.StartsWith("|"))
|
|
{
|
|
_log.SetFrameAt(i, line);
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!stateFrame.HasValue)
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
}
|
|
|
|
var stateFramei = stateFrame ?? 0;
|
|
|
|
if (stateFramei > 0 && stateFramei < _log.Length)
|
|
{
|
|
if (!Global.Config.VBAStyleMovieLoadState)
|
|
{
|
|
_log.TruncateStates(stateFramei);
|
|
_log.TruncateMovie(stateFramei);
|
|
}
|
|
}
|
|
else if (stateFramei > _log.Length) // Post movie savestate
|
|
{
|
|
if (!Global.Config.VBAStyleMovieLoadState)
|
|
{
|
|
_log.TruncateStates(_log.Length);
|
|
_log.TruncateMovie(_log.Length);
|
|
}
|
|
|
|
_mode = Moviemode.Finished;
|
|
}
|
|
|
|
if (IsCountingRerecords)
|
|
{
|
|
Header.Rerecords++;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public TimeSpan Time
|
|
{
|
|
get
|
|
{
|
|
var dblseconds = GetSeconds(Loaded ? _log.Length : _preloadFramecount);
|
|
var seconds = (int)(dblseconds % 60);
|
|
var days = seconds / 86400;
|
|
var hours = seconds / 3600;
|
|
var minutes = (seconds / 60) % 60;
|
|
var milliseconds = (int)((dblseconds - seconds) * 1000);
|
|
return new TimeSpan(days, hours, minutes, seconds, milliseconds);
|
|
}
|
|
}
|
|
|
|
public bool CheckTimeLines(TextReader reader, out string errorMessage)
|
|
{
|
|
// This function will compare the movie data to the savestate movie data to see if they match
|
|
errorMessage = string.Empty;
|
|
var log = new MovieLog();
|
|
var stateFrame = 0;
|
|
while (true)
|
|
{
|
|
var line = reader.ReadLine();
|
|
if (line == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (line.Trim() == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (line.Contains("Frame 0x")) // NES stores frame count in hex, yay
|
|
{
|
|
var strs = line.Split('x');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1], NumberStyles.HexNumber);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line.Contains("Frame "))
|
|
{
|
|
var strs = line.Split(' ');
|
|
try
|
|
{
|
|
stateFrame = int.Parse(strs[1]);
|
|
}
|
|
catch
|
|
{
|
|
errorMessage = "Savestate Frame number failed to parse";
|
|
return false;
|
|
}
|
|
}
|
|
else if (line == "[Input]")
|
|
{
|
|
continue;
|
|
}
|
|
else if (line == "[/Input]")
|
|
{
|
|
break;
|
|
}
|
|
else if (line[0] == '|')
|
|
{
|
|
log.AppendFrame(line);
|
|
}
|
|
}
|
|
|
|
if (stateFrame == 0)
|
|
{
|
|
stateFrame = log.Length; // In case the frame count failed to parse, revert to using the entire state input log
|
|
}
|
|
|
|
if (_log.Length < stateFrame)
|
|
{
|
|
if (IsFinished)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
errorMessage = "The savestate is from frame "
|
|
+ log.Length
|
|
+ " which is greater than the current movie length of "
|
|
+ _log.Length;
|
|
|
|
return false;
|
|
}
|
|
|
|
for (var i = 0; i < stateFrame; i++)
|
|
{
|
|
if (_log[i] != log[i])
|
|
{
|
|
errorMessage = "The savestate input does not match the movie input at frame "
|
|
+ (i + 1)
|
|
+ ".";
|
|
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (stateFrame > log.Length) // stateFrame is greater than state input log, so movie finished mode
|
|
{
|
|
if (_mode == Moviemode.Play || _mode == Moviemode.Finished)
|
|
{
|
|
_mode = Moviemode.Finished;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
if (_mode == Moviemode.Finished)
|
|
{
|
|
_mode = Moviemode.Play;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Helpers
|
|
|
|
private void Write(string fn)
|
|
{
|
|
using (var fs = new FileStream(fn, FileMode.Create, FileAccess.Write, FileShare.Read))
|
|
{
|
|
using (var sw = new StreamWriter(fs))
|
|
{
|
|
sw.Write(Header.ToString());
|
|
|
|
// TODO: clean this up
|
|
if (_loopOffset.HasValue)
|
|
{
|
|
sw.WriteLine("LoopOffset " + _loopOffset);
|
|
}
|
|
|
|
foreach (var input in _log)
|
|
{
|
|
sw.WriteLine(input);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private double GetSeconds(int frameCount)
|
|
{
|
|
double frames = frameCount;
|
|
|
|
if (frames < 1)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
var system = Header[HeaderKeys.PLATFORM];
|
|
var pal = Header.ContainsKey(HeaderKeys.PAL) &&
|
|
Header[HeaderKeys.PAL] == "1";
|
|
|
|
return frames / _frameRates[system, pal];
|
|
}
|
|
|
|
public double Fps
|
|
{
|
|
get
|
|
{
|
|
var system = Header[HeaderKeys.PLATFORM];
|
|
var pal = Header.ContainsKey(HeaderKeys.PAL) &&
|
|
Header[HeaderKeys.PAL] == "1";
|
|
|
|
return _frameRates[system, pal];
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |