empathicqubit/lsnes
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'origin/rr1-maint' into rr1-maint

Browse source
This commit is contained in:
Ilari Liusvaara 2013-09-24 13:25:32 +03:00
commit 8301de15b2
15 changed files with 103 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
include/core/moviefile.hpp
View file

@ -7,9 +7,9 @@
#include <map>
#include "core/controllerframe.hpp"
#include "core/rom.hpp"
#include "core/romtype.hpp"
#include "core/subtitles.hpp"
/**
* This structure gives parsed representationg of movie file, as result of decoding or for encoding.
*/
@ -76,11 +76,15 @@ struct moviefile
/**
* SHA-256 of ROM (empty string if none).
*/
std::string romimg_sha256[27];
std::string romimg_sha256[ROM_SLOT_COUNT];
/**
* SHA-256 of ROM XML (empty string if none).
*/
std::string romxml_sha256[27];
std::string romxml_sha256[ROM_SLOT_COUNT];
/**
* ROM hints (empty string if none).
*/
std::string romname_hint[ROM_SLOT_COUNT];
/**
* Authors of the run, first in each pair is full name, second is nickname.
*/

16
include/core/rom.hpp
View file

@ -1,11 +1,14 @@
#ifndef _rom__hpp__included__
#define _rom__hpp__included__
#define ROM_SLOT_COUNT 27
#include <string>
#include <map>
#include <vector>
#include <stdexcept>
#include "core/misc.hpp"
#include "core/moviefile.hpp"
#include "core/romtype.hpp"
/**
@ -60,6 +63,10 @@ struct loaded_slot
* SHA-256 for the data in this slot if data is valid. If no valid data, this field is "".
*/
std::string sha256;
/**
* Name hint. Only for non-XML slots.
*/
std::string namehint;
/**
* Get pointer to loaded data
*
@ -121,11 +128,11 @@ struct loaded_rom
/**
* Loaded main ROM
*/
loaded_slot romimg[27];
loaded_slot romimg[ROM_SLOT_COUNT];
/**
* Loaded main ROM XML
*/
loaded_slot romxml[27];
loaded_slot romxml[ROM_SLOT_COUNT];
/**
* MSU-1 base.
*/
@ -194,4 +201,9 @@ std::vector<char> save_core_state(bool nochecksum = false) throw(std::bad_alloc)
*/
void load_core_state(const std::vector<char>& buf, bool nochecksum = false) throw(std::runtime_error);
/**
* Does specified file exist?
*/
bool file_exists(const std::string& name);
#endif

2
include/core/window.hpp
View file

@ -225,7 +225,7 @@ struct graphics_plugin
/**
* Request filename for ROM load.
*/
static std::string request_rom(core_type& coretype);
static std::string request_rom(core_type& coretype, const std::string& hint);
/**
* Identification for graphics plugin.
*/

2
include/platform/wxwidgets/window_mainwindow.hpp
View file

@ -41,7 +41,7 @@ public:
void menu_check(int id, bool newstate);
void menu_separator();
void handle_menu_click(wxCommandEvent& e);
void request_rom(std::string& filename, core_type& coretype);
void request_rom(std::string& filename, core_type& coretype, const std::string& hint);
recent_menu* recent_roms;
recent_menu* recent_movies;
private:

3
src/core/mainloop.cpp
View file

@ -278,9 +278,10 @@ namespace
messages << "Loading ROM " << filenam << std::endl;
loaded_rom newrom(filenam);
*our_rom = newrom;
for(size_t i = 0; i < sizeof(our_rom->romimg)/sizeof(our_rom->romimg[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
our_movie.romimg_sha256[i] = our_rom->romimg[i].sha256;
our_movie.romxml_sha256[i] = our_rom->romxml[i].sha256;
our_movie.romname_hint[i] = our_rom->romxml[i].namehint;
}
} catch(std::exception& e) {
messages << "Can't reload ROM: " << e.what() << std::endl;

27
src/core/moviedata.cpp
View file

@ -183,6 +183,15 @@ namespace
return false;
}
}
std::string getline(const std::vector<char>& v)
{
std::string t(v.begin(), v.end());
size_t ptr = t.find_first_of("\r\n");
if(ptr < t.size())
t = t.substr(0, ptr);
return t;
}
}
std::string translate_name_mprefix(std::string original, bool forio)
@ -377,18 +386,20 @@ void do_load_beginning(bool reload) throw(std::bad_alloc, std::runtime_error)
void try_request_rom(const std::string& moviefile)
{
auto sysreg_content = read_file_relative(moviefile + "/gametype", "");
std::string sysreg_name(sysreg_content.begin(), sysreg_content.end());
size_t ptr = sysreg_name.find_first_of("\r\n");
if(ptr < sysreg_name.size())
sysreg_name = sysreg_name.substr(0, ptr);
std::string sysreg_name = getline(read_file_relative(moviefile + "/gametype", ""));
core_sysregion* sysreg;
try {
sysreg = &core_sysregion::lookup(sysreg_name);
} catch(...) {
throw std::runtime_error("The movie is for unsupported system type");
}
std::string rname = graphics_plugin::request_rom(sysreg->get_type());
std::string hintfile = (sysreg->get_type().get_biosname() != "") ? "slota.hint" : "rom.hint";
std::string hint;
try {
hint = getline(read_file_relative(moviefile + "/" + hintfile, ""));
} catch(...) {
}
std::string rname = graphics_plugin::request_rom(sysreg->get_type(), hint);
if(rname == "")
throw std::runtime_error("Canceled loading ROM");
loaded_rom newrom(rname);
@ -421,7 +432,9 @@ void do_load_state(struct moviefile& _movie, int lmode)
<< "\tFile is from: " << _movie.coreversion << std::endl;
}
bool rom_ok = true;
for(size_t i = 0; i < sizeof(our_rom->romimg)/sizeof(our_rom->romimg[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
if(_movie.romname_hint[i] == "")
_movie.romname_hint[i] = our_rom->romimg[i].namehint;
rom_ok = rom_ok & warn_hash_mismatch(_movie.romimg_sha256[i], our_rom->romimg[i],
(stringfmt() << "ROM #" << (i + 1)).str(), will_load_state);
rom_ok = rom_ok & warn_hash_mismatch(_movie.romxml_sha256[i], our_rom->romxml[i],

22
src/core/moviefile.cpp
View file

@ -387,14 +387,17 @@ moviefile::moviefile(const std::string& movie) throw(std::bad_alloc, std::runtim
read_linefile(r, "coreversion", coreversion);
read_linefile(r, "rom.sha256", romimg_sha256[0], true);
read_linefile(r, "romxml.sha256", romxml_sha256[0], true);
read_linefile(r, "rom.hint", romname_hint[0], true);
unsigned base = 97;
if(r.has_member("slot`.sha256"))
base = 96;
for(size_t i = 0; i < 26; i++) {
read_linefile(r, (stringfmt() << "slot" << (char)(base + i) << ".sha256").str(), romimg_sha256[i + 1],
for(size_t i = 1; i < ROM_SLOT_COUNT; i++) {
read_linefile(r, (stringfmt() << "slot" << (char)(base + i - 1) << ".sha256").str(), romimg_sha256[i],
true);
read_linefile(r, (stringfmt() << "slot" << (char)(base + i) << "xml.sha256").str(),
romxml_sha256[i + 1], true);
read_linefile(r, (stringfmt() << "slot" << (char)(base + i - 1) << "xml.sha256").str(),
romxml_sha256[i], true);
read_linefile(r, (stringfmt() << "slot" << (char)(base + i - 1) << ".hint").str(),
romname_hint[i], true);
}
read_linefile(r, "prefix", prefix, true);
read_subtitles(r, "subtitles", subtitles);
@ -458,11 +461,14 @@ void moviefile::save(const std::string& movie, unsigned compression) throw(std::
write_rrdata(w);
write_linefile(w, "rom.sha256", romimg_sha256[0], true);
write_linefile(w, "romxml.sha256", romxml_sha256[0], true);
for(size_t i = 0; i < 26; i++) {
write_linefile(w, (stringfmt() << "slot" << (char)(97 + i) << ".sha256").str(), romimg_sha256[i + 1],
write_linefile(w, "rom.hint", romname_hint[0], true);
for(size_t i = 1; i < ROM_SLOT_COUNT; i++) {
write_linefile(w, (stringfmt() << "slot" << (char)(96 + i) << ".sha256").str(), romimg_sha256[i],
true);
write_linefile(w, (stringfmt() << "slot" << (char)(97 + i) << "xml.sha256").str(),
romxml_sha256[i + 1], true);
write_linefile(w, (stringfmt() << "slot" << (char)(96 + i) << "xml.sha256").str(),
romxml_sha256[i], true);
write_linefile(w, (stringfmt() << "slot" << (char)(96 + i) << ".hint").str(),
romname_hint[i], true);
}
write_subtitles(w, "subtitles", subtitles);
write_linefile(w, "prefix", prefix, true);

31
src/core/rom.cpp
View file

@ -29,20 +29,20 @@
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/device/back_inserter.hpp>
bool file_exists(const std::string& name)
{
try {
delete &open_file_relative(name, "");
return true;
} catch(...) {
return false;
}
}
namespace
{
core_type* current_rom_type = NULL;
core_region* current_region = NULL;
bool file_exists(const std::string& name)
{
try {
delete &open_file_relative(name, "");
return true;
} catch(...) {
return false;
}
}
}
loaded_slot::loaded_slot() throw(std::bad_alloc)
@ -63,6 +63,17 @@ loaded_slot::loaded_slot(const std::string& filename, const std::string& base,
return;
}
valid = true;
std::string _filename = filename;
#if defined(_WIN32) || defined(_WIN64)
const char* split = "/\\";
#else
const char* split = "/";
#endif
size_t s1 = _filename.find_last_of(split);
size_t s2 = _filename.find_last_of(".");
if(s1 < _filename.length()) s1 = s1 + 1; else s1 = 0;
if(s2 <= s1 || s2 >= _filename.length()) s2 = _filename.length();
namehint = _filename.substr(s1, s2 - s1);
data = read_file_relative(filename, base);
if(!xml)
headered = imginfo.headersize(data.size());

2
src/dummy/graphics.cpp
View file

@ -49,7 +49,7 @@ void graphics_plugin::fatal_error() throw()
std::cerr << "Exiting on fatal error." << std::endl;
}
std::string graphics_plugin::request_rom(core_type& coretype)
std::string graphics_plugin::request_rom(core_type& coretype, const std::string& hint)
{
throw std::runtime_error("Headless does not support ROM preloading");
}

2
src/platform/sdl/graphicsfn.cpp
View file

@ -613,7 +613,7 @@ void graphics_plugin::fatal_error() throw()
}
}
std::string graphics_plugin::request_rom(core_type& coretype)
std::string graphics_plugin::request_rom(core_type& coretype, const std::string& hint)
{
throw std::runtime_error("SDL version does not support ROM preloading");
}

3
src/platform/sdl/main.cpp
View file

@ -36,9 +36,10 @@ struct moviefile generate_movie_template(std::vector<std::string> cmdline, loade
movie.coreversion = bsnes_core_version;
movie.projectid = get_random_hexstring(40);
movie.gametype = &r.rtype->combine_region(*r.region);
for(size_t i = 0; i < sizeof(r.romimg)/sizeof(r.romimg[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
movie.romimg_sha256[i] = r.romimg[i].sha256;
movie.romxml_sha256[i] = r.romxml[i].sha256;
movie.romname_hint[i] = r.romimg[i].namehint;
}
movie.movie_sram = load_sram_commandline(cmdline);
for(auto i = cmdline.begin(); i != cmdline.end(); i++) {

10
src/platform/wxwidgets/main.cpp
View file

@ -458,9 +458,10 @@ bool lsnes_app::OnInit()
//Initialize the remainder.
mov->coreversion = bsnes_core_version;
mov->rerecords = "0";
for(size_t i = 0; i < sizeof(rom->romimg)/sizeof(rom->romimg[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
mov->romimg_sha256[i] = rom->romimg[i].sha256;
mov->romxml_sha256[i] = rom->romxml[i].sha256;
mov->romname_hint[i] = rom->romimg[i].namehint;
}
mov->gametype = &rom->rtype->combine_region(*rom->region);
}
@ -533,19 +534,20 @@ void graphics_plugin::fatal_error() throw()
}
}
std::string graphics_plugin::request_rom(core_type& coretype)
std::string graphics_plugin::request_rom(core_type& coretype, const std::string& hint)
{
core_type* ctype = &coretype;
std::string outname;
std::string _hint = hint;
mutex_class lock;
cv_class cv;
bool done = false;
umutex_class h(lock);
runuifun([ctype, &outname, &lock, &cv, &done]() -> void {
runuifun([ctype, hint, &outname, &lock, &cv, &done]() -> void {
if(done)
return;
try {
main_window->request_rom(outname, *ctype);
main_window->request_rom(outname, *ctype, hint);
} catch(...) {
}
umutex_class h(lock);

8
src/platform/wxwidgets/mainwindow.cpp
View file

@ -1000,12 +1000,16 @@ void wxwin_mainwindow::notify_exit() throw()
Destroy();
}
void wxwin_mainwindow::request_rom(std::string& filename, core_type& coretype)
void wxwin_mainwindow::request_rom(std::string& filename, core_type& coretype, const std::string& hint)
{
const std::list<std::string>& exts = coretype.get_extensions();
std::string filter = coretype.get_hname() + " ROMs|";
bool first = true;
std::string defaultname = "";
for(auto i : exts) {
std::string hinted_file = hint + "." + i;
if(file_exists(rom_path() + "/" + hinted_file))
defaultname = hinted_file;
if(!first)
filter = filter + ";";
first = false;
@ -1014,6 +1018,8 @@ void wxwin_mainwindow::request_rom(std::string& filename, core_type& coretype)
filter = filter + "|All files|*.*";
wxFileDialog* fdiag = new wxFileDialog(this, wxT("Load ROM"), towxstring(rom_path()), wxT(""),
towxstring(filter), wxFD_OPEN);
if(defaultname != "")
fdiag->SetFilename(towxstring(defaultname));
if(fdiag->ShowModal() != wxID_OK) {
delete fdiag;
return;

3
src/platform/wxwidgets/romselect.cpp
View file

@ -374,9 +374,10 @@ struct moviefile wxwin_project::make_movie()
f.prefix = sanitize_prefix(tostdstring(prefix->GetValue()));
f.projectid = get_random_hexstring(40);
f.rerecords = "0";
for(size_t i = 0; i < sizeof(our_rom->romimg)/sizeof(our_rom->romimg[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
f.romimg_sha256[i] = our_rom->romimg[i].sha256;
f.romxml_sha256[i] = our_rom->romxml[i].sha256;
f.romname_hint[i] = our_rom->romimg[i].namehint;
}
size_t lines = authors->GetNumberOfLines();
for(size_t i = 0; i < lines; i++) {

5
src/util/movieinfo.cpp
View file

@ -56,8 +56,11 @@ int main(int argc, char** argv)
else
std::cout << "No game name available" << std::endl;
std::cout << "Project ID: " << escape_string(m.projectid) << std::endl;
for(size_t i = 0; i < sizeof(m.romimg_sha256)/sizeof(m.romimg_sha256[0]); i++) {
for(size_t i = 0; i < ROM_SLOT_COUNT; i++) {
if(m.romimg_sha256[i] != "") {
if(m.romname_hint[i] != "")
std::cout << name_subrom(*rtype, 2 * i + 0) << " namehint: "
<< escape_string(m.romname_hint[i]) << std::endl;
std::cout << name_subrom(*rtype, 2 * i + 0) << " checksum: "
<< escape_string(m.romimg_sha256[i]) << std::endl;
if(m.romxml_sha256[i] != "") {