mirror of
https://github.com/holub/mame
synced 2025-04-16 13:34:55 +03:00
floppy: Beginning of the support for preformatted floppy images.
What's missing: - parameters (like the disk name when it exists) - possibly a cleanup of ram_open and friends (but not sure of the appropriate direction in which to go)
This commit is contained in:
Olivier Galibert
parent
f7011c21e1
commit
92326e47af
@ -69,6 +69,11 @@ project "formats"
|
||||
MAME_DIR .. "src/lib/formats/dfi_dsk.cpp",
|
||||
MAME_DIR .. "src/lib/formats/dfi_dsk.h",
|
||||
MAME_DIR .. "src/lib/formats/fdi_dsk.cpp",
|
||||
|
||||
MAME_DIR .. "src/lib/formats/fsmgr.h",
|
||||
MAME_DIR .. "src/lib/formats/fsmgr.cpp",
|
||||
MAME_DIR .. "src/lib/formats/fs_unformatted.h",
|
||||
MAME_DIR .. "src/lib/formats/fs_unformatted.cpp",
|
||||
}
|
||||
|
||||
--------------------------------------------------
|
||||
@ -1598,10 +1603,10 @@ end
|
||||
|
||||
--------------------------------------------------
|
||||
--
|
||||
--@src/lib/formats/rc759_dsk.h,FORMATS["RC759_DSK"] = true
|
||||
--@src/lib/formats/rc759_dsk.h,FORMATS["RC759"] = true
|
||||
--------------------------------------------------
|
||||
|
||||
if opt_tool(FORMATS, "RC759_DSK") then
|
||||
if (FORMATS["APRIDISK"]~=null or _OPTIONS["with-tools"]) then
|
||||
files {
|
||||
MAME_DIR.. "src/lib/formats/rc759_dsk.cpp",
|
||||
MAME_DIR.. "src/lib/formats/rc759_dsk.h",
|
||||
@ -2052,4 +2057,16 @@ if opt_tool(FORMATS, "ZX81_P") then
|
||||
}
|
||||
end
|
||||
|
||||
--------------------------------------------------
|
||||
--
|
||||
--@src/lib/formats/fs_prodos.h,FORMATS["FS_PRODOS"] = true
|
||||
--------------------------------------------------
|
||||
|
||||
if opt_tool(FORMATS, "FS_PRODOS") then
|
||||
files {
|
||||
MAME_DIR.. "src/lib/formats/fs_prodos.cpp",
|
||||
MAME_DIR.. "src/lib/formats/fs_prodos.h",
|
||||
}
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@ -981,6 +981,7 @@ BUSES["X68K"] = true
|
||||
BUSES["Z29_KBD"] = true
|
||||
BUSES["Z88"] = true
|
||||
BUSES["ZORRO"] = true
|
||||
BUSES["THOMSON"] = true
|
||||
|
||||
--------------------------------------------------
|
||||
-- specify used file formats
|
||||
@ -1111,7 +1112,7 @@ FORMATS["PPG_DSK"] = true
|
||||
FORMATS["PRIMOPTP"] = true
|
||||
FORMATS["PYLDIN_DSK"] = true
|
||||
FORMATS["QL_DSK"] = true
|
||||
FORMATS["RC759_DSK"] = true
|
||||
FORMATS["RC759"] = true
|
||||
FORMATS["RK_CAS"] = true
|
||||
FORMATS["RX50_DSK"] = true
|
||||
FORMATS["SC3000_BIT"] = true
|
||||
@ -1150,6 +1151,7 @@ FORMATS["X07_CAS"] = true
|
||||
FORMATS["X1_TAP"] = true
|
||||
FORMATS["XDF_DSK"] = true
|
||||
FORMATS["ZX81_P"] = true
|
||||
FORMATS["FS_PRODOS"] = true
|
||||
|
||||
--------------------------------------------------
|
||||
-- this is the list of driver libraries that
|
||||
@ -3928,8 +3930,6 @@ files {
|
||||
MAME_DIR .. "src/mame/drivers/thomson.cpp",
|
||||
MAME_DIR .. "src/mame/includes/thomson.h",
|
||||
MAME_DIR .. "src/mame/machine/thomson.cpp",
|
||||
MAME_DIR .. "src/mame/machine/thomflop.cpp",
|
||||
MAME_DIR .. "src/mame/machine/thomflop.h",
|
||||
MAME_DIR .. "src/mame/video/thomson.cpp",
|
||||
}
|
||||
|
||||
|
||||
@ -20,6 +20,8 @@
|
||||
#include "formats/dsk_dsk.h"
|
||||
#include "formats/pc_dsk.h"
|
||||
|
||||
#include "formats/fs_unformatted.h"
|
||||
|
||||
#include "speaker.h"
|
||||
#include "formats/imageutl.h"
|
||||
#include "zippath.h"
|
||||
@ -139,6 +141,8 @@ format_registration::format_registration()
|
||||
{
|
||||
add(FLOPPY_MFI_FORMAT); // Our generic format
|
||||
add(FLOPPY_DFI_FORMAT); // Flux format, dying
|
||||
|
||||
add(FS_UNFORMATTED);
|
||||
}
|
||||
|
||||
void format_registration::add_fm_containers()
|
||||
@ -170,6 +174,11 @@ void format_registration::add(floppy_format_type format)
|
||||
m_formats.push_back(format);
|
||||
}
|
||||
|
||||
void format_registration::add(filesystem_manager_type fs)
|
||||
{
|
||||
m_fs.push_back(fs);
|
||||
}
|
||||
|
||||
void floppy_image_device::default_fm_floppy_formats(format_registration &fr)
|
||||
{
|
||||
fr.add_fm_containers();
|
||||
@ -299,11 +308,21 @@ void floppy_image_device::setup_led_cb(led_cb cb)
|
||||
cur_led_cb = cb;
|
||||
}
|
||||
|
||||
void floppy_image_device::set_formats(std::function<void (format_registration &fr)> formats)
|
||||
void floppy_image_device::fs_enum::add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description)
|
||||
{
|
||||
m_fid->m_fs.emplace_back(fs_info(manager, type, image_size, name, key, description));
|
||||
}
|
||||
|
||||
void floppy_image_device::fs_enum::add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description)
|
||||
{
|
||||
m_fid->m_fs.emplace_back(fs_info(manager, name, key, description));
|
||||
}
|
||||
|
||||
void floppy_image_device::register_formats()
|
||||
{
|
||||
format_registration fr;
|
||||
if(formats)
|
||||
formats(fr);
|
||||
if(format_registration_cb)
|
||||
format_registration_cb(fr);
|
||||
|
||||
extension_list[0] = '\0';
|
||||
fif_list = nullptr;
|
||||
@ -320,6 +339,19 @@ void floppy_image_device::set_formats(std::function<void (format_registration &f
|
||||
|
||||
image_specify_extension( extension_list, 256, fif->extensions() );
|
||||
}
|
||||
|
||||
fs_enum fse(this);
|
||||
for(filesystem_manager_type fmt : fr.m_fs)
|
||||
{
|
||||
auto ff = fmt();
|
||||
ff->enumerate(fse, form_factor, variants);
|
||||
m_fs_managers.push_back(std::unique_ptr<filesystem_manager_t>(ff));
|
||||
}
|
||||
}
|
||||
|
||||
void floppy_image_device::set_formats(std::function<void (format_registration &fr)> formats)
|
||||
{
|
||||
format_registration_cb = formats;
|
||||
}
|
||||
|
||||
floppy_image_format_t *floppy_image_device::get_formats() const
|
||||
@ -400,6 +432,7 @@ void floppy_image_device::device_start()
|
||||
phases = 0;
|
||||
|
||||
setup_characteristics();
|
||||
register_formats();
|
||||
|
||||
if (m_make_sound) m_sound_out = subdevice<floppy_sound_device>(FLOPSND_TAG);
|
||||
|
||||
@ -611,6 +644,87 @@ image_init_result floppy_image_device::call_create(int format_type, util::option
|
||||
return image_init_result::PASS;
|
||||
}
|
||||
|
||||
// Should that go into ioprocs? Should ioprocs be turned into something C++?
|
||||
|
||||
struct iofile_ram {
|
||||
std::vector<u8> *data;
|
||||
int64_t pos;
|
||||
};
|
||||
|
||||
static void ram_closeproc(void *file)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
delete f;
|
||||
}
|
||||
|
||||
static int ram_seekproc(void *file, int64_t offset, int whence)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
switch(whence) {
|
||||
case SEEK_SET: f->pos = offset; break;
|
||||
case SEEK_CUR: f->pos += offset; break;
|
||||
case SEEK_END: f->pos = f->data->size() + offset; break;
|
||||
}
|
||||
|
||||
f->pos = std::clamp(f->pos, int64_t(0), int64_t(f->data->size()));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static size_t ram_readproc(void *file, void *buffer, size_t length)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
size_t l = std::min(length, f->data->size() - f->pos);
|
||||
memcpy(buffer, f->data->data() + f->pos, l);
|
||||
return l;
|
||||
}
|
||||
|
||||
static size_t ram_writeproc(void *file, const void *buffer, size_t length)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
size_t l = std::min(length, f->data->size() - f->pos);
|
||||
memcpy(f->data->data() + f->pos, buffer, l);
|
||||
return l;
|
||||
}
|
||||
|
||||
static uint64_t ram_filesizeproc(void *file)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
return f->data->size();
|
||||
}
|
||||
|
||||
|
||||
static const io_procs iop_ram = {
|
||||
ram_closeproc,
|
||||
ram_seekproc,
|
||||
ram_readproc,
|
||||
ram_writeproc,
|
||||
ram_filesizeproc
|
||||
};
|
||||
|
||||
static io_generic *ram_open(std::vector<u8> &data)
|
||||
{
|
||||
iofile_ram *f = new iofile_ram;
|
||||
f->data = &data;
|
||||
f->pos = 0;
|
||||
return new io_generic({ &iop_ram, f });
|
||||
}
|
||||
|
||||
void floppy_image_device::init_fs(const fs_info *fs)
|
||||
{
|
||||
if (fs->m_type)
|
||||
{
|
||||
std::vector<u8> img(fs->m_image_size);
|
||||
fs->m_manager->floppy_instantiate(fs->m_key, img);
|
||||
auto iog = ram_open(img);
|
||||
auto source_format = fs->m_type();
|
||||
source_format->load(iog, floppy_image::FF_UNKNOWN, variants, image.get());
|
||||
delete source_format;
|
||||
delete iog;
|
||||
|
||||
} else
|
||||
fs->m_manager->floppy_instantiate_raw(fs->m_key, image.get());
|
||||
}
|
||||
|
||||
/* write protect, active high
|
||||
phase 1 can force it to 1 for drive detection
|
||||
on the rare drives that actually use phases.
|
||||
@ -2293,7 +2407,7 @@ void teac_fd_30a::setup_characteristics()
|
||||
sides = 1;
|
||||
set_rpm(300);
|
||||
|
||||
variants.push_back(floppy_image::SSSD);
|
||||
variants.push_back(floppy_image::SSDD);
|
||||
}
|
||||
|
||||
//-------------------------------------------------
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "formats/flopimg.h"
|
||||
#include "formats/fsmgr.h"
|
||||
#include "sound/samples.h"
|
||||
#include "softlist_dev.h"
|
||||
|
||||
@ -26,12 +27,14 @@ public:
|
||||
format_registration();
|
||||
|
||||
void add(floppy_format_type format);
|
||||
void add(filesystem_manager_type fs);
|
||||
|
||||
void add_fm_containers();
|
||||
void add_mfm_containers();
|
||||
void add_pc_formats();
|
||||
|
||||
std::vector<floppy_format_type> m_formats;
|
||||
std::vector<filesystem_manager_type> m_fs;
|
||||
};
|
||||
|
||||
class floppy_image_device : public device_t,
|
||||
@ -45,15 +48,45 @@ public:
|
||||
typedef delegate<void (floppy_image_device *, int)> wpt_cb;
|
||||
typedef delegate<void (floppy_image_device *, int)> led_cb;
|
||||
|
||||
struct fs_info {
|
||||
const filesystem_manager_t *m_manager;
|
||||
floppy_format_type m_type;
|
||||
u32 m_image_size;
|
||||
const char *m_name;
|
||||
u32 m_key;
|
||||
const char *m_description;
|
||||
|
||||
fs_info(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) :
|
||||
m_manager(manager),
|
||||
m_type(type),
|
||||
m_image_size(image_size),
|
||||
m_name(name),
|
||||
m_key(key),
|
||||
m_description(description)
|
||||
{}
|
||||
|
||||
fs_info(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) :
|
||||
m_manager(manager),
|
||||
m_type(nullptr),
|
||||
m_image_size(0),
|
||||
m_name(name),
|
||||
m_key(key),
|
||||
m_description(description)
|
||||
{}
|
||||
};
|
||||
|
||||
// construction/destruction
|
||||
virtual ~floppy_image_device();
|
||||
|
||||
void set_formats(std::function<void (format_registration &fr)> formats);
|
||||
floppy_image_format_t *get_formats() const;
|
||||
const std::vector<fs_info> &get_fs() const { return m_fs; }
|
||||
floppy_image_format_t *get_load_format() const;
|
||||
floppy_image_format_t *identify(std::string filename);
|
||||
void set_rpm(float rpm);
|
||||
|
||||
void init_fs(const fs_info *fs);
|
||||
|
||||
// image-level overrides
|
||||
virtual image_init_result call_load() override;
|
||||
virtual void call_unload() override;
|
||||
@ -120,6 +153,14 @@ public:
|
||||
void enable_sound(bool doit) { m_make_sound = doit; }
|
||||
|
||||
protected:
|
||||
struct fs_enum : public filesystem_manager_t::floppy_enumerator {
|
||||
floppy_image_device *m_fid;
|
||||
fs_enum(floppy_image_device *fid) : filesystem_manager_t::floppy_enumerator(), m_fid(fid) {};
|
||||
|
||||
virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) override;
|
||||
virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) override;
|
||||
};
|
||||
|
||||
floppy_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
|
||||
|
||||
// device-level overrides
|
||||
@ -137,12 +178,15 @@ protected:
|
||||
|
||||
void init_floppy_load(bool write_supported);
|
||||
|
||||
std::function<void (format_registration &fr)> format_registration_cb;
|
||||
floppy_image_format_t *input_format;
|
||||
floppy_image_format_t *output_format;
|
||||
std::vector<uint32_t> variants;
|
||||
std::unique_ptr<floppy_image> image;
|
||||
char extension_list[256];
|
||||
floppy_image_format_t *fif_list;
|
||||
std::vector<fs_info> m_fs;
|
||||
std::vector<std::unique_ptr<filesystem_manager_t>> m_fs_managers;
|
||||
emu_timer *index_timer;
|
||||
|
||||
/* Physical characteristics, filled by setup_characteristics */
|
||||
@ -197,6 +241,8 @@ protected:
|
||||
wpt_cb cur_wpt_cb;
|
||||
led_cb cur_led_cb;
|
||||
|
||||
void register_formats();
|
||||
|
||||
void check_led();
|
||||
uint32_t find_position(attotime &base, const attotime &when);
|
||||
int find_index(uint32_t position, const std::vector<uint32_t> &buf) const;
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
#include "formats/ap2_dsk.h"
|
||||
#include "formats/ap_dsk35.h"
|
||||
#include "formats/pc_dsk.h"
|
||||
#include "formats/fs_prodos.h"
|
||||
|
||||
void applefdintf_device::formats_525_13(format_registration &fr)
|
||||
{
|
||||
@ -30,6 +31,8 @@ void applefdintf_device::formats_35(format_registration &fr)
|
||||
fr.add(FLOPPY_WOZ_FORMAT);
|
||||
fr.add(FLOPPY_APPLE_GCR_FORMAT);
|
||||
fr.add(FLOPPY_APPLE_2MG_FORMAT);
|
||||
|
||||
fr.add(FS_PRODOS);
|
||||
}
|
||||
|
||||
void applefdintf_device::floppies_525(device_slot_interface &device)
|
||||
|
||||
@ -291,4 +291,59 @@ void menu_select_format::handle()
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
SELECT FORMAT MENU
|
||||
***************************************************************************/
|
||||
|
||||
//-------------------------------------------------
|
||||
// ctor
|
||||
//-------------------------------------------------
|
||||
|
||||
menu_select_floppy_init::menu_select_floppy_init(mame_ui_manager &mui, render_container &container, const std::vector<floppy_image_device::fs_info> &fs, int *result)
|
||||
: menu(mui, container),
|
||||
m_fs(fs),
|
||||
m_result(result)
|
||||
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// dtor
|
||||
//-------------------------------------------------
|
||||
|
||||
menu_select_floppy_init::~menu_select_floppy_init()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// populate
|
||||
//-------------------------------------------------
|
||||
|
||||
void menu_select_floppy_init::populate(float &customtop, float &custombottom)
|
||||
{
|
||||
item_append(_("Select initial contents"), FLAG_DISABLE, nullptr);
|
||||
int id = 0;
|
||||
for (const auto &fmt : m_fs)
|
||||
item_append(fmt.m_description, fmt.m_name, 0, (void *)(uintptr_t)(id++));
|
||||
}
|
||||
|
||||
|
||||
//-------------------------------------------------
|
||||
// handle
|
||||
//-------------------------------------------------
|
||||
|
||||
void menu_select_floppy_init::handle()
|
||||
{
|
||||
// process the menu
|
||||
const event *event = process(0);
|
||||
if (event != nullptr && event->iptkey == IPT_UI_SELECT)
|
||||
{
|
||||
*m_result = int(uintptr_t(event->itemref));
|
||||
stack_pop();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} // namespace ui
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#pragma once
|
||||
|
||||
#include "ui/menu.h"
|
||||
#include "imagedev/floppy.h"
|
||||
|
||||
class floppy_image_format_t;
|
||||
|
||||
@ -77,6 +78,24 @@ private:
|
||||
int * m_result;
|
||||
};
|
||||
|
||||
// ======================> menu_select_floppy_init
|
||||
|
||||
class menu_select_floppy_init : public menu
|
||||
{
|
||||
public:
|
||||
menu_select_floppy_init(mame_ui_manager &mui, render_container &container,
|
||||
const std::vector<floppy_image_device::fs_info> &fs, int *result);
|
||||
virtual ~menu_select_floppy_init() override;
|
||||
|
||||
private:
|
||||
virtual void populate(float &customtop, float &custombottom) override;
|
||||
virtual void handle() override;
|
||||
|
||||
// internal state
|
||||
const std::vector<floppy_image_device::fs_info> &m_fs;
|
||||
int * m_result;
|
||||
};
|
||||
|
||||
|
||||
} // namespace ui
|
||||
|
||||
|
||||
@ -26,6 +26,7 @@ menu_control_floppy_image::menu_control_floppy_image(mame_ui_manager &mui, rende
|
||||
fd(dynamic_cast<floppy_image_device &>(image)),
|
||||
input_format(nullptr),
|
||||
output_format(nullptr),
|
||||
create_fs(nullptr),
|
||||
input_filename(),
|
||||
output_filename()
|
||||
{
|
||||
@ -48,6 +49,8 @@ void menu_control_floppy_image::do_load_create()
|
||||
machine().popmessage("Error: %s", fd.error());
|
||||
return;
|
||||
}
|
||||
if (create_fs)
|
||||
fd.init_fs(create_fs);
|
||||
} else {
|
||||
image_init_result err = fd.load(input_filename);
|
||||
if ((err == image_init_result::PASS) && (output_filename.compare("") != 0))
|
||||
@ -122,8 +125,27 @@ void menu_control_floppy_image::handle()
|
||||
m_state = START_FILE;
|
||||
handle();
|
||||
} else {
|
||||
const auto &fs = fd.get_fs();
|
||||
output_filename = util::zippath_combine(m_current_directory, m_current_file);
|
||||
output_format = format_array[m_submenu_result.i];
|
||||
if(fs.size() == 1) {
|
||||
create_fs = &fs[0];
|
||||
do_load_create();
|
||||
stack_pop();
|
||||
} else {
|
||||
m_submenu_result.i = -1;
|
||||
menu::stack_push<menu_select_floppy_init>(ui(), container(), fs, &m_submenu_result.i);
|
||||
m_state = SELECT_INIT;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case SELECT_INIT:
|
||||
if(m_submenu_result.i == -1) {
|
||||
m_state = START_FILE;
|
||||
handle();
|
||||
} else {
|
||||
create_fs = &fd.get_fs()[m_submenu_result.i];
|
||||
do_load_create();
|
||||
stack_pop();
|
||||
}
|
||||
|
||||
@ -27,11 +27,12 @@ public:
|
||||
virtual ~menu_control_floppy_image() override;
|
||||
|
||||
private:
|
||||
enum { SELECT_FORMAT = LAST_ID, SELECT_MEDIA, SELECT_RW };
|
||||
enum { SELECT_FORMAT = LAST_ID, SELECT_MEDIA, SELECT_INIT, SELECT_RW };
|
||||
|
||||
floppy_image_device &fd;
|
||||
std::unique_ptr<floppy_image_format_t * []> format_array;
|
||||
floppy_image_format_t *input_format, *output_format;
|
||||
const floppy_image_device::fs_info *create_fs;
|
||||
std::string input_filename, output_filename;
|
||||
|
||||
virtual void handle() override;
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
#include "pc_dsk.h"
|
||||
#include "d88_dsk.h"
|
||||
#include "dfi_dsk.h"
|
||||
#include "fs_unformatted.h"
|
||||
|
||||
#ifdef HAS_FORMATS_2D_DSK
|
||||
#include "2d_dsk.h"
|
||||
@ -664,9 +665,14 @@
|
||||
#include "zx81_p.h"
|
||||
#endif
|
||||
|
||||
#ifdef HAS_FORMATS_FS_PRODOS
|
||||
#include "fs_prodos.h"
|
||||
#endif
|
||||
|
||||
void mame_formats_full_list(mame_formats_enumerator &en)
|
||||
{
|
||||
en.category("Generic");
|
||||
en.add(FS_UNFORMATTED);
|
||||
en.add(cassette_default_formats);
|
||||
#ifdef HAS_FORMATS_UEF_CAS
|
||||
en.add(uef_cassette_formats); // uef_cas.h
|
||||
@ -689,6 +695,9 @@ void mame_formats_full_list(mame_formats_enumerator &en)
|
||||
#endif
|
||||
|
||||
en.category("Apple");
|
||||
#ifdef HAS_FORMATS_FS_PRODOS
|
||||
en.add(FS_PRODOS);
|
||||
#endif
|
||||
#ifdef HAS_FORMATS_AP2_DSK
|
||||
en.add(FLOPPY_A216S_FORMAT); // ap2_dsk.h
|
||||
en.add(FLOPPY_RWTS18_FORMAT); // ap2_dsk.h
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
|
||||
#include "cassimg.h"
|
||||
#include "flopimg.h"
|
||||
#include "fsmgr.h"
|
||||
|
||||
struct mame_formats_enumerator {
|
||||
virtual ~mame_formats_enumerator() = default;
|
||||
@ -17,6 +18,7 @@ struct mame_formats_enumerator {
|
||||
virtual void category(const char *name) = 0;
|
||||
virtual void add(const cassette_image::Format *const *formats) = 0;
|
||||
virtual void add(floppy_format_type format) = 0;
|
||||
virtual void add(filesystem_manager_type fs) = 0;
|
||||
};
|
||||
|
||||
void mame_formats_full_list(mame_formats_enumerator &en);
|
||||
|
||||
76
src/lib/formats/fs_prodos.cpp
Normal file
76
src/lib/formats/fs_prodos.cpp
Normal file
@ -0,0 +1,76 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Creation of Apple ProDOS floppy images
|
||||
|
||||
#include "emu.h"
|
||||
#include "fs_prodos.h"
|
||||
#include "ap_dsk35.h"
|
||||
|
||||
const u8 fs_prodos::boot[512] = {
|
||||
0x01, 0x38, 0xb0, 0x03, 0x4c, 0x1c, 0x09, 0x78, 0x86, 0x43, 0xc9, 0x03, 0x08, 0x8a, 0x29, 0x70,
|
||||
0x4a, 0x4a, 0x4a, 0x4a, 0x09, 0xc0, 0x85, 0x49, 0xa0, 0xff, 0x84, 0x48, 0x28, 0xc8, 0xb1, 0x48,
|
||||
0xd0, 0x3a, 0xb0, 0x0e, 0xa9, 0x03, 0x8d, 0x00, 0x08, 0xe6, 0x3d, 0xa5, 0x49, 0x48, 0xa9, 0x5b,
|
||||
0x48, 0x60, 0x85, 0x40, 0x85, 0x48, 0xa0, 0x5e, 0xb1, 0x48, 0x99, 0x94, 0x09, 0xc8, 0xc0, 0xeb,
|
||||
0xd0, 0xf6, 0xa2, 0x06, 0xbc, 0x32, 0x09, 0xbd, 0x39, 0x09, 0x99, 0xf2, 0x09, 0xbd, 0x40, 0x09,
|
||||
0x9d, 0x7f, 0x0a, 0xca, 0x10, 0xee, 0xa9, 0x09, 0x85, 0x49, 0xa9, 0x86, 0xa0, 0x00, 0xc9, 0xf9,
|
||||
0xb0, 0x2f, 0x85, 0x48, 0x84, 0x60, 0x84, 0x4a, 0x84, 0x4c, 0x84, 0x4e, 0x84, 0x47, 0xc8, 0x84,
|
||||
0x42, 0xc8, 0x84, 0x46, 0xa9, 0x0c, 0x85, 0x61, 0x85, 0x4b, 0x20, 0x27, 0x09, 0xb0, 0x66, 0xe6,
|
||||
0x61, 0xe6, 0x61, 0xe6, 0x46, 0xa5, 0x46, 0xc9, 0x06, 0x90, 0xef, 0xad, 0x00, 0x0c, 0x0d, 0x01,
|
||||
0x0c, 0xd0, 0x52, 0xa9, 0x04, 0xd0, 0x02, 0xa5, 0x4a, 0x18, 0x6d, 0x23, 0x0c, 0xa8, 0x90, 0x0d,
|
||||
0xe6, 0x4b, 0xa5, 0x4b, 0x4a, 0xb0, 0x06, 0xc9, 0x0a, 0xf0, 0x71, 0xa0, 0x04, 0x84, 0x4a, 0xad,
|
||||
0x20, 0x09, 0x29, 0x0f, 0xa8, 0xb1, 0x4a, 0xd9, 0x20, 0x09, 0xd0, 0xdb, 0x88, 0x10, 0xf6, 0xa0,
|
||||
0x16, 0xb1, 0x4a, 0x4a, 0x6d, 0x1f, 0x09, 0x8d, 0x1f, 0x09, 0xa0, 0x11, 0xb1, 0x4a, 0x85, 0x46,
|
||||
0xc8, 0xb1, 0x4a, 0x85, 0x47, 0xa9, 0x00, 0x85, 0x4a, 0xa0, 0x1e, 0x84, 0x4b, 0x84, 0x61, 0xc8,
|
||||
0x84, 0x4d, 0x20, 0x27, 0x09, 0xb0, 0x35, 0xe6, 0x61, 0xe6, 0x61, 0xa4, 0x4e, 0xe6, 0x4e, 0xb1,
|
||||
0x4a, 0x85, 0x46, 0xb1, 0x4c, 0x85, 0x47, 0x11, 0x4a, 0xd0, 0x18, 0xa2, 0x01, 0xa9, 0x00, 0xa8,
|
||||
0x91, 0x60, 0xc8, 0xd0, 0xfb, 0xe6, 0x61, 0xea, 0xea, 0xca, 0x10, 0xf4, 0xce, 0x1f, 0x09, 0xf0,
|
||||
0x07, 0xd0, 0xd8, 0xce, 0x1f, 0x09, 0xd0, 0xca, 0x58, 0x4c, 0x00, 0x20, 0x4c, 0x47, 0x09, 0x02,
|
||||
0x26, 0x50, 0x52, 0x4f, 0x44, 0x4f, 0x53, 0xa5, 0x60, 0x85, 0x44, 0xa5, 0x61, 0x85, 0x45, 0x6c,
|
||||
0x48, 0x00, 0x08, 0x1e, 0x24, 0x3f, 0x45, 0x47, 0x76, 0xf4, 0xd7, 0xd1, 0xb6, 0x4b, 0xb4, 0xac,
|
||||
0xa6, 0x2b, 0x18, 0x60, 0x4c, 0xbc, 0x09, 0x20, 0x58, 0xfc, 0xa0, 0x14, 0xb9, 0x58, 0x09, 0x99,
|
||||
0xb1, 0x05, 0x88, 0x10, 0xf7, 0x4c, 0x55, 0x09, 0xd5, 0xce, 0xc1, 0xc2, 0xcc, 0xc5, 0xa0, 0xd4,
|
||||
0xcf, 0xa0, 0xcc, 0xcf, 0xc1, 0xc4, 0xa0, 0xd0, 0xd2, 0xcf, 0xc4, 0xcf, 0xd3, 0xa5, 0x53, 0x29,
|
||||
0x03, 0x2a, 0x05, 0x2b, 0xaa, 0xbd, 0x80, 0xc0, 0xa9, 0x2c, 0xa2, 0x11, 0xca, 0xd0, 0xfd, 0xe9,
|
||||
0x01, 0xd0, 0xf7, 0xa6, 0x2b, 0x60, 0xa5, 0x46, 0x29, 0x07, 0xc9, 0x04, 0x29, 0x03, 0x08, 0x0a,
|
||||
0x28, 0x2a, 0x85, 0x3d, 0xa5, 0x47, 0x4a, 0xa5, 0x46, 0x6a, 0x4a, 0x4a, 0x85, 0x41, 0x0a, 0x85,
|
||||
0x51, 0xa5, 0x45, 0x85, 0x27, 0xa6, 0x2b, 0xbd, 0x89, 0xc0, 0x20, 0xbc, 0x09, 0xe6, 0x27, 0xe6,
|
||||
0x3d, 0xe6, 0x3d, 0xb0, 0x03, 0x20, 0xbc, 0x09, 0xbc, 0x88, 0xc0, 0x60, 0xa5, 0x40, 0x0a, 0x85,
|
||||
0x53, 0xa9, 0x00, 0x85, 0x54, 0xa5, 0x53, 0x85, 0x50, 0x38, 0xe5, 0x51, 0xf0, 0x14, 0xb0, 0x04,
|
||||
0xe6, 0x53, 0x90, 0x02, 0xc6, 0x53, 0x38, 0x20, 0x6d, 0x09, 0xa5, 0x50, 0x18, 0x20, 0x6f, 0x09,
|
||||
0xd0, 0xe3, 0xa0, 0x7f, 0x84, 0x52, 0x08, 0x28, 0x38, 0xc6, 0x52, 0xf0, 0xce, 0x18, 0x08, 0x88,
|
||||
0xf0, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
};
|
||||
|
||||
void fs_prodos::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
|
||||
{
|
||||
bool all = form_factor == floppy_image::FF_UNKNOWN;
|
||||
|
||||
if(all || (form_factor == floppy_image::FF_35 && has_variant(variants, floppy_image::DSDD)))
|
||||
fe.add(this, FLOPPY_APPLE_GCR_FORMAT, 819200, "prodos_800k", 800, "Apple ProDOS 800K");
|
||||
if(all || (form_factor == floppy_image::FF_35 && has_variant(variants, floppy_image::SSDD)))
|
||||
fe.add(this, FLOPPY_APPLE_GCR_FORMAT, 409600, "prodos_400k", 400, "Apple ProDOS 400K");
|
||||
}
|
||||
|
||||
void fs_prodos::floppy_instantiate(u32 key, std::vector<u8> &image) const
|
||||
{
|
||||
if(key == 800) {
|
||||
copy(image, 0x000, boot, 512);
|
||||
w8 (image, 0x402, 0x03);
|
||||
w8 (image, 0x404, 0xf8);
|
||||
wstr(image, 0x405, "UNTITLED");
|
||||
w32b(image, 0x416, 0x642a250d);
|
||||
w16b(image, 0x41a, 0x80ff);
|
||||
w32b(image, 0x41c, 0x642a250d);
|
||||
w32b(image, 0x420, 0x0500c327);
|
||||
w32b(image, 0x424, 0x0d000006);
|
||||
w32b(image, 0x428, 0x00400600);
|
||||
w32b(image, 0x600, 0x02000400);
|
||||
w32b(image, 0x800, 0x03000500);
|
||||
w8 (image, 0xa00, 0x04);
|
||||
w8 (image, 0xc00, 0x01);
|
||||
fill(image, 0xc01, 0xff, 199);
|
||||
}
|
||||
}
|
||||
|
||||
const filesystem_manager_type FS_PRODOS = &filesystem_manager_creator<fs_prodos>;;
|
||||
26
src/lib/formats/fs_prodos.h
Normal file
26
src/lib/formats/fs_prodos.h
Normal file
@ -0,0 +1,26 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Creation of Apple ProDOS floppy images
|
||||
|
||||
#ifndef MAME_FORMATS_FS_PRODOS_H
|
||||
#define MAME_FORMATS_FS_PRODOS_H
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "fsmgr.h"
|
||||
|
||||
class fs_prodos : public filesystem_manager_t {
|
||||
public:
|
||||
fs_prodos() : filesystem_manager_t() {}
|
||||
|
||||
virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override;
|
||||
virtual void floppy_instantiate(u32 key, std::vector<u8> &image) const override;
|
||||
|
||||
private:
|
||||
static const u8 boot[512];
|
||||
};
|
||||
|
||||
extern const filesystem_manager_type FS_PRODOS;
|
||||
|
||||
#endif
|
||||
99
src/lib/formats/fs_unformatted.cpp
Normal file
99
src/lib/formats/fs_unformatted.cpp
Normal file
@ -0,0 +1,99 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Creation of unformatted floppy images
|
||||
|
||||
#include "emu.h"
|
||||
#include "fs_unformatted.h"
|
||||
|
||||
void fs_unformatted::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
|
||||
{
|
||||
bool all = form_factor == floppy_image::FF_UNKNOWN;
|
||||
u32 best_8 =
|
||||
form_factor == floppy_image::FF_8 ?
|
||||
has_variant(variants, floppy_image::DSDD) ? FSI_8_DSDD :
|
||||
has_variant(variants, floppy_image::DSSD) ? FSI_8_DSSD : FSI_8_SSSD
|
||||
: FSI_NONE;
|
||||
|
||||
u32 best_525 =
|
||||
form_factor == floppy_image::FF_525 ?
|
||||
has_variant(variants, floppy_image::DSHD) ? FSI_525_DSHD :
|
||||
has_variant(variants, floppy_image::DSQD) ? FSI_525_DSQD :
|
||||
has_variant(variants, floppy_image::DSDD) ? FSI_525_DSDD :
|
||||
has_variant(variants, floppy_image::SSQD) ? FSI_525_SSQD :
|
||||
has_variant(variants, floppy_image::SSDD) ? FSI_525_SSDD : FSI_525_SSSD
|
||||
: FSI_NONE;
|
||||
|
||||
u32 best_35 =
|
||||
form_factor == floppy_image::FF_35 ?
|
||||
has_variant(variants, floppy_image::DSDD) ? FSI_35_DSDD : FSI_35_SSDD
|
||||
: FSI_NONE;
|
||||
|
||||
u32 best_3 =
|
||||
form_factor == floppy_image::FF_3 ?
|
||||
has_variant(variants, floppy_image::DSDD) ? FSI_3_DSDD : FSI_3_SSDD
|
||||
: FSI_NONE;
|
||||
|
||||
if(all || best_8 == FSI_8_DSDD)
|
||||
fe.add_raw(this, "u8dsdd", FSI_8_DSDD, "Unformatted 8\" double-sided double-density");
|
||||
if(all || best_8 == FSI_8_DSSD)
|
||||
fe.add_raw(this, "u8dssd", FSI_8_DSSD, "Unformatted 8\" double-sided single-density");
|
||||
if(all || best_8 == FSI_8_SSSD)
|
||||
fe.add_raw(this, "u8sssd", FSI_8_SSSD, "Unformatted 8\" single-sided single-density");
|
||||
|
||||
if(all || best_525 == FSI_525_DSHD)
|
||||
fe.add_raw(this, "u525dshd", FSI_525_DSHD, "Unformatted 5\"25 double-sided high-density");
|
||||
if(all || best_525 == FSI_525_DSQD)
|
||||
fe.add_raw(this, "u525dsqd", FSI_525_DSQD, "Unformatted 5\"25 double-sided quad-density");
|
||||
if(all || best_525 == FSI_525_DSDD)
|
||||
fe.add_raw(this, "u525dsdd", FSI_525_DSDD, "Unformatted 5\"25 double-sided double-density");
|
||||
if(all)
|
||||
fe.add_raw(this, "u525dssd", FSI_525_DSSD, "Unformatted 5\"25 double-sided single-density");
|
||||
if(all || best_525 == FSI_525_SSQD)
|
||||
fe.add_raw(this, "u525ssqd", FSI_525_SSQD, "Unformatted 5\"25 single-sided quad-density");
|
||||
if(all || best_525 == FSI_525_SSDD)
|
||||
fe.add_raw(this, "u525ssdd", FSI_525_SSDD, "Unformatted 5\"25 single-sided double-density");
|
||||
if(all || best_525 == FSI_525_SSSD)
|
||||
fe.add_raw(this, "u525sssd", FSI_525_SSSD, "Unformatted 5\"25 single-sided single-density");
|
||||
|
||||
if(all || has_variant(variants, floppy_image::DSED))
|
||||
fe.add_raw(this, "u35dsed", FSI_35_DSED, "Unformatted 3\"5 double-sided extra-density");
|
||||
if(all || has_variant(variants, floppy_image::DSHD))
|
||||
fe.add_raw(this, "u35dshd", FSI_35_DSHD, "Unformatted 3\"5 double-sided high-density");
|
||||
if(all || best_35 == FSI_35_DSDD)
|
||||
fe.add_raw(this, "u35dsdd", FSI_35_DSDD, "Unformatted 3\"5 double-sided double-density");
|
||||
if(all || best_35 == FSI_35_SSDD)
|
||||
fe.add_raw(this, "u35ssdd", FSI_35_SSDD, "Unformatted 3\"5 single-sided double-density");
|
||||
|
||||
if(all || best_3 == FSI_3_DSDD)
|
||||
fe.add_raw(this, "u3dsdd", FSI_35_DSDD, "Unformatted 3\" double-sided double-density");
|
||||
if(all || best_3 == FSI_3_SSDD)
|
||||
fe.add_raw(this, "u3ssdd", FSI_35_SSDD, "Unformatted 3\" single-sided double-density");
|
||||
}
|
||||
|
||||
void fs_unformatted::floppy_instantiate_raw(u32 key, floppy_image *image) const
|
||||
{
|
||||
switch(key) {
|
||||
case FSI_8_DSDD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSDD); break;
|
||||
case FSI_8_DSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::DSSD); break;
|
||||
case FSI_8_SSSD: image->set_form_variant(floppy_image::FF_8, floppy_image::SSSD); break;
|
||||
|
||||
case FSI_525_DSHD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSHD); break;
|
||||
case FSI_525_DSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSQD); break;
|
||||
case FSI_525_DSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSDD); break;
|
||||
case FSI_525_DSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::DSSD); break;
|
||||
case FSI_525_SSQD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSQD); break;
|
||||
case FSI_525_SSDD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSDD); break;
|
||||
case FSI_525_SSSD: image->set_form_variant(floppy_image::FF_525, floppy_image::SSSD); break;
|
||||
|
||||
case FSI_35_DSED: image->set_form_variant(floppy_image::FF_35, floppy_image::DSED); break;
|
||||
case FSI_35_DSHD: image->set_form_variant(floppy_image::FF_35, floppy_image::DSHD); break;
|
||||
case FSI_35_DSDD: image->set_form_variant(floppy_image::FF_35, floppy_image::DSDD); break;
|
||||
case FSI_35_SSDD: image->set_form_variant(floppy_image::FF_35, floppy_image::SSDD); break;
|
||||
|
||||
case FSI_3_DSDD: image->set_form_variant(floppy_image::FF_3, floppy_image::DSDD); break;
|
||||
case FSI_3_SSDD: image->set_form_variant(floppy_image::FF_3, floppy_image::SSDD); break;
|
||||
}
|
||||
}
|
||||
|
||||
const filesystem_manager_type FS_UNFORMATTED = &filesystem_manager_creator<fs_unformatted>;
|
||||
48
src/lib/formats/fs_unformatted.h
Normal file
48
src/lib/formats/fs_unformatted.h
Normal file
@ -0,0 +1,48 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Creation of unformatted floppy images
|
||||
|
||||
#ifndef MAME_FORMATS_FS_UNFORMATTED_H
|
||||
#define MAME_FORMATS_FS_UNFORMATTED_H
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "fsmgr.h"
|
||||
|
||||
class fs_unformatted : public filesystem_manager_t {
|
||||
public:
|
||||
fs_unformatted() : filesystem_manager_t() {}
|
||||
|
||||
virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const override;
|
||||
virtual void floppy_instantiate_raw(u32 key, floppy_image *image) const override;
|
||||
|
||||
private:
|
||||
enum {
|
||||
FSI_NONE,
|
||||
|
||||
FSI_8_SSSD,
|
||||
FSI_8_DSSD,
|
||||
FSI_8_DSDD,
|
||||
|
||||
FSI_525_SSSD,
|
||||
FSI_525_SSDD,
|
||||
FSI_525_SSQD,
|
||||
FSI_525_DSSD,
|
||||
FSI_525_DSDD,
|
||||
FSI_525_DSQD,
|
||||
FSI_525_DSHD,
|
||||
|
||||
FSI_35_SSDD,
|
||||
FSI_35_DSDD,
|
||||
FSI_35_DSHD,
|
||||
FSI_35_DSED,
|
||||
|
||||
FSI_3_DSDD,
|
||||
FSI_3_SSDD,
|
||||
};
|
||||
};
|
||||
|
||||
extern const filesystem_manager_type FS_UNFORMATTED;
|
||||
|
||||
#endif
|
||||
81
src/lib/formats/fsmgr.cpp
Normal file
81
src/lib/formats/fsmgr.cpp
Normal file
@ -0,0 +1,81 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Filesystem management code for floppy and hd images
|
||||
|
||||
// Currently limited to floppies and creation of preformatted images
|
||||
|
||||
#include "emu.h"
|
||||
#include "fsmgr.h"
|
||||
|
||||
void filesystem_manager_t::enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const
|
||||
{
|
||||
}
|
||||
|
||||
void filesystem_manager_t::floppy_instantiate(u32 key, std::vector<u8> &image) const
|
||||
{
|
||||
fprintf(stderr, "filesystem_manager_t::floppy_instantiate called while unsupported\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
void filesystem_manager_t::floppy_instantiate_raw(u32 key, floppy_image *image) const
|
||||
{
|
||||
fprintf(stderr, "filesystem_manager_t::floppy_instantiate_raw called while unsupported\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
bool filesystem_manager_t::has_variant(const std::vector<uint32_t> &variants, uint32_t variant)
|
||||
{
|
||||
for(uint32_t v : variants)
|
||||
if(variant == v)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void filesystem_manager_t::copy(std::vector<u8> &image, u32 offset, const u8 *src, u32 size)
|
||||
{
|
||||
memcpy(image.data() + offset, src, size);
|
||||
}
|
||||
|
||||
void filesystem_manager_t::fill(std::vector<u8> &image, u32 offset, u8 data, u32 size)
|
||||
{
|
||||
memset(image.data() + offset, data, size);
|
||||
}
|
||||
|
||||
void filesystem_manager_t::wstr(std::vector<u8> &image, u32 offset, const char *str)
|
||||
{
|
||||
memcpy(image.data() + offset, str, strlen(str)+1);
|
||||
}
|
||||
|
||||
void filesystem_manager_t::w8(std::vector<u8> &image, u32 offset, u8 data)
|
||||
{
|
||||
image[offset] = data;
|
||||
}
|
||||
|
||||
void filesystem_manager_t::w16b(std::vector<u8> &image, u32 offset, u16 data)
|
||||
{
|
||||
image[offset ] = data >> 8;
|
||||
image[offset+1] = data;
|
||||
}
|
||||
|
||||
void filesystem_manager_t::w32b(std::vector<u8> &image, u32 offset, u32 data)
|
||||
{
|
||||
image[offset ] = data >> 24;
|
||||
image[offset+1] = data >> 16;
|
||||
image[offset+2] = data >> 8;
|
||||
image[offset+3] = data;
|
||||
}
|
||||
|
||||
void filesystem_manager_t::w16l(std::vector<u8> &image, u32 offset, u16 data)
|
||||
{
|
||||
image[offset ] = data;
|
||||
image[offset+1] = data >> 8;
|
||||
}
|
||||
|
||||
void filesystem_manager_t::w32l(std::vector<u8> &image, u32 offset, u32 data)
|
||||
{
|
||||
image[offset ] = data;
|
||||
image[offset+1] = data >> 8;
|
||||
image[offset+2] = data >> 16;
|
||||
image[offset+3] = data >> 24;
|
||||
}
|
||||
57
src/lib/formats/fsmgr.h
Normal file
57
src/lib/formats/fsmgr.h
Normal file
@ -0,0 +1,57 @@
|
||||
// license:BSD-3-Clause
|
||||
// copyright-holders:Olivier Galibert
|
||||
|
||||
// Filesystem management code for floppy and hd images
|
||||
|
||||
// Currently limited to floppies and creation of preformatted images
|
||||
|
||||
#ifndef MAME_FORMATS_FSMGR_H
|
||||
#define MAME_FORMATS_FSMGR_H
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "flopimg.h"
|
||||
|
||||
class filesystem_manager_t {
|
||||
public:
|
||||
struct floppy_enumerator {
|
||||
virtual ~floppy_enumerator() = default;
|
||||
|
||||
virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) = 0;
|
||||
virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) = 0;
|
||||
};
|
||||
|
||||
virtual void enumerate(floppy_enumerator &fe, uint32_t form_factor, const std::vector<uint32_t> &variants) const;
|
||||
|
||||
// Floppy image initialization
|
||||
virtual void floppy_instantiate(u32 key, std::vector<u8> &image) const;
|
||||
|
||||
// Floppy image initialization for add_raw
|
||||
virtual void floppy_instantiate_raw(u32 key, floppy_image *image) const;
|
||||
|
||||
protected:
|
||||
filesystem_manager_t() = default;
|
||||
|
||||
static bool has_variant(const std::vector<uint32_t> &variants, uint32_t variant);
|
||||
|
||||
static void copy(std::vector<u8> &image, u32 offset, const u8 *src, u32 size);
|
||||
static void fill(std::vector<u8> &image, u32 offset, u8 data, u32 size);
|
||||
static void wstr(std::vector<u8> &image, u32 offset, const char *str);
|
||||
static void w8(std::vector<u8> &image, u32 offset, u8 data);
|
||||
static void w16b(std::vector<u8> &image, u32 offset, u16 data);
|
||||
static void w32b(std::vector<u8> &image, u32 offset, u32 data);
|
||||
static void w16l(std::vector<u8> &image, u32 offset, u16 data);
|
||||
static void w32l(std::vector<u8> &image, u32 offset, u32 data);
|
||||
};
|
||||
|
||||
|
||||
typedef filesystem_manager_t *(*filesystem_manager_type)();
|
||||
|
||||
// this template function creates a stub which constructs a filesystem manager
|
||||
template<class _FormatClass>
|
||||
filesystem_manager_t *filesystem_manager_creator()
|
||||
{
|
||||
return new _FormatClass();
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -33,7 +33,7 @@
|
||||
#include "emupal.h"
|
||||
#include "screen.h"
|
||||
|
||||
#define NEW_SWIM 0
|
||||
#define NEW_SWIM 1
|
||||
|
||||
#define MAC_SCREEN_NAME "screen"
|
||||
#define MAC_539X_1_TAG "539x_1"
|
||||
|
||||
@ -22,16 +22,131 @@
|
||||
#include "corestr.h"
|
||||
#include "osdcomm.h"
|
||||
|
||||
using u8 = uint8_t;
|
||||
using u16 = uint16_t;
|
||||
using u32 = uint32_t;
|
||||
|
||||
#include "formats/all.h"
|
||||
|
||||
struct fs_info {
|
||||
const filesystem_manager_t *m_manager;
|
||||
floppy_format_type m_type;
|
||||
u32 m_image_size;
|
||||
const char *m_name;
|
||||
u32 m_key;
|
||||
const char *m_description;
|
||||
|
||||
fs_info(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) :
|
||||
m_manager(manager),
|
||||
m_type(type),
|
||||
m_image_size(image_size),
|
||||
m_name(name),
|
||||
m_key(key),
|
||||
m_description(description)
|
||||
{}
|
||||
|
||||
fs_info(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) :
|
||||
m_manager(manager),
|
||||
m_type(nullptr),
|
||||
m_image_size(0),
|
||||
m_name(name),
|
||||
m_key(key),
|
||||
m_description(description)
|
||||
{}
|
||||
};
|
||||
|
||||
struct iofile_ram {
|
||||
std::vector<u8> *data;
|
||||
int64_t pos;
|
||||
};
|
||||
|
||||
static void ram_closeproc(void *file)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
delete f;
|
||||
}
|
||||
|
||||
static int ram_seekproc(void *file, int64_t offset, int whence)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
switch(whence) {
|
||||
case SEEK_SET: f->pos = offset; break;
|
||||
case SEEK_CUR: f->pos += offset; break;
|
||||
case SEEK_END: f->pos = f->data->size() + offset; break;
|
||||
}
|
||||
|
||||
f->pos = std::clamp(f->pos, int64_t(0), int64_t(f->data->size()));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static size_t ram_readproc(void *file, void *buffer, size_t length)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
size_t l = std::min(length, f->data->size() - f->pos);
|
||||
memcpy(buffer, f->data->data() + f->pos, l);
|
||||
return l;
|
||||
}
|
||||
|
||||
static size_t ram_writeproc(void *file, const void *buffer, size_t length)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
size_t l = std::min(length, f->data->size() - f->pos);
|
||||
memcpy(f->data->data() + f->pos, buffer, l);
|
||||
return l;
|
||||
}
|
||||
|
||||
static uint64_t ram_filesizeproc(void *file)
|
||||
{
|
||||
auto f = (iofile_ram *)file;
|
||||
return f->data->size();
|
||||
}
|
||||
|
||||
|
||||
static const io_procs iop_ram = {
|
||||
ram_closeproc,
|
||||
ram_seekproc,
|
||||
ram_readproc,
|
||||
ram_writeproc,
|
||||
ram_filesizeproc
|
||||
};
|
||||
|
||||
static io_generic *ram_open(std::vector<u8> &data)
|
||||
{
|
||||
iofile_ram *f = new iofile_ram;
|
||||
f->data = &data;
|
||||
f->pos = 0;
|
||||
return new io_generic({ &iop_ram, f });
|
||||
}
|
||||
|
||||
std::map<std::string, std::vector<floppy_image_format_t *>> formats_by_category;
|
||||
std::map<std::string, floppy_image_format_t *> formats_by_key;
|
||||
|
||||
std::map<std::string, std::vector<fs_info>> fs_by_category;
|
||||
std::map<std::string, fs_info> fs_by_key;
|
||||
|
||||
static std::vector<uint32_t> variants;
|
||||
|
||||
struct enumerator;
|
||||
|
||||
struct fs_enum : public filesystem_manager_t::floppy_enumerator {
|
||||
enumerator *m_en;
|
||||
fs_enum(enumerator *en) : filesystem_manager_t::floppy_enumerator(), m_en(en) {};
|
||||
|
||||
void reg(const fs_info &fsi) const;
|
||||
virtual void add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description) override;
|
||||
virtual void add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description) override;
|
||||
};
|
||||
|
||||
struct enumerator : public mame_formats_enumerator {
|
||||
fs_enum fse;
|
||||
|
||||
enumerator() : mame_formats_enumerator(), fse(this) {}
|
||||
|
||||
virtual ~enumerator() = default;
|
||||
virtual void add(const cassette_image::Format *const *formats) {}
|
||||
|
||||
std::vector<floppy_image_format_t *> *cf = nullptr;
|
||||
std::vector<fs_info> *cfs = nullptr;
|
||||
virtual void category(const char *name) {
|
||||
auto i = formats_by_category.find(name);
|
||||
if(i != formats_by_category.end()) {
|
||||
@ -39,6 +154,7 @@ struct enumerator : public mame_formats_enumerator {
|
||||
exit(1);
|
||||
}
|
||||
cf = &formats_by_category[name];
|
||||
cfs = &fs_by_category[name];
|
||||
}
|
||||
|
||||
virtual void add(floppy_format_type format) {
|
||||
@ -46,7 +162,7 @@ struct enumerator : public mame_formats_enumerator {
|
||||
std::string key = f->name();
|
||||
auto i = formats_by_key.find(key);
|
||||
if(i != formats_by_key.end()) {
|
||||
fprintf(stderr, "Collision on key %s between \"%s\" and \"%s\".\n",
|
||||
fprintf(stderr, "Collision on format key %s between \"%s\" and \"%s\".\n",
|
||||
key.c_str(),
|
||||
i->second->description(),
|
||||
f->description());
|
||||
@ -55,8 +171,40 @@ struct enumerator : public mame_formats_enumerator {
|
||||
cf->push_back(f);
|
||||
formats_by_key[key] = f;
|
||||
}
|
||||
|
||||
virtual void add(filesystem_manager_type fs) {
|
||||
auto ff = fs();
|
||||
ff->enumerate(fse, floppy_image::FF_UNKNOWN, variants);
|
||||
}
|
||||
};
|
||||
|
||||
void fs_enum::reg(const fs_info &fsi) const
|
||||
{
|
||||
std::string key = fsi.m_name;
|
||||
auto i = fs_by_key.find(key);
|
||||
if(i != fs_by_key.end()) {
|
||||
fprintf(stderr, "Collision on fs key %s between \"%s\" and \"%s\".\n",
|
||||
key.c_str(),
|
||||
i->second.m_description,
|
||||
fsi.m_description);
|
||||
exit(1);
|
||||
}
|
||||
m_en->cfs->push_back(fsi);
|
||||
fs_by_key.emplace(key, fsi);
|
||||
}
|
||||
|
||||
void fs_enum::add(const filesystem_manager_t *manager, floppy_format_type type, u32 image_size, const char *name, u32 key, const char *description)
|
||||
{
|
||||
fs_info fsi(manager, type, image_size, name, key, description);
|
||||
reg(fsi);
|
||||
}
|
||||
|
||||
void fs_enum::add_raw(const filesystem_manager_t *manager, const char *name, u32 key, const char *description)
|
||||
{
|
||||
fs_info fsi(manager, name, key, description);
|
||||
reg(fsi);
|
||||
}
|
||||
|
||||
void CLIB_DECL ATTR_PRINTF(1,2) logerror(const char *format, ...)
|
||||
{
|
||||
va_list arg;
|
||||
@ -65,7 +213,6 @@ void CLIB_DECL ATTR_PRINTF(1,2) logerror(const char *format, ...)
|
||||
va_end(arg);
|
||||
}
|
||||
|
||||
static std::vector<uint32_t> variants;
|
||||
|
||||
static void init_formats()
|
||||
{
|
||||
@ -97,11 +244,21 @@ static floppy_image_format_t *find_format_by_identify(io_generic *image)
|
||||
return best_fif;
|
||||
}
|
||||
|
||||
static const fs_info *find_fs_by_name(const char *name)
|
||||
{
|
||||
auto i = fs_by_key.find(name);
|
||||
if(i == fs_by_key.end())
|
||||
return nullptr;
|
||||
return &i->second;
|
||||
}
|
||||
|
||||
|
||||
static void display_usage()
|
||||
{
|
||||
fprintf(stderr, "Usage: \n");
|
||||
fprintf(stderr, " floptool.exe identify <inputfile> [<inputfile> ...]\n");
|
||||
fprintf(stderr, " floptool.exe convert [input_format|auto] output_format <inputfile> <outputfile>\n");
|
||||
fprintf(stderr, " floptool.exe create output_format filesystem <outputfile>\n");
|
||||
}
|
||||
|
||||
static void display_formats()
|
||||
@ -112,6 +269,11 @@ static void display_formats()
|
||||
if(sz > sk)
|
||||
sk = sz;
|
||||
}
|
||||
for(const auto &e : fs_by_key) {
|
||||
int sz = e.first.size();
|
||||
if(sz > sk)
|
||||
sk = sz;
|
||||
}
|
||||
|
||||
fprintf(stderr, "Supported formats:\n\n");
|
||||
for(const auto &e : formats_by_category)
|
||||
@ -120,6 +282,15 @@ static void display_formats()
|
||||
for(floppy_image_format_t *fif : e.second)
|
||||
fprintf(stderr, " %-*s - %s [%s]\n", sk, fif->name(), fif->description(), fif->extensions());
|
||||
}
|
||||
|
||||
fprintf(stderr, "\n\n");
|
||||
fprintf(stderr, "Supported filesystems:\n\n");
|
||||
for(const auto &e : fs_by_category)
|
||||
if(!e.second.empty()) {
|
||||
fprintf(stderr, "%s:\n", e.first.c_str());
|
||||
for(const fs_info &fs : e.second)
|
||||
fprintf(stderr, " %-*s - %s\n", sk, fs.m_name, fs.m_description);
|
||||
}
|
||||
}
|
||||
|
||||
static void display_full_usage()
|
||||
@ -240,6 +411,63 @@ static int convert(int argc, char *argv[])
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int create(int argc, char *argv[])
|
||||
{
|
||||
if (argc!=5) {
|
||||
fprintf(stderr, "Incorrect number of arguments.\n\n");
|
||||
display_usage();
|
||||
return 1;
|
||||
}
|
||||
|
||||
auto dest_format = find_format_by_name(argv[2]);
|
||||
if(!dest_format) {
|
||||
fprintf(stderr, "Error: Format '%s' unknown\n", argv[3]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
auto source_fs = find_fs_by_name(argv[3]);
|
||||
if(!source_fs) {
|
||||
fprintf(stderr, "Error: Filesystem '%s' unknown\n", argv[2]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
floppy_image image(84, 2, floppy_image::FF_UNKNOWN);
|
||||
|
||||
if(source_fs->m_type) {
|
||||
std::vector<u8> img(source_fs->m_image_size);
|
||||
source_fs->m_manager->floppy_instantiate(source_fs->m_key, img);
|
||||
auto iog = ram_open(img);
|
||||
auto source_format = source_fs->m_type();
|
||||
source_format->load(iog, floppy_image::FF_UNKNOWN, variants, &image);
|
||||
delete source_format;
|
||||
delete iog;
|
||||
|
||||
} else
|
||||
source_fs->m_manager->floppy_instantiate_raw(source_fs->m_key, &image);
|
||||
|
||||
char msg[4096];
|
||||
sprintf(msg, "Error opening %s for writing", argv[4]);
|
||||
auto f = fopen(argv[4], "wb");
|
||||
if (!f) {
|
||||
perror(msg);
|
||||
return 1;
|
||||
}
|
||||
|
||||
io_generic dest_io;
|
||||
dest_io.file = f;
|
||||
dest_io.procs = &stdio_ioprocs_noclose;
|
||||
dest_io.filler = 0xff;
|
||||
|
||||
if(!dest_format->save(&dest_io, variants, &image)) {
|
||||
fprintf(stderr, "Error: writing output file as '%s' failed\n", dest_format->name());
|
||||
return 1;
|
||||
}
|
||||
|
||||
fclose((FILE *)dest_io.file);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CLIB_DECL main(int argc, char *argv[])
|
||||
{
|
||||
init_formats();
|
||||
@ -253,6 +481,8 @@ int CLIB_DECL main(int argc, char *argv[])
|
||||
return identify(argc, argv);
|
||||
else if (!core_stricmp("convert", argv[1]))
|
||||
return convert(argc, argv);
|
||||
else if (!core_stricmp("create", argv[1]))
|
||||
return create(argc, argv);
|
||||
else {
|
||||
fprintf(stderr, "Unknown command '%s'\n\n", argv[1]);
|
||||
display_usage();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user