Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-07-06 02:18:09 +03:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

chd: Add dvd support. better abstraction in general, multi-image support in arcade-type drivers

Browse Source
This commit is contained in:
Olivier Galibert 2023-04-09 14:07:32 +02:00
parent 472f441a1b
commit 28104cdbdf
99 changed files with 1640 additions and 1024 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/src/lib.lua
View File

@ -65,6 +65,8 @@ end
MAME_DIR .. "src/lib/util/delegate.h",
MAME_DIR .. "src/lib/util/disasmintf.cpp",
MAME_DIR .. "src/lib/util/disasmintf.h",
MAME_DIR .. "src/lib/util/dvdrom.cpp",
MAME_DIR .. "src/lib/util/dvdrom.h",
MAME_DIR .. "src/lib/util/dynamicclass.cpp",
MAME_DIR .. "src/lib/util/dynamicclass.h",
MAME_DIR .. "src/lib/util/dynamicclass.ipp",

4
scripts/src/machine.lua
View File

@ -41,8 +41,8 @@ files {
MAME_DIR .. "src/devices/imagedev/cartrom.h",
MAME_DIR .. "src/devices/imagedev/cassette.cpp",
MAME_DIR .. "src/devices/imagedev/cassette.h",
MAME_DIR .. "src/devices/imagedev/chd_cd.cpp",
MAME_DIR .. "src/devices/imagedev/chd_cd.h",
MAME_DIR .. "src/devices/imagedev/cdromimg.cpp",
MAME_DIR .. "src/devices/imagedev/cdromimg.h",
MAME_DIR .. "src/devices/imagedev/diablo.cpp",
MAME_DIR .. "src/devices/imagedev/diablo.h",
MAME_DIR .. "src/devices/imagedev/flopdrv.cpp",

2
scripts/src/mame/frontend.lua
View File

@ -149,6 +149,8 @@ files {
MAME_DIR .. "src/frontend/mame/ui/optsmenu.h",
MAME_DIR .. "src/frontend/mame/ui/pluginopt.cpp",
MAME_DIR .. "src/frontend/mame/ui/pluginopt.h",
MAME_DIR .. "src/frontend/mame/ui/prscntrl.cpp",
MAME_DIR .. "src/frontend/mame/ui/prscntrl.h",
MAME_DIR .. "src/frontend/mame/ui/quitmenu.cpp",
MAME_DIR .. "src/frontend/mame/ui/quitmenu.h",
MAME_DIR .. "src/frontend/mame/ui/selector.cpp",

39
src/devices/bus/ata/atapicdr.cpp
View File

@ -8,8 +8,10 @@
#define T10MMC_GET_EVENT_STATUS_NOTIFICATION 0x4a
// device type definition
DEFINE_DEVICE_TYPE(ATAPI_CDROM, atapi_cdrom_device, "cdrom", "ATAPI CD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_FIXED_CDROM, atapi_fixed_cdrom_device, "cdrom_fixed", "ATAPI fixed CD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_CDROM, atapi_cdrom_device, "cdrom", "ATAPI CD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_FIXED_CDROM, atapi_fixed_cdrom_device, "cdrom_fixed", "ATAPI fixed CD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_DVDROM, atapi_dvdrom_device, "dvdrom", "ATAPI CD/DVD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_FIXED_DVDROM, atapi_fixed_dvdrom_device, "dvdrom_fixed", "ATAPI fixed CD/DVD-ROM")
atapi_cdrom_device::atapi_cdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
atapi_cdrom_device(mconfig, ATAPI_CDROM, tag, owner, clock)
@ -27,6 +29,16 @@ atapi_fixed_cdrom_device::atapi_fixed_cdrom_device(const machine_config &mconfig
{
}
atapi_dvdrom_device::atapi_dvdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
atapi_cdrom_device(mconfig, ATAPI_DVDROM, tag, owner, clock)
{
}
atapi_fixed_dvdrom_device::atapi_fixed_dvdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
atapi_cdrom_device(mconfig, ATAPI_FIXED_DVDROM, tag, owner, clock)
{
}
//-------------------------------------------------
// device_add_mconfig - add device configuration
//-------------------------------------------------
@ -88,21 +100,36 @@ void atapi_cdrom_device::device_reset()
{
atapi_hle_device::device_reset();
m_media_change = true;
m_sequence_counter = m_image->sequence_counter();
}
void atapi_fixed_cdrom_device::device_reset()
{
atapi_hle_device::device_reset();
m_cdrom = m_image->get_cdrom_file();
m_media_change = false;
m_sequence_counter = m_image->sequence_counter();
}
void atapi_dvdrom_device::device_reset()
{
atapi_hle_device::device_reset();
m_media_change = true;
m_sequence_counter = m_image->sequence_counter();
}
void atapi_fixed_dvdrom_device::device_reset()
{
atapi_hle_device::device_reset();
m_media_change = false;
m_sequence_counter = m_image->sequence_counter();
}
void atapi_cdrom_device::process_buffer()
{
if(m_cdrom != m_image->get_cdrom_file())
if( m_sequence_counter != m_image->sequence_counter() )
{
m_media_change = true;
SetDevice(m_image->get_cdrom_file());
m_sequence_counter = m_image->sequence_counter();
}
atapi_hle_device::process_buffer();
}
@ -129,7 +156,7 @@ void atapi_cdrom_device::ExecCommand()
case T10MMC_CMD_PAUSE_RESUME:
case T10MMC_CMD_PLAY_AUDIO_12:
case T10SBC_CMD_READ_12:
if(!m_cdrom)
if(!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_sense_key = SCSI_SENSE_KEY_MEDIUM_ERROR;

27
src/devices/bus/ata/atapicdr.h
View File

@ -4,7 +4,7 @@
atapicdr.h
ATAPI CDROM
ATAPI CDROM/DVDROM
***************************************************************************/
@ -37,6 +37,7 @@ protected:
virtual void identify_packet_device() override;
virtual void process_buffer() override;
virtual void ExecCommand() override;
u32 m_sequence_counter;
bool m_media_change;
uint16_t ultra_dma_mode;
};
@ -50,8 +51,28 @@ protected:
virtual void device_reset() override;
};
class atapi_dvdrom_device : public atapi_cdrom_device
{
public:
atapi_dvdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
virtual void device_reset() override;
};
class atapi_fixed_dvdrom_device : public atapi_cdrom_device
{
public:
atapi_fixed_dvdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
protected:
virtual void device_reset() override;
};
// device type definition
DECLARE_DEVICE_TYPE(ATAPI_CDROM, atapi_cdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_FIXED_CDROM, atapi_fixed_cdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_CDROM, atapi_cdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_FIXED_CDROM, atapi_fixed_cdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_DVDROM, atapi_dvdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_FIXED_DVDROM, atapi_fixed_dvdrom_device)
#endif // MAME_BUS_ATA_ATAPICDR_H

33
src/devices/bus/ata/gdrom.cpp
View File

@ -247,7 +247,7 @@ void gdrom_device::ExecCommand()
// READ TOC (GD-ROM ver.)
case 0x14:
{
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -257,7 +257,7 @@ void gdrom_device::ExecCommand()
// TODO: is this correct?
int start_trk = command[2];
int end_trk = m_cdrom->get_last_track();
int end_trk = m_image->get_last_track();
int length;
int allocation_length = SCSILengthFromUINT16( &command[ 3 ] );
@ -340,11 +340,11 @@ void gdrom_device::ReadData( uint8_t *data, int dataLength )
case 0x30: // CD_READ
LOGCMD("CD_READ read %x dataLength,\n", dataLength);
if ((m_cdrom) && (m_blocks))
if (m_image->exists() && m_blocks)
{
while (dataLength > 0)
{
if (!m_cdrom->read_data(m_lba, tmp_buffer, cdrom_file::CD_TRACK_MODE1))
if (!m_image->read_data(m_lba, tmp_buffer, cdrom_file::CD_TRACK_MODE1))
{
LOGWARN("CD read error!\n");
return;
@ -397,7 +397,7 @@ void gdrom_device::ReadData( uint8_t *data, int dataLength )
start_trk = 1;
}
end_trk = m_cdrom->get_last_track();
end_trk = m_image->get_last_track();
len = (end_trk * 8) + 2;
// the returned TOC DATA LENGTH must be the full amount,
@ -429,11 +429,11 @@ void gdrom_device::ReadData( uint8_t *data, int dataLength )
}
data[dptr++] = 0;
data[dptr++] = m_cdrom->get_adr_control(cdrom_track);
data[dptr++] = m_image->get_adr_control(cdrom_track);
data[dptr++] = i;
data[dptr++] = 0;
tstart = m_cdrom->get_track_start(cdrom_track);
tstart = m_image->get_track_start(cdrom_track);
if ((command[1]&2)>>1)
tstart = cdrom_file::lba_to_msf(tstart);
data[dptr++] = (tstart>>24) & 0xff;
@ -453,7 +453,7 @@ void gdrom_device::ReadData( uint8_t *data, int dataLength )
case 0x71:
LOGCMD("SYS_REQ_SECU\n");
memcpy(data, &GDROM_Cmd71_Reply[0], sizeof(GDROM_Cmd71_Reply));
if (is_real_gdrom_disc)
if (m_image->is_gd())
data[10] = 0x1f; // needed by dimm board firmware
break;
@ -498,22 +498,11 @@ void gdrom_device::WriteData( uint8_t *data, int dataLength )
}
}
void gdrom_device::SetDevice(void *device)
{
t10mmc::SetDevice(device);
// try to find if the mounted chd is from an actual gd-rom disc
if (m_cdrom)
if (m_cdrom->get_toc().flags & cdrom_file::CD_FLAG_GDROM)
is_real_gdrom_disc = true;
}
// device type definition
DEFINE_DEVICE_TYPE(GDROM, gdrom_device, "gdrom", "GD-ROM")
DEFINE_DEVICE_TYPE(ATAPI_GDROM, gdrom_device, "gdrom", "GD-ROM")
gdrom_device::gdrom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) :
atapi_cdrom_device(mconfig, GDROM, tag, owner, clock),
is_real_gdrom_disc(false)
atapi_cdrom_device(mconfig, GDROM, tag, owner, clock)
{
}
@ -574,6 +563,6 @@ void gdrom_device::signature()
atapi_hle_device::signature();
// naomi dimm board firmware needs the upper nibble to be 8 at the beginning
if (is_real_gdrom_disc)
if (m_image->is_gd())
m_sector_number = 0x81;
}

4
src/devices/bus/ata/gdrom.h
View File

@ -27,7 +27,6 @@ public:
protected:
virtual void process_buffer() override;
virtual void signature() override;
virtual void SetDevice(void *device) override;
// device-level overrides
virtual void device_start() override;
@ -38,9 +37,8 @@ private:
uint32_t read_type = 0; // for command 0x30 only
uint32_t data_select = 0; // for command 0x30 only
uint32_t transferOffset = 0;
bool is_real_gdrom_disc;
};
DECLARE_DEVICE_TYPE(GDROM, gdrom_device)
DECLARE_DEVICE_TYPE(ATAPI_GDROM, gdrom_device)
#endif // MAME_BUS_ATA_GDROM_H

8
src/devices/bus/ata/idehd.cpp
View File

@ -821,11 +821,9 @@ void ide_hdd_device::device_start()
void ide_hdd_device::device_reset()
{
m_disk = m_image->get_hard_disk_file();
if (m_disk != nullptr && !m_can_identify_device)
if (m_image->exists() && !m_can_identify_device)
{
const auto &hdinfo = m_disk->get_info();
const auto &hdinfo = m_image->get_info();
if (hdinfo.sectorbytes == IDE_DISK_SECTOR_SIZE)
{
m_num_cylinders = hdinfo.cylinders;
@ -837,7 +835,7 @@ void ide_hdd_device::device_reset()
// build the features page
std::vector<u8> ident;
m_disk->get_inquiry_data(ident);
m_image->get_inquiry_data(ident);
if (ident.size() == 512)
{
for( int w = 0; w < 256; w++ )

8
src/devices/bus/ata/idehd.h
View File

@ -102,20 +102,18 @@ protected:
// optional information overrides
virtual void device_add_mconfig(machine_config &config) override;
virtual int read_sector(uint32_t lba, void *buffer) override { return !m_disk ? 0 : m_disk->read(lba, buffer); }
virtual int write_sector(uint32_t lba, const void *buffer) override { return !m_disk ? 0 : m_disk->write(lba, buffer); }
virtual int read_sector(uint32_t lba, void *buffer) override { return !m_image->exists() ? 0 : m_image->read(lba, buffer); }
virtual int write_sector(uint32_t lba, const void *buffer) override { return !m_image->exists() ? 0 : m_image->write(lba, buffer); }
virtual uint8_t calculate_status() override;
hard_disk_file *m_disk;
enum
{
TID_NULL = TID_BUSY + 1
};
private:
required_device<harddisk_image_device> m_image;
private:
emu_timer * m_last_status_timer;
};

14
src/devices/bus/isa/hdc.cpp
View File

@ -227,7 +227,7 @@ void xt_hdc_device::device_reset()
m_error = 0;
}
hard_disk_file *xt_hdc_device::pc_hdc_file(int id)
harddisk_image_device *xt_hdc_device::pc_hdc_file(int id)
{
harddisk_image_device *img = nullptr;
switch (id)
@ -245,7 +245,7 @@ hard_disk_file *xt_hdc_device::pc_hdc_file(int id)
if (!img->exists())
return nullptr;
return img->get_hard_disk_file();
return img;
}
void xt_hdc_device::pc_hdc_result(bool set_error_info)
@ -291,7 +291,7 @@ bool xt_hdc_device::no_dma()
int xt_hdc_device::get_lbasector()
{
hard_disk_file *file = pc_hdc_file(m_drv);
harddisk_image_device *file = pc_hdc_file(m_drv);
const auto &info = file->get_info();
int lbasector = m_cylinder[m_drv];
@ -314,7 +314,7 @@ int xt_hdc_device::get_lbasector()
int xt_hdc_device::dack_r()
{
hard_disk_file *file = pc_hdc_file(m_drv);
harddisk_image_device *file = pc_hdc_file(m_drv);
if (!file)
return 0;
const auto &info = file->get_info();
@ -387,7 +387,7 @@ int xt_hdc_device::dack_rs()
void xt_hdc_device::dack_w(int data)
{
hard_disk_file *file = pc_hdc_file(m_drv);
harddisk_image_device *file = pc_hdc_file(m_drv);
if (!file)
return;
const auto &info = file->get_info();
@ -455,7 +455,7 @@ void xt_hdc_device::execute_read()
if (m_sector_cnt[m_drv] == 0)
size = 256 * 512;
hard_disk_file *disk = pc_hdc_file(m_drv);
harddisk_image_device *disk = pc_hdc_file(m_drv);
if (!disk)
return;
@ -504,7 +504,7 @@ void xt_hdc_device::execute_write()
if (m_sector_cnt[m_drv] == 0)
size = 256 * 512;
hard_disk_file *disk = pc_hdc_file(m_drv);
harddisk_image_device *disk = pc_hdc_file(m_drv);
if (!disk)
return;

2
src/devices/bus/isa/hdc.h
View File

@ -52,7 +52,7 @@ protected:
virtual void device_start() override;
virtual void device_reset() override;
hard_disk_file *pc_hdc_file(int id);
harddisk_image_device *pc_hdc_file(int id);
void pc_hdc_result(bool set_error_info);
bool no_dma();
int get_lbasector();

2
src/devices/bus/isa/mcd.cpp
View File

@ -84,7 +84,7 @@ bool mcd_isa_device::read_sector(bool first)
if(m_cdrom_handle->get_track_type(m_cdrom_handle->get_track(lba)) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->stop_audio();
m_cdda->set_cdrom(get_cdrom_file());
m_cdda->set_cdrom(this);
m_cdda->start_audio(lba, m_readcount);
return true;
}

2
src/devices/bus/isa/mcd.h
View File

@ -6,7 +6,7 @@
#pragma once
#include "isa.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "sound/cdda.h"
//**************************************************************************

77
src/devices/bus/nscsi/cd.cpp
View File

@ -76,12 +76,11 @@ nscsi_cdrom_apple_device::nscsi_cdrom_apple_device(const machine_config &mconfig
nscsi_cdrom_device::nscsi_cdrom_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
: nscsi_full_device(mconfig, type, tag, owner, clock)
, cdrom(nullptr)
, image(*this, "image")
, cdda(*this, "cdda")
, bytes_per_block(bytes_per_sector)
, lba(0)
, cur_sector(0)
, image(*this, "image")
{
}
@ -99,8 +98,8 @@ void nscsi_cdrom_device::device_start()
void nscsi_cdrom_device::device_reset()
{
nscsi_full_device::device_reset();
cdrom = image->get_cdrom_file();
cdda->set_cdrom(cdrom);
sequence_counter = image->sequence_counter();
cdda->set_cdrom(image);
lba = 0;
cur_sector = -1;
mode_data_size = 12;
@ -141,7 +140,7 @@ uint8_t nscsi_cdrom_device::scsi_get_data(int id, int pos)
const int extra_pos = (lba * bytes_per_block) % bytes_per_sector;
if(sector != cur_sector) {
cur_sector = sector;
if(!cdrom->read_data(sector, sector_buffer, cdrom_file::CD_TRACK_MODE1)) {
if(!image->read_data(sector, sector_buffer, cdrom_file::CD_TRACK_MODE1)) {
LOG("CD READ ERROR sector %d!\n", sector);
std::fill_n(sector_buffer, sizeof(sector_buffer), 0);
}
@ -195,11 +194,11 @@ void nscsi_cdrom_device::scsi_command()
int blocks;
// check for media change
if((cdrom != image->get_cdrom_file()) && (scsi_cmdbuf[0] != SC_INQUIRY))
if( sequence_counter != image->sequence_counter() && (scsi_cmdbuf[0] != SC_INQUIRY))
{
// clear media change condition
cdrom = image->get_cdrom_file();
cur_sector = -1;
sequence_counter = image->sequence_counter();
// report unit attention condition
sense(false, SK_UNIT_ATTENTION);
@ -210,14 +209,14 @@ void nscsi_cdrom_device::scsi_command()
switch(scsi_cmdbuf[0]) {
case SC_TEST_UNIT_READY:
LOG("command TEST UNIT READY\n");
if(cdrom)
if(image->exists())
scsi_status_complete(SS_GOOD);
else
return_no_cd();
break;
case SC_READ_6:
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -346,13 +345,13 @@ void nscsi_cdrom_device::scsi_command()
case SC_READ_CAPACITY: {
LOG("command READ CAPACITY\n");
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
// get the last used block on the disc
const u32 temp = cdrom->get_track_start(0xaa) * (bytes_per_sector / bytes_per_block) - 1;
const u32 temp = image->get_track_start(0xaa) * (bytes_per_sector / bytes_per_block) - 1;
scsi_cmdbuf[0] = (temp>>24) & 0xff;
scsi_cmdbuf[1] = (temp>>16) & 0xff;
@ -373,7 +372,7 @@ void nscsi_cdrom_device::scsi_command()
blocks = (scsi_cmdbuf[7] << 8) | scsi_cmdbuf[8];
LOG("command READ EXTENDED start=%08x blocks=%04x\n", lba, blocks);
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -398,7 +397,7 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[pos++] = 0x80; // WP, cache
// get the last used block on the disc
const u32 temp = cdrom ? cdrom->get_track_start(0xaa) * (bytes_per_sector / bytes_per_block) - 1 : 0;
const u32 temp = image->exists() ? image->get_track_start(0xaa) * (bytes_per_sector / bytes_per_block) - 1 : 0;
scsi_cmdbuf[pos++] = 0x08; // Block descriptor length
scsi_cmdbuf[pos++] = 0x00; // density code
@ -515,7 +514,7 @@ void nscsi_cdrom_device::scsi_command()
case SC_READ_DISC_INFORMATION:
LOG("command READ DISC INFORMATION\n");
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -526,12 +525,12 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[3] = 1; // first track
scsi_cmdbuf[4] = 1; // number of sessions (TODO: session support for CHDv6)
scsi_cmdbuf[5] = 1; // first track in last session
scsi_cmdbuf[6] = cdrom->get_last_track(); // last track in last session
scsi_cmdbuf[6] = image->get_last_track(); // last track in last session
scsi_cmdbuf[8] = 0; // CD-ROM, not XA
// lead in start time in MSF
{
u32 tstart = cdrom->get_track_start(0);
u32 tstart = image->get_track_start(0);
tstart = to_msf(tstart + 150);
scsi_cmdbuf[16] = (tstart >> 24) & 0xff;
@ -540,7 +539,7 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[19] = (tstart & 0xff);
// lead-out start time in MSF
tstart = cdrom->get_track_start(0xaa);
tstart = image->get_track_start(0xaa);
tstart = to_msf(tstart + 150);
scsi_cmdbuf[20] = (tstart >> 24) & 0xff;
@ -568,7 +567,7 @@ void nscsi_cdrom_device::scsi_command()
LOG("command READ SUB CHANNEL Param = %d, Track = %d, MSF = %d, SUBQ = %d\n", param, track, msf, subq);
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -600,7 +599,7 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[4] = 0x01; // Sub-channel Data Format Code
scsi_cmdbuf[5] = (audio_active ? 0 : 4) | 0x10; // Q Sub-channel encodes current position data
scsi_cmdbuf[6] = cdrom->get_track(m_last_lba) + 1; // Track Number
scsi_cmdbuf[6] = image->get_track(m_last_lba) + 1; // Track Number
scsi_cmdbuf[7] = 0x00; // Index Number
uint32_t frame = m_last_lba;
@ -612,7 +611,7 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[10] = BIT(frame, 8, 8);
scsi_cmdbuf[11] = BIT(frame, 0, 8);
frame = m_last_lba - cdrom->get_track_start(scsi_cmdbuf[6] - 1);
frame = m_last_lba - image->get_track_start(scsi_cmdbuf[6] - 1);
if(msf)
frame = to_msf(frame);
@ -672,7 +671,7 @@ void nscsi_cdrom_device::scsi_command()
LOG("command READ TOC PMA ATIP, format %s msf=%d size=%d\n", format_names[format], msf, size);
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -681,7 +680,7 @@ void nscsi_cdrom_device::scsi_command()
switch (format) {
case 0: {
int start_track = scsi_cmdbuf[6];
int end_track = cdrom->get_last_track();
int end_track = image->get_last_track();
int tracks;
if(start_track == 0)
@ -700,7 +699,7 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[pos++] = (len>>8) & 0xff;
scsi_cmdbuf[pos++] = (len & 0xff);
scsi_cmdbuf[pos++] = 1;
scsi_cmdbuf[pos++] = cdrom->get_last_track();
scsi_cmdbuf[pos++] = image->get_last_track();
if (start_track == 0)
start_track = 1;
@ -714,11 +713,11 @@ void nscsi_cdrom_device::scsi_command()
}
scsi_cmdbuf[pos++] = 0;
scsi_cmdbuf[pos++] = cdrom->get_adr_control(cdrom_track);
scsi_cmdbuf[pos++] = image->get_adr_control(cdrom_track);
scsi_cmdbuf[pos++] = track;
scsi_cmdbuf[pos++] = 0;
u32 tstart = cdrom->get_track_start(cdrom_track);
u32 tstart = image->get_track_start(cdrom_track);
if(msf)
tstart = to_msf(tstart+150);
@ -740,11 +739,11 @@ void nscsi_cdrom_device::scsi_command()
scsi_cmdbuf[pos++] = 1;
scsi_cmdbuf[pos++] = 0;
scsi_cmdbuf[pos++] = cdrom->get_adr_control(0);
scsi_cmdbuf[pos++] = image->get_adr_control(0);
scsi_cmdbuf[pos++] = 1;
scsi_cmdbuf[pos++] = 0;
u32 tstart = cdrom->get_track_start(0);
u32 tstart = image->get_track_start(0);
if (msf)
tstart = to_msf(tstart+150);
@ -787,12 +786,12 @@ void nscsi_cdrom_device::scsi_command()
// TODO: Index isn't accounted for at all
const uint32_t start_track = scsi_cmdbuf[4];
const uint32_t end_track = cdda_sotc ? start_track : std::min(cdrom->get_last_track(), (int)scsi_cmdbuf[7]);
const uint32_t m_lba = cdrom->get_track_start(start_track - 1);
const uint32_t m_blocks = cdrom->get_track_start(end_track) - m_lba;
const uint32_t track = cdrom->get_track(m_lba);
const uint32_t end_track = cdda_sotc ? start_track : std::min(image->get_last_track(), (int)scsi_cmdbuf[7]);
const uint32_t m_lba = image->get_track_start(start_track - 1);
const uint32_t m_blocks = image->get_track_start(end_track) - m_lba;
const uint32_t track = image->get_track(m_lba);
if(cdrom->get_track_type(track) == cdrom_file::CD_TRACK_AUDIO) {
if(image->get_track_type(track) == cdrom_file::CD_TRACK_AUDIO) {
LOG("Playing %d blocks from track %d (lba %d)\n", m_blocks, start_track, m_lba);
cdda->start_audio(m_lba, m_blocks);
@ -808,7 +807,7 @@ void nscsi_cdrom_device::scsi_command()
}
case SC_PAUSE_RESUME:
if (cdrom)
if (image->exists())
cdda->pause_audio(BIT(scsi_cmdbuf[8], 0) ^ 1);
scsi_status_complete(SS_GOOD);
@ -899,7 +898,7 @@ void nscsi_cdrom_apple_device::scsi_command()
switch (scsi_cmdbuf[0]) {
case SC_TEST_UNIT_READY:
LOG("command TEST UNIT READY (AppleCD)\n");
if(cdrom)
if(image->exists())
{
scsi_status_complete(SS_GOOD);
}
@ -916,7 +915,7 @@ void nscsi_cdrom_apple_device::scsi_command()
LOG("command READ TOC (AppleCD), size=%d, msf=%d\n", size, msf);
if(!cdrom) {
if(!image->exists()) {
return_no_cd();
break;
}
@ -924,7 +923,7 @@ void nscsi_cdrom_apple_device::scsi_command()
int pos = 0;
int start_track = scsi_cmdbuf[5];
int end_track = cdrom->get_last_track();
int end_track = image->get_last_track();
int tracks;
if(start_track == 0)
@ -943,7 +942,7 @@ void nscsi_cdrom_apple_device::scsi_command()
scsi_cmdbuf[pos++] = (len>>8) & 0xff;
scsi_cmdbuf[pos++] = (len & 0xff);
scsi_cmdbuf[pos++] = 1;
scsi_cmdbuf[pos++] = cdrom->get_last_track();
scsi_cmdbuf[pos++] = image->get_last_track();
if (start_track == 0)
start_track = 1;
@ -957,9 +956,9 @@ void nscsi_cdrom_apple_device::scsi_command()
}
scsi_cmdbuf[pos++] = track;
scsi_cmdbuf[pos++] = cdrom->get_adr_control(cdrom_track);
scsi_cmdbuf[pos++] = image->get_adr_control(cdrom_track);
u32 tstart = cdrom->get_track_start(cdrom_track);
u32 tstart = image->get_track_start(cdrom_track);
if(msf)
tstart = to_msf(tstart+150);

11
src/devices/bus/nscsi/cd.h
View File

@ -6,7 +6,7 @@
#pragma once
#include "machine/nscsi_bus.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "cdrom.h"
#include "sound/cdda.h"
@ -18,6 +18,9 @@ public:
void set_block_size(u32 block_size);
protected:
required_device<cdrom_image_device> image;
required_device<cdda_device> cdda;
nscsi_cdrom_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock = 0);
nscsi_cdrom_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, const char *mfr, const char *product, const char *rev, uint8_t inq_data, uint8_t compliance)
@ -41,17 +44,13 @@ protected:
void return_no_cd();
static int to_msf(int frame);
cdrom_file *cdrom;
required_device<cdda_device> cdda;
private:
static constexpr uint32_t bytes_per_sector = 2048;
u32 sequence_counter;
uint8_t sector_buffer[bytes_per_sector];
uint32_t bytes_per_block;
int lba, cur_sector;
required_device<cdrom_image_device> image;
uint8_t mode_data[256];
uint8_t mode_data_size;

25
src/devices/bus/nscsi/hd.cpp
View File

@ -21,7 +21,7 @@ nscsi_harddisk_device::nscsi_harddisk_device(const machine_config &mconfig, cons
}
nscsi_harddisk_device::nscsi_harddisk_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock) :
nscsi_full_device(mconfig, type, tag, owner, clock), image(*this, "image"), harddisk(nullptr), lba(0), cur_lba(0), blocks(0), bytes_per_sector(0)
nscsi_full_device(mconfig, type, tag, owner, clock), image(*this, "image"), lba(0), cur_lba(0), blocks(0), bytes_per_sector(0)
{
}
@ -38,14 +38,13 @@ void nscsi_harddisk_device::device_start()
void nscsi_harddisk_device::device_reset()
{
nscsi_full_device::device_reset();
harddisk = image->get_hard_disk_file();
if(!harddisk) {
if(!image->exists()) {
scsi_id = -1;
bytes_per_sector = 0;
} else {
const auto &hdinfo = harddisk->get_info();
const auto &hdinfo = image->get_info();
bytes_per_sector = hdinfo.sectorbytes;
harddisk->get_inquiry_data(m_inquiry_data);
image->get_inquiry_data(m_inquiry_data);
}
cur_lba = -1;
}
@ -67,7 +66,7 @@ uint8_t nscsi_harddisk_device::scsi_get_data(int id, int pos)
int clba = lba + pos / bytes_per_sector;
if(clba != cur_lba) {
cur_lba = clba;
if(!harddisk->read(cur_lba, block)) {
if(!image->read(cur_lba, block)) {
LOG("HD READ ERROR !\n");
memset(block, 0, sizeof(block));
}
@ -90,7 +89,7 @@ void nscsi_harddisk_device::scsi_put_data(int id, int pos, uint8_t data)
block[offset] = data;
cur_lba = lba + pos / bytes_per_sector;
if(offset == bytes_per_sector-1) {
if(!harddisk->write(cur_lba, block))
if(!image->write(cur_lba, block))
LOG("HD WRITE ERROR !\n");
}
}
@ -117,7 +116,7 @@ void nscsi_harddisk_device::scsi_command()
LOG("command READ start=%08x blocks=%04x\n", lba, blocks);
if(harddisk->read(lba, block)) {
if(image->read(lba, block)) {
scsi_data_in(2, blocks*bytes_per_sector);
scsi_status_complete(SS_GOOD);
}
@ -219,7 +218,7 @@ void nscsi_harddisk_device::scsi_command()
scsi_cmdbuf[pos++] = 0x00; // medium type
scsi_cmdbuf[pos++] = 0x00; // WP, cache
const auto &info = harddisk->get_info();
const auto &info = image->get_info();
uint32_t dsize = info.cylinders * info.heads * info.sectors - 1;
scsi_cmdbuf[pos++] = 0x08; // Block descriptor length
scsi_cmdbuf[pos++] = 0x00;
@ -450,7 +449,7 @@ void nscsi_harddisk_device::scsi_command()
case SC_READ_CAPACITY: {
LOG("command READ CAPACITY\n");
const auto &info = harddisk->get_info();
const auto &info = image->get_info();
uint32_t size = info.cylinders * info.heads * info.sectors - 1;
scsi_cmdbuf[0] = (size>>24) & 0xff;
@ -473,7 +472,7 @@ void nscsi_harddisk_device::scsi_command()
LOG("command READ EXTENDED start=%08x blocks=%04x\n",lba, blocks);
if(harddisk->read(lba, block)) {
if(image->read(lba, block)) {
scsi_data_in(2, blocks*bytes_per_sector);
scsi_status_complete(SS_GOOD);
}
@ -502,12 +501,12 @@ void nscsi_harddisk_device::scsi_command()
(scsi_cmdbuf[1] & 0x10) ? " FMTDATA" : "",
(scsi_cmdbuf[1] & 0x08) ? " CMPLIST" : "");
{
const auto &info = harddisk->get_info();
const auto &info = image->get_info();
auto block = std::make_unique<uint8_t[]>(info.sectorbytes);
for(int cyl = 0; cyl < info.cylinders; cyl++) {
for(int head = 0; head < info.heads; head++) {
for(int sector = 0; sector < info.sectors; sector++) {
harddisk->write(cyl * head * sector, block.get());
image->write(cyl * head * sector, block.get());
}
}
}

1
src/devices/bus/nscsi/hd.h
View File

@ -26,7 +26,6 @@ protected:
required_device<harddisk_image_device> image;
uint8_t block[512];
hard_disk_file *harddisk;
int lba, cur_lba, blocks;
int bytes_per_sector;

6
src/devices/bus/nscsi/s1410.cpp
View File

@ -85,12 +85,12 @@ void nscsi_s1410_device::scsi_command()
case SC_FORMAT_UNIT:
LOG("command FORMAT UNIT\n");
{
const auto &info = harddisk->get_info();
const auto &info = image->get_info();
auto block = std::make_unique<uint8_t[]>(info.sectorbytes);
memset(&block[0], 0x6c, info.sectorbytes);
lba = ((scsi_cmdbuf[1] & 0x1f)<<16) | (scsi_cmdbuf[2]<<8) | scsi_cmdbuf[3];
for(; lba < (info.cylinders * info.heads * info.sectors); lba++) {
harddisk->write(lba, block.get());
image->write(lba, block.get());
}
}
scsi_status_complete(SS_GOOD);
@ -110,7 +110,7 @@ void nscsi_s1410_device::scsi_command()
auto block = std::make_unique<uint8_t[]>(track_length);
memset(&block[0], 0x6c, track_length);
if(!harddisk->write(lba, &block[0])) {
if(!image->write(lba, &block[0])) {
logerror("%s: HD WRITE ERROR !\n", tag());
scsi_status_complete(SS_FORMAT_ERROR);
scsi_sense_buffer[0] = SK_FORMAT_ERROR;

12
src/devices/bus/scsi/omti5100.cpp
View File

@ -33,7 +33,7 @@ omti5100_device::omti5100_device(const machine_config &mconfig, const char *tag,
void omti5100_device::device_start()
{
if(!m_image0->get_hard_disk_file())
if(!m_image0->exists())
m_image = m_image1;
m_image = m_image0;
scsihle_device::device_start();
@ -42,8 +42,8 @@ void omti5100_device::device_start()
void omti5100_device::ExecCommand()
{
int drive = (command[1] >> 5) & 1;
hard_disk_file *image = (drive ? m_image1 : m_image0)->get_hard_disk_file();
if(!image)
harddisk_image_device *image = drive ? m_image1 : m_image0;
if(!image->exists())
{
if(command[0] == T10SPC_CMD_REQUEST_SENSE)
return scsihd_device::ExecCommand();
@ -86,7 +86,6 @@ void omti5100_device::ExecCommand()
}
else
{
SetDevice(image);
scsihd_device::ExecCommand();
}
break;
@ -114,7 +113,6 @@ void omti5100_device::ExecCommand()
break;
}
default:
SetDevice(image);
scsihd_device::ExecCommand();
break;
}
@ -144,10 +142,10 @@ void omti5100_device::WriteData( uint8_t *data, int dataLength )
case OMTI_ASSIGN_DISK_PARAM:
{
int drive = ((command[1] >> 5) & 1);
hard_disk_file *image = (drive ? m_image1 : m_image0)->get_hard_disk_file();
harddisk_image_device *image = drive ? m_image1 : m_image0;
m_param[drive].heads = data[3] + 1;
m_param[drive].cylinders = ((data[4] << 8) | data[5]) + 1;
if(!data[8] && image)
if(!data[8] && image->exists())
{
switch(image->get_info().sectorbytes)
{

9
src/devices/bus/scsi/s1410.cpp
View File

@ -173,7 +173,7 @@ void s1410_device::device_add_mconfig(machine_config &config)
z8400a.set_addrmap(AS_IO, &s1410_device::s1410_io);
z8400a.set_disable();
HARDDISK(config, "image").set_interface("scsi_hdd");
HARDDISK(config, m_image).set_interface("scsi_hdd");
}
@ -187,7 +187,8 @@ void s1410_device::device_add_mconfig(machine_config &config)
//-------------------------------------------------
s1410_device::s1410_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: scsihd_device(mconfig, S1410, tag, owner, clock)
: scsihd_device(mconfig, S1410, tag, owner, clock),
m_image(*this, "image")
{
}
@ -248,14 +249,14 @@ void s1410_device::ExecCommand()
logerror("S1410: FORMAT TRACK at LBA %x for %x blocks\n", m_lba, m_blocks);
if ((m_disk) && (m_blocks))
if (m_image->exists() && m_blocks)
{
std::vector<uint8_t> data(m_sector_bytes);
memset(&data[0], 0xc6, m_sector_bytes);
while (m_blocks > 0)
{
if (!m_disk->write(m_lba, &data[0]))
if (!m_image->write(m_lba, &data[0]))
{
logerror("S1410: HD write error!\n");
}

2
src/devices/bus/scsi/s1410.h
View File

@ -29,6 +29,8 @@ protected:
virtual void ReadData( uint8_t *data, int dataLength ) override;
private:
required_device<harddisk_image_device> m_image;
void s1410_io(address_map &map);
void s1410_mem(address_map &map);
};

7
src/devices/bus/scsi/scsicd.cpp
View File

@ -35,3 +35,10 @@ void scsicd_device::device_add_mconfig(machine_config &config)
CDROM(config, "image").set_interface("cdrom");
CDDA(config, "cdda");
}
bool scsicd_device::exists() const
{
// cd drive is visible even if there's no cd in it
return true;
}

2
src/devices/bus/scsi/scsicd.h
View File

@ -21,8 +21,8 @@ public:
protected:
scsicd_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual bool exists() const override;
};
// device type definition

5
src/devices/bus/scsi/scsihd.cpp
View File

@ -33,3 +33,8 @@ void scsihd_device::device_add_mconfig(machine_config &config)
{
HARDDISK(config, "image", "scsi_hdd");
}
bool scsihd_device::exists() const
{
return m_image->exists();
}

2
src/devices/bus/scsi/scsihd.h
View File

@ -23,8 +23,8 @@ public:
protected:
scsihd_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
virtual void device_start() override;
virtual void device_add_mconfig(machine_config &config) override;
virtual bool exists() const override;
};
// device type definition

6
src/devices/bus/scsi/scsihle.cpp
View File

@ -415,11 +415,9 @@ WRITE_LINE_MEMBER( scsihle_device::input_sel )
// only one line active.
if (scsibus_driveno(m_input_data) == scsiID)
{
void *hdfile = nullptr;
// Check to see if device had image file mounted, if not, do not set busy,
// and stay busfree.
GetDevice(&hdfile);
if (hdfile != nullptr)
if (exists())
{
if (!state)
{
@ -494,7 +492,7 @@ WRITE_LINE_MEMBER( scsihle_device::input_ack )
if (IS_COMMAND(SCSI_CMD_FORMAT_UNIT))
{
// If we have the first byte, then cancel the dataout timout
// If we have the first byte, then cancel the dataout timeout
if (data_idx == 1)
dataout_timer->adjust(attotime::never);

2
src/devices/bus/scsi/scsihle.h
View File

@ -35,6 +35,8 @@ public:
virtual DECLARE_WRITE_LINE_MEMBER( input_data6 ) override { if (state) m_input_data |= 0x40; else m_input_data &= ~0x40; }
virtual DECLARE_WRITE_LINE_MEMBER( input_data7 ) override { if (state) m_input_data |= 0x80; else m_input_data &= ~0x80; }
virtual bool exists() const = 0;
protected:
// construction/destruction
scsihle_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);

51
src/devices/bus/ti99x/990_hd.cpp
View File

@ -46,16 +46,6 @@ static inline uint32_t get_UINT32BE(UINT32BE word)
return (word.bytes[0] << 24) | (word.bytes[1] << 16) | (word.bytes[2] << 8) | word.bytes[3];
}
#ifdef UNUSED_FUNCTION
static inline void set_UINT32BE(UINT32BE *word, uint32_t data)
{
word->bytes[0] = (data >> 24) & 0xff;
word->bytes[1] = (data >> 16) & 0xff;
word->bytes[2] = (data >> 8) & 0xff;
word->bytes[3] = data & 0xff;
}
#endif
/* disk image header */
struct disk_image_header
{
@ -166,20 +156,16 @@ std::error_condition ti990_hdc_device::load_hd(device_image_interface &image)
{
int id = get_id_from_device( &image.device() );
hd_unit_t *d;
hard_disk_file *hd_file;
d = &m_d[id];
d->img = &image;
d->img = downcast<harddisk_image_device *>(&image);
hd_file = dynamic_cast<harddisk_image_device *>(&image)->get_hard_disk_file();
if ( hd_file )
if ( d->img->exists() )
{
d->format = format_mame;
d->hd_handle = hd_file;
/* use standard hard disk image header. */
const auto &standard_header = d->hd_handle->get_info();
const auto &standard_header = d->img->get_info();
d->cylinders = standard_header.cylinders;
d->heads = standard_header.heads;
@ -194,7 +180,6 @@ std::error_condition ti990_hdc_device::load_hd(device_image_interface &image)
/* set file descriptor */
d->format = format_old;
d->hd_handle = nullptr;
/* use custom image header. */
/* to convert old header-less images to this format, insert a 16-byte
@ -218,7 +203,6 @@ std::error_condition ti990_hdc_device::load_hd(device_image_interface &image)
if (d->bytes_per_sector > MAX_SECTOR_SIZE)
{
d->format = format_mame;
d->hd_handle = nullptr;
d->wp = 1;
d->unsafe = 1;
return image_error::INVALIDIMAGE;
@ -245,7 +229,6 @@ void ti990_hdc_device::unload_hd(device_image_interface &image)
d = &m_d[id];
d->format = format_mame; /* don't care */
d->hd_handle = nullptr;
d->wp = 1;
d->unsafe = 1;
@ -258,20 +241,7 @@ void ti990_hdc_device::unload_hd(device_image_interface &image)
*/
int ti990_hdc_device::is_unit_loaded(int unit)
{
int reply = 0;
switch (m_d[unit].format)
{
case format_mame:
reply = (m_d[unit].hd_handle != nullptr);
break;
case format_old:
reply = (m_d[unit].img->exists() ? 1 : 0);
break;
}
return reply;
return m_d[unit].img->exists();
}
/*
@ -363,7 +333,7 @@ int ti990_hdc_device::read_sector(int unit, unsigned int lba, void *buffer, unsi
switch (m_d[unit].format)
{
case format_mame:
bytes_read = m_d[unit].bytes_per_sector * m_d[unit].hd_handle->read(lba, buffer);
bytes_read = m_d[unit].bytes_per_sector * m_d[unit].img->read(lba, buffer);
if (bytes_read > bytes_to_read)
bytes_read = bytes_to_read;
break;
@ -393,7 +363,7 @@ int ti990_hdc_device::write_sector(int unit, unsigned int lba, const void *buffe
switch (m_d[unit].format)
{
case format_mame:
bytes_written = m_d[unit].bytes_per_sector * m_d[unit].hd_handle->write(lba, buffer);
bytes_written = m_d[unit].bytes_per_sector * m_d[unit].img->write(lba, buffer);
if (bytes_written > bytes_to_write)
bytes_written = bytes_to_write;
break;
@ -979,7 +949,6 @@ void ti990_hdc_device::device_start()
for (i=0; i<MAX_DISK_UNIT; i++)
{
m_d[i].format = format_mame;
m_d[i].hd_handle = nullptr;
m_d[i].wp = 1;
m_d[i].unsafe = 1;
}
@ -987,10 +956,10 @@ void ti990_hdc_device::device_start()
m_w[7] = w7_idle;
/* get references to harddisk devices */
m_d[0].img = dynamic_cast<device_image_interface *>(subdevice("harddisk1"));
m_d[1].img = dynamic_cast<device_image_interface *>(subdevice("harddisk2"));
m_d[2].img = dynamic_cast<device_image_interface *>(subdevice("harddisk3"));
m_d[3].img = dynamic_cast<device_image_interface *>(subdevice("harddisk4"));
m_d[0].img = dynamic_cast<harddisk_image_device *>(subdevice("harddisk1"));
m_d[1].img = dynamic_cast<harddisk_image_device *>(subdevice("harddisk2"));
m_d[2].img = dynamic_cast<harddisk_image_device *>(subdevice("harddisk3"));
m_d[3].img = dynamic_cast<harddisk_image_device *>(subdevice("harddisk4"));
m_interrupt_callback.resolve_safe();

3
src/devices/bus/ti99x/990_hd.h
View File

@ -59,9 +59,8 @@ private:
/* disk drive unit descriptor */
struct hd_unit_t
{
device_image_interface *img; /* image descriptor */
harddisk_image_device *img; /* image descriptor */
format_t format;
hard_disk_file *hd_handle; /* mame hard disk descriptor - only if format == format_mame */
unsigned int wp : 1; /* true if disk is write-protected */
unsigned int unsafe : 1; /* true when a disk has just been connected */

227
src/devices/imagedev/cdromimg.cpp Normal file
View File

@ -0,0 +1,227 @@
// license:BSD-3-Clause
// copyright-holders:Nathan Woods, R. Belmont, Miodrag Milanovic
/*********************************************************************
CD/DVD reader
*********************************************************************/
#include "emu.h"
#include "cdromimg.h"
#include "romload.h"
// device type definition
DEFINE_DEVICE_TYPE(CDROM, cdrom_image_device, "cdrom_image", "CD-ROM Image")
DEFINE_DEVICE_TYPE(GDROM, gdrom_image_device, "gdrom_image", "CD/GD-ROM Image")
DEFINE_DEVICE_TYPE(DVDROM, dvdrom_image_device, "dvdrom_image", "CD/DVD-ROM Image")
//-------------------------------------------------
// cdrom_image_device - constructor
//-------------------------------------------------
cdrom_image_device::cdrom_image_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: cdrom_image_device(mconfig, CDROM, tag, owner, clock)
{
}
cdrom_image_device::cdrom_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, bool dvd_compat, bool gd_compat)
: device_t(mconfig, type, tag, owner, clock),
device_image_interface(mconfig, *this),
m_gd_compat(gd_compat),
m_dvd_compat(dvd_compat),
m_cdrom_handle(nullptr),
m_dvdrom_handle(nullptr),
m_extension_list(nullptr),
m_interface(nullptr)
{
}
//-------------------------------------------------
// cdrom_image_device - destructor
//-------------------------------------------------
cdrom_image_device::~cdrom_image_device()
{
}
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
//-------------------------------------------------
void cdrom_image_device::device_config_complete()
{
m_extension_list = "chd,cue,toc,nrg,gdi,iso,cdr";
add_format("chdcd", m_dvd_compat ? "CD/DVD-ROM drive" : "CD-ROM drive", m_extension_list, "");
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void cdrom_image_device::device_start()
{
if (has_preset_images())
{
set_image_tag();
set_user_loadable(false);
setup_current_preset_image();
}
else
{
m_cdrom_handle.reset();
m_dvdrom_handle.reset();
}
}
void cdrom_image_device::setup_current_preset_image()
{
m_cdrom_handle.reset();
m_dvdrom_handle.reset();
chd_file *chd = current_preset_image_chd();
if (chd->is_cd())
m_cdrom_handle = std::make_unique<cdrom_file>(chd);
else if(m_dvd_compat && chd->is_dvd())
m_dvdrom_handle = std::make_unique<dvdrom_file>(chd);
else
fatalerror("chd for region %s is not compatible with the cdrom image device\n", preset_images_list()[current_preset_image_id()]);
}
void cdrom_image_device::device_stop()
{
m_cdrom_handle.reset();
m_dvdrom_handle.reset();
if (m_self_chd.opened())
m_self_chd.close();
}
std::pair<std::error_condition, std::string> cdrom_image_device::call_load()
{
if (has_preset_images())
{
setup_current_preset_image();
return std::make_pair(image_error(0), std::string());;
}
std::error_condition err;
chd_file *chd = nullptr;
m_cdrom_handle.reset();
m_dvdrom_handle.reset();
if (!loaded_through_softlist()) {
if (is_filetype("chd") && is_loaded()) {
util::core_file::ptr proxy;
err = util::core_file::open_proxy(image_core_file(), proxy);
if (!err)
err = m_self_chd.open(std::move(proxy)); // CDs are never writeable
if (err)
goto error;
chd = &m_self_chd;
}
} else {
chd = device().machine().rom_load().get_disk_handle(device().subtag("cdrom").c_str());
}
// open the CHD file
if (chd)
m_cdrom_handle.reset(new cdrom_file(chd));
else
m_cdrom_handle.reset(new cdrom_file(filename()));
if (!m_cdrom_handle)
goto error;
return std::make_pair(std::error_condition(), std::string());
error:
if (chd && chd == &m_self_chd)
m_self_chd.close();
return std::make_pair(err ? err : image_error::UNSPECIFIED, std::string());
}
void cdrom_image_device::call_unload()
{
assert(m_cdrom_handle || m_dvdrom_handle);
m_cdrom_handle.reset();
m_dvdrom_handle.reset();
if (m_self_chd.opened())
m_self_chd.close();
}
int cdrom_image_device::get_last_track() const
{
if (m_cdrom_handle)
return m_cdrom_handle->get_last_track();
return 0;
}
uint32_t cdrom_image_device::get_track(uint32_t frame) const
{
if (m_cdrom_handle)
return m_cdrom_handle->get_track(frame);
return 0;
}
uint32_t cdrom_image_device::get_track_start(uint32_t track) const
{
if (m_cdrom_handle)
return m_cdrom_handle->get_track_start(track);
return 0;
}
bool cdrom_image_device::read_data(uint32_t lbasector, void *buffer, uint32_t datatype, bool phys)
{
if (m_cdrom_handle)
return m_cdrom_handle->read_data(lbasector, buffer, datatype, phys);
return 0;
}
bool cdrom_image_device::read_subcode(uint32_t lbasector, void *buffer, bool phys)
{
if (m_cdrom_handle)
return m_cdrom_handle->read_subcode(lbasector, buffer, phys);
return 0;
}
int cdrom_image_device::get_adr_control(int track) const
{
if (m_cdrom_handle)
return m_cdrom_handle->get_adr_control(track);
return 0;
}
const cdrom_file::toc &cdrom_image_device::get_toc() const
{
static cdrom_file::toc notoc;
if (m_cdrom_handle)
return m_cdrom_handle->get_toc();
return notoc;
}
int cdrom_image_device::get_track_type(int track) const
{
if (m_cdrom_handle)
return m_cdrom_handle->get_track_type(track);
return 0;
}
bool cdrom_image_device::is_cd() const
{
return m_cdrom_handle != nullptr;
}
bool cdrom_image_device::is_gd() const
{
return false;
}
bool cdrom_image_device::is_dvd() const
{
return m_dvdrom_handle != nullptr;
}

51
src/devices/imagedev/chd_cd.h → src/devices/imagedev/cdromimg.h
View File

@ -2,9 +2,9 @@
// copyright-holders:Nathan Woods, R. Belmont, Miodrag Milanovic
/*********************************************************************
chd_cd.h
cdromimg.h
Interface to the CHD CDROM code
CD/DVD reader
*********************************************************************/
@ -16,12 +16,18 @@
#include "softlist_dev.h"
#include "cdrom.h"
#include "dvdrom.h"
#include <memory>
#include <string>
#include <system_error>
#include <utility>
// device type definition
DECLARE_DEVICE_TYPE(CDROM, cdrom_image_device)
DECLARE_DEVICE_TYPE(GDROM, gdrom_image_device) // Includes CDROM compatibility (but not DVDROM)
DECLARE_DEVICE_TYPE(DVDROM, dvdrom_image_device) // Includes CDROM compatibility (but not GDROM)
/***************************************************************************
TYPE DEFINITIONS
@ -52,11 +58,21 @@ public:
virtual const char *image_type_name() const noexcept override { return "cdrom"; }
virtual const char *image_brief_type_name() const noexcept override { return "cdrm"; }
// specific implementation
cdrom_file *get_cdrom_file() { return m_cdrom_handle.get(); }
int get_last_track() const;
uint32_t get_track(uint32_t frame) const;
uint32_t get_track_start(uint32_t track) const;
bool read_data(uint32_t lbasector, void *buffer, uint32_t datatype, bool phys=false);
bool read_subcode(uint32_t lbasector, void *buffer, bool phys=false);
int get_adr_control(int track) const;
const cdrom_file::toc &get_toc() const;
int get_track_type(int track) const;
bool is_cd() const;
bool is_gd() const;
bool is_dvd() const;
protected:
cdrom_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
cdrom_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock, bool dvd_compat = false, bool gd_compat = false);
// device_t implementation
virtual void device_config_complete() override;
@ -66,13 +82,34 @@ protected:
// device_image_interface implementation
virtual const software_list_loader &get_software_list_loader() const override { return rom_software_list_loader::instance(); }
void setup_current_preset_image();
bool m_gd_compat;
bool m_dvd_compat;
chd_file m_self_chd;
std::unique_ptr<cdrom_file> m_cdrom_handle;
std::unique_ptr<dvdrom_file> m_dvdrom_handle;
const char *m_extension_list;
const char *m_interface;
};
// device type definition
DECLARE_DEVICE_TYPE(CDROM, cdrom_image_device)
class gdrom_image_device : public cdrom_image_device
{
public:
// construction/destruction
gdrom_image_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock = 0) :
cdrom_image_device(mconfig, GDROM, tag, owner, clock, false, true) {}
virtual ~gdrom_image_device() = default;
};
class dvdrom_image_device : public cdrom_image_device
{
public:
// construction/destruction
dvdrom_image_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock = 0) :
cdrom_image_device(mconfig, DVDROM, tag, owner, clock, true, false) {}
virtual ~dvdrom_image_device() = default;
};
#endif // MAME_DEVICES_IMAGEDEV_CHD_CD_H

123
src/devices/imagedev/chd_cd.cpp
View File

@ -1,123 +0,0 @@
// license:BSD-3-Clause
// copyright-holders:Nathan Woods, R. Belmont, Miodrag Milanovic
/*********************************************************************
Code to interface the image code with CHD-CD core.
Based on harddriv.c by Raphael Nabet 2003
*********************************************************************/
#include "emu.h"
#include "chd_cd.h"
#include "cdrom.h"
#include "romload.h"
// device type definition
DEFINE_DEVICE_TYPE(CDROM, cdrom_image_device, "cdrom_image", "CD-ROM Image")
//-------------------------------------------------
// cdrom_image_device - constructor
//-------------------------------------------------
cdrom_image_device::cdrom_image_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
: cdrom_image_device(mconfig, CDROM, tag, owner, clock)
{
}
cdrom_image_device::cdrom_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
: device_t(mconfig, type, tag, owner, clock)
, device_image_interface(mconfig, *this)
, m_cdrom_handle()
, m_extension_list(nullptr)
, m_interface(nullptr)
{
}
//-------------------------------------------------
// cdrom_image_device - destructor
//-------------------------------------------------
cdrom_image_device::~cdrom_image_device()
{
}
//-------------------------------------------------
// device_config_complete - perform any
// operations now that the configuration is
// complete
//-------------------------------------------------
void cdrom_image_device::device_config_complete()
{
m_extension_list = "chd,cue,toc,nrg,gdi,iso,cdr";
add_format("chdcd", "CD-ROM drive", m_extension_list, "");
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------
void cdrom_image_device::device_start()
{
// try to locate the CHD from a DISK_REGION
chd_file *chd = machine().rom_load().get_disk_handle(owner()->tag());
if (chd)
m_cdrom_handle.reset(new cdrom_file(chd));
else
m_cdrom_handle.reset();
}
void cdrom_image_device::device_stop()
{
m_cdrom_handle.reset();
if (m_self_chd.opened())
m_self_chd.close();
}
std::pair<std::error_condition, std::string> cdrom_image_device::call_load()
{
std::error_condition err;
chd_file *chd = nullptr;
m_cdrom_handle.reset();
if (!loaded_through_softlist()) {
if (is_filetype("chd") && is_loaded()) {
util::core_file::ptr proxy;
err = util::core_file::open_proxy(image_core_file(), proxy);
if (!err)
err = m_self_chd.open(std::move(proxy)); // CDs are never writeable
if (err)
goto error;
chd = &m_self_chd;
}
} else {
chd = device().machine().rom_load().get_disk_handle(device().subtag("cdrom").c_str());
}
// open the CHD file
if (chd)
m_cdrom_handle.reset(new cdrom_file(chd));
else
m_cdrom_handle.reset(new cdrom_file(filename()));
if (!m_cdrom_handle)
goto error;
return std::make_pair(std::error_condition(), std::string());
error:
if (chd && chd == &m_self_chd)
m_self_chd.close();
return std::make_pair(err ? err : image_error::UNSPECIFIED, std::string());
}
void cdrom_image_device::call_unload()
{
assert(m_cdrom_handle);
m_cdrom_handle.reset();
if (m_self_chd.opened())
m_self_chd.close();
}

59
src/devices/imagedev/harddriv.cpp
View File

@ -107,11 +107,11 @@ void harddisk_image_device::device_start()
m_chd = nullptr;
// try to locate the CHD from a DISK_REGION
chd_file *handle = machine().rom_load().get_disk_handle(tag());
if (handle)
m_hard_disk_handle.reset(new hard_disk_file(handle));
else
if (has_preset_images()) {
set_image_tag();
set_user_loadable(false);
setup_current_preset_image();
} else
m_hard_disk_handle.reset();
}
@ -166,6 +166,12 @@ std::pair<std::error_condition, std::string> harddisk_image_device::call_create(
return std::make_pair(internal_load_hd(), std::string());
}
void harddisk_image_device::setup_current_preset_image()
{
chd_file *chd = current_preset_image_chd();
m_hard_disk_handle.reset(new hard_disk_file(chd));
}
void harddisk_image_device::call_unload()
{
// Check if there is an image_unload callback defined
@ -227,6 +233,12 @@ static std::error_condition open_disk_diff(emu_options &options, const char *nam
std::error_condition harddisk_image_device::internal_load_hd()
{
if (has_preset_images())
{
setup_current_preset_image();
return std::error_condition();
}
std::error_condition err;
m_chd = nullptr;
uint8_t header[64];
@ -325,3 +337,40 @@ std::error_condition harddisk_image_device::internal_load_hd()
else
return image_error::UNSPECIFIED;
}
const hard_disk_file::info &harddisk_image_device::get_info() const
{
return m_hard_disk_handle->get_info();
}
bool harddisk_image_device::read(uint32_t lbasector, void *buffer)
{
return m_hard_disk_handle->read(lbasector, buffer);
}
bool harddisk_image_device::write(uint32_t lbasector, const void *buffer)
{
return m_hard_disk_handle->write(lbasector, buffer);
}
bool harddisk_image_device::set_block_size(uint32_t blocksize)
{
return m_hard_disk_handle->set_block_size(blocksize);
}
std::error_condition harddisk_image_device::get_inquiry_data(std::vector<uint8_t> &data) const
{
return m_hard_disk_handle->get_inquiry_data(data);
}
std::error_condition harddisk_image_device::get_cis_data(std::vector<uint8_t> &data) const
{
return m_hard_disk_handle->get_cis_data(data);
}
std::error_condition harddisk_image_device::get_disk_key_data(std::vector<uint8_t> &data) const
{
return m_hard_disk_handle->get_disk_key_data(data);
}

12
src/devices/imagedev/harddriv.h
View File

@ -74,8 +74,15 @@ public:
virtual const char *file_extensions() const noexcept override { return "chd,hd,hdv,2mg,hdi"; }
virtual const util::option_guide &create_option_guide() const override;
// specific implementation
hard_disk_file *get_hard_disk_file() { return m_hard_disk_handle.get(); }
const hard_disk_file::info &get_info() const;
bool read(uint32_t lbasector, void *buffer);
bool write(uint32_t lbasector, const void *buffer);
bool set_block_size(uint32_t blocksize);
std::error_condition get_inquiry_data(std::vector<uint8_t> &data) const;
std::error_condition get_cis_data(std::vector<uint8_t> &data) const;
std::error_condition get_disk_key_data(std::vector<uint8_t> &data) const;
protected:
harddisk_image_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock);
@ -88,6 +95,7 @@ protected:
// device_image_interface implementation
virtual const software_list_loader &get_software_list_loader() const override { return rom_software_list_loader::instance(); }
void setup_current_preset_image();
std::error_condition internal_load_hd();
chd_file *m_chd;

31
src/devices/machine/akiko.cpp
View File

@ -84,8 +84,7 @@ akiko_device::akiko_device(const machine_config &mconfig, const char *tag, devic
, m_cdrom_cmd_end(0)
, m_cdrom_cmd_resp(0)
, m_cdda(*this, "^cdda")
, m_cddevice(*this, "^cdrom")
, m_cdrom(nullptr)
, m_cdrom(*this, "^cdrom")
, m_cdrom_toc(nullptr)
, m_dma_timer(nullptr)
, m_frame_timer(nullptr)
@ -153,18 +152,6 @@ void akiko_device::device_start()
void akiko_device::device_reset()
{
if (m_cddevice.found())
{
// CD32 case
m_cdrom = m_cddevice->get_cdrom_file();
}
else
{
// Arcade case
chd_file *chd = machine().rom_load().get_disk_handle(":cdrom");
m_cdrom = chd != nullptr ? new cdrom_file(chd) : nullptr;
}
/* create the TOC table */
if ( m_cdrom != nullptr && m_cdrom->get_last_track() )
{
@ -222,14 +209,6 @@ void akiko_device::device_reset()
void akiko_device::device_stop()
{
if (!m_cddevice.found())
{
if( m_cdrom )
{
delete m_cdrom;
m_cdrom = nullptr;
}
}
}
void akiko_device::nvram_write(uint32_t data)
@ -460,7 +439,7 @@ TIMER_CALLBACK_MEMBER(akiko_device::dma_proc)
uint8_t buf[2352];
int index;
if ( m_cdrom == nullptr )
if ( !m_cdrom->exists() )
return;
if ( (m_cdrom_dmacontrol & 0x04000000) == 0 )
@ -589,7 +568,7 @@ TIMER_CALLBACK_MEMBER( akiko_device::cd_delayed_cmd )
resp[0] = 0x06;
if ( m_cdrom == nullptr || m_cdrom_numtracks == 0 )
if ( !m_cdrom->exists() || m_cdrom_numtracks == 0 )
{
resp[1] = 0x80;
setup_response( 15, resp );
@ -665,7 +644,7 @@ void akiko_device::update_cdrom()
m_cdrom_cmd_start = (m_cdrom_cmd_start + 13) & 0xff;
if ( m_cdrom == nullptr || m_cdrom_numtracks == 0 )
if ( !m_cdrom->exists() || m_cdrom_numtracks == 0 )
{
resp[1] = 0x80;
setup_response( 2, resp );
@ -775,7 +754,7 @@ void akiko_device::update_cdrom()
m_cdrom_cmd_start = (m_cdrom_cmd_start + 2) & 0xff;
if ( m_cdrom == nullptr || m_cdrom_numtracks == 0 )
if ( !m_cdrom->exists() || m_cdrom_numtracks == 0 )
resp[1] = 0x80;
setup_response( 20, resp );

5
src/devices/machine/akiko.h
View File

@ -18,7 +18,7 @@
#pragma once
#include "cdrom.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "sound/cdda.h"
@ -84,8 +84,7 @@ private:
uint8_t m_cdrom_cmd_resp;
required_device<cdda_device> m_cdda;
optional_device<cdrom_image_device> m_cddevice;
cdrom_file *m_cdrom;
optional_device<cdrom_image_device> m_cdrom;
std::unique_ptr<uint8_t[]> m_cdrom_toc;

10
src/devices/machine/ataflash.cpp
View File

@ -20,9 +20,9 @@ void ata_flash_pccard_device::device_reset()
{
ide_hdd_device::device_reset();
if (m_disk)
if (m_image->exists())
{
m_disk->get_cis_data(m_cis);
m_image->get_cis_data(m_cis);
}
m_cis.resize(512, 0xff);
@ -135,7 +135,7 @@ void taito_pccard1_device::device_reset()
{
ata_flash_pccard_device::device_reset();
if (m_disk && !m_disk->get_disk_key_data(m_key) && m_key.size() == 5)
if (m_image->exists() && !m_image->get_disk_key_data(m_key) && m_key.size() == 5)
{
m_locked = 0x1ff;
}
@ -224,7 +224,7 @@ void taito_pccard2_device::device_reset()
{
ata_flash_pccard_device::device_reset();
if (m_disk && !m_disk->get_disk_key_data(m_key) && m_key.size() == 5)
if (m_image->exists() && !m_image->get_disk_key_data(m_key) && m_key.size() == 5)
{
m_locked = true;
}
@ -321,7 +321,7 @@ void taito_compact_flash_device::device_reset()
{
ata_flash_pccard_device::device_reset();
if (m_disk && !m_disk->get_disk_key_data(m_key) && m_key.size() == 5)
if (m_image->exists() && !m_image->get_disk_key_data(m_key) && m_key.size() == 5)
{
m_locked = true;
}

15
src/devices/machine/corvushd.cpp
View File

@ -419,7 +419,7 @@ bool corvus_hdc_device::parse_hdc_command(uint8_t data) {
// status: Command status
//
uint8_t corvus_hdc_device::corvus_write_sector(uint8_t drv, uint32_t sector, uint8_t *buffer, int len) {
hard_disk_file
harddisk_image_device
*disk; // Structures for interface to CHD routines
uint8_t tbuffer[512]; // Buffer to hold an entire sector
uint16_t cylinder; // Cylinder this sector resides on
@ -527,7 +527,7 @@ uint8_t corvus_hdc_device::corvus_write_logical_sector(dadr_t *dadr, uint8_t *bu
// status: Corvus status
//
uint8_t corvus_hdc_device::corvus_read_sector(uint8_t drv, uint32_t sector, uint8_t *buffer, int len) {
hard_disk_file
harddisk_image_device
*disk; // Structures for interface to CHD routines
uint8_t tbuffer[512]; // Buffer to store full sector results in
uint16_t cylinder;
@ -1090,15 +1090,15 @@ uint8_t corvus_hdc_device::corvus_format_drive(uint8_t *pattern, uint16_t len) {
//
// Corvus_HDC_File
//
// Returns a hard_disk_file object for a given virtual hard drive device in the concept
// Returns a harddisk_image_device object for a given virtual hard drive device in the concept
//
// Pass:
// drv: Corvus drive id (1..15)
//
// Returns:
// hard_disk_file object
// harddisk_image_device object
//
hard_disk_file *corvus_hdc_device::corvus_hdc_file(int drv) {
harddisk_image_device *corvus_hdc_device::corvus_hdc_file(int drv) {
static const char *const tags[] = {
"harddisk1", "harddisk2", "harddisk3", "harddisk4"
};
@ -1119,15 +1119,14 @@ hard_disk_file *corvus_hdc_device::corvus_hdc_file(int drv) {
return nullptr;
// Pick up the Head/Cylinder/Sector info
hard_disk_file *file = img->get_hard_disk_file();
const auto &info = file->get_info();
const auto &info = img->get_info();
m_sectors_per_track = info.sectors;
m_tracks_per_cylinder = info.heads;
m_cylinders_per_drive = info.cylinders;
LOG("corvus_hdc_file: Attached to drive %u image: H:%d, C:%d, S:%d\n", drv, info.heads, info.cylinders, info.sectors);
return file;
return img;
}

2
src/devices/machine/corvushd.h
View File

@ -364,7 +364,7 @@ private:
uint8_t corvus_read_firmware_block(uint8_t head, uint8_t sector);
uint8_t corvus_write_firmware_block(uint8_t head, uint8_t sector, uint8_t *buffer);
uint8_t corvus_format_drive(uint8_t *pattern, uint16_t len);
hard_disk_file *corvus_hdc_file(int id);
harddisk_image_device *corvus_hdc_file(int id);
void corvus_process_command_packet(bool local_invalid_command_flag);
corvus_cmd_t corvus_cmd[0xf5][0xc1]; // Command sizes and their return sizes

2
src/devices/machine/cr511b.h
View File

@ -35,7 +35,7 @@
#pragma once
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "sound/cdda.h"
class cr511b_device : public device_t

8
src/devices/machine/legscsi.cpp
View File

@ -116,13 +116,7 @@ uint8_t legacy_scsi_host_adapter::get_status()
scsihle_device *scsidev = get_device(m_selected);
if (scsidev != nullptr)
{
void *image;
scsidev->GetDevice(&image);
if (image != nullptr)
return 0x00;
return 0x02;
return scsidev->exists() ? 0x00 : 0x02;
}
else
{

32
src/devices/machine/spg290_cdservo.cpp
View File

@ -91,12 +91,8 @@ void spg290_cdservo_device::device_reset()
m_irq_cb(CLEAR_LINE);
// generate Q subchannel
if (m_cdrom.found())
{
auto *cdrom = m_cdrom->get_cdrom_file();
if (cdrom != nullptr)
generate_qsub(cdrom);
}
if (m_cdrom.found() && m_cdrom->exists())
generate_qsub();
change_status();
}
@ -109,7 +105,7 @@ TIMER_CALLBACK_MEMBER(spg290_cdservo_device::cd_update)
if (BIT(m_control0, 15)) // CDDA
{
m_cdrom->get_cdrom_file()->read_data(m_cur_sector - 150 - SPG290_LEADIN_LEN, cdbuf, cdrom_file::CD_TRACK_AUDIO);
m_cdrom->read_data(m_cur_sector - 150 - SPG290_LEADIN_LEN, cdbuf, cdrom_file::CD_TRACK_AUDIO);
for (int i=0; i<2352; i++)
{
@ -120,10 +116,10 @@ TIMER_CALLBACK_MEMBER(spg290_cdservo_device::cd_update)
}
else
{
m_cdrom->get_cdrom_file()->read_data(m_cur_sector - 150 - SPG290_LEADIN_LEN, cdbuf, cdrom_file::CD_TRACK_MODE1_RAW);
m_cdrom->read_data(m_cur_sector - 150 - SPG290_LEADIN_LEN, cdbuf, cdrom_file::CD_TRACK_MODE1_RAW);
// FIXME: this is required for load iso images
if (m_cdrom->get_cdrom_file()->get_track_type(m_qsub[m_cur_sector * 12 + 1] - 1) == cdrom_file::CD_TRACK_MODE1)
if (m_cdrom->get_track_type(m_qsub[m_cur_sector * 12 + 1] - 1) == cdrom_file::CD_TRACK_MODE1)
{
int lba = (bcd_2_dec(cdbuf[12]) * 60 + bcd_2_dec(cdbuf[13])) * 75 + bcd_2_dec(cdbuf[14]);
uint32_t msf = cdrom_file::lba_to_msf(lba + 150);
@ -332,7 +328,7 @@ void spg290_cdservo_device::servo_cmd_w()
void spg290_cdservo_device::change_status()
{
if (m_speed == 0 || !m_cdrom.found() || !m_cdrom->get_cdrom_file())
if (m_speed == 0 || !m_cdrom.found() || !m_cdrom->exists())
m_cdtimer->adjust(attotime::never);
else
m_cdtimer->adjust(attotime::from_hz(75 * m_speed), 0, attotime::from_hz(75 * m_speed));
@ -355,11 +351,11 @@ void spg290_cdservo_device::add_qsub(int sector, uint8_t addrctrl, uint8_t track
dest[11] = crc16;
}
void spg290_cdservo_device::generate_qsub(cdrom_file *cdrom)
void spg290_cdservo_device::generate_qsub()
{
const cdrom_file::toc &toc = cdrom->get_toc();
int numtracks = cdrom->get_last_track();
uint32_t total_sectors = cdrom->get_track_start(numtracks - 1) + toc.tracks[numtracks - 1].frames + 150;
const cdrom_file::toc &toc = m_cdrom->get_toc();
int numtracks = m_cdrom->get_last_track();
uint32_t total_sectors = m_cdrom->get_track_start(numtracks - 1) + toc.tracks[numtracks - 1].frames + 150;
m_tot_sectors = SPG290_LEADIN_LEN + total_sectors + SPG290_LEADOUT_LEN;
m_qsub = std::make_unique<uint8_t[]>(m_tot_sectors * 12);
@ -375,17 +371,17 @@ void spg290_cdservo_device::generate_qsub(cdrom_file *cdrom)
for(int track = 0; track < numtracks; track++)
{
uint32_t track_start = cdrom->get_track_start(track) + 150;
uint32_t track_start = m_cdrom->get_track_start(track) + 150;
if (lba < SPG290_LEADIN_LEN)
add_qsub(lba++, cdrom->get_adr_control(track), 0, dec_2_bcd(track + 1), cdrom_file::lba_to_msf(s + 3 + track), cdrom_file::lba_to_msf(track_start));
add_qsub(lba++, m_cdrom->get_adr_control(track), 0, dec_2_bcd(track + 1), cdrom_file::lba_to_msf(s + 3 + track), cdrom_file::lba_to_msf(track_start));
}
}
// data tracks
for(int track = 0; track < numtracks; track++)
{
uint32_t control = cdrom->get_adr_control(track);
uint32_t track_start = cdrom->get_track_start(track);
uint32_t control = m_cdrom->get_adr_control(track);
uint32_t track_start = m_cdrom->get_track_start(track);
// pregap
uint32_t pregap = toc.tracks[track].pregap;

4
src/devices/machine/spg290_cdservo.h
View File

@ -7,7 +7,7 @@
#pragma once
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
class spg290_cdservo_device : public device_t
@ -37,7 +37,7 @@ protected:
private:
void change_status();
void add_qsub(int sector, uint8_t addrctrl, uint8_t track, uint8_t index, uint32_t rel_msf, uint32_t abs_msf, uint16_t crc16=0);
void generate_qsub(cdrom_file *cdrom);
void generate_qsub();
void servo_cmd_r();
void servo_cmd_w();

16
src/devices/machine/spi_sdcard.cpp
View File

@ -49,7 +49,6 @@ spi_sdcard_device::spi_sdcard_device(const machine_config &mconfig, device_type
write_miso(*this),
m_image(*this, "image"),
m_state(SD_STATE_IDLE),
m_harddisk(nullptr),
m_ss(0), m_in_bit(0), m_clk_state(0),
m_in_latch(0), m_out_latch(0xff), m_cur_bit(0),
m_out_count(0), m_out_ptr(0), m_write_ptr(0), m_blksize(512), m_blknext(0),
@ -95,7 +94,6 @@ void spi_sdcard_device::device_start()
void spi_sdcard_device::device_reset()
{
m_harddisk = m_image->get_hard_disk_file();
}
void spi_sdcard_device::device_add_mconfig(machine_config &config)
@ -164,7 +162,7 @@ void spi_sdcard_device::latch_in()
if (m_write_ptr == (m_blksize + 2))
{
LOGMASKED(LOG_GENERAL, "writing LBA %x, data %02x %02x %02x %02x\n", m_blknext, m_data[0], m_data[1], m_data[2], m_data[3]);
if (m_harddisk->write(m_blknext, &m_data[0]))
if (m_image->write(m_blknext, &m_data[0]))
{
m_data[0] = DATA_RESPONSE_OK;
}
@ -183,7 +181,7 @@ void spi_sdcard_device::latch_in()
if (m_state == SD_STATE_DATA_MULTI && m_out_count == 0)
{
m_data[0] = 0xfe; // data token
m_harddisk->read(m_blknext++, &m_data[1]);
m_image->read(m_blknext++, &m_data[1]);
util::crc16_t crc16 = util::crc16_creator::simple(&m_data[1], m_blksize);
m_data[m_blksize + 1] = (crc16 >> 8) & 0xff;
m_data[m_blksize + 2] = (crc16 & 0xff);
@ -235,7 +233,7 @@ void spi_sdcard_device::do_command()
switch (m_cmd[0] & 0x3f)
{
case 0: // CMD0 - GO_IDLE_STATE
if (m_harddisk)
if (m_image->exists())
{
m_data[0] = 0x01;
send_data(1, SD_STATE_IDLE);
@ -309,7 +307,7 @@ void spi_sdcard_device::do_command()
case 16: // CMD16 - SET_BLOCKLEN
m_blksize = (u16(m_cmd[3]) << 8) | u16(m_cmd[4]);
if (m_harddisk && m_harddisk->set_block_size(m_blksize))
if (m_image->set_block_size(m_blksize))
{
m_data[0] = 0;
}
@ -324,7 +322,7 @@ void spi_sdcard_device::do_command()
break;
case 17: // CMD17 - READ_SINGLE_BLOCK
if (m_harddisk)
if (m_image->exists())
{
m_data[0] = 0x00; // initial R1 response
// data token occurs some time after the R1 response. A2SD expects at least 1
@ -337,7 +335,7 @@ void spi_sdcard_device::do_command()
blk /= m_blksize;
}
LOGMASKED(LOG_GENERAL, "reading LBA %x\n", blk);
m_harddisk->read(blk, &m_data[3]);
m_image->read(blk, &m_data[3]);
{
util::crc16_t crc16 = util::crc16_creator::simple(&m_data[3], m_blksize);
m_data[m_blksize + 3] = (crc16 >> 8) & 0xff;
@ -353,7 +351,7 @@ void spi_sdcard_device::do_command()
break;
case 18: // CMD18 - CMD_READ_MULTIPLE_BLOCK
if (m_harddisk)
if (m_image->exists())
{
m_data[0] = 0x00; // initial R1 response
// data token occurs some time after the R1 response. A2SD

3
src/devices/machine/spi_sdcard.h
View File

@ -16,7 +16,7 @@ public:
void spi_ss_w(int state) { m_ss = state; }
void spi_mosi_w(int state) { m_in_bit = state; }
bool get_card_present() { return !(m_harddisk == nullptr); }
bool get_card_present() { return m_image->exists(); }
devcb_write_line write_miso;
@ -70,7 +70,6 @@ private:
void shift_out();
u8 m_data[520], m_cmd[6];
hard_disk_file *m_harddisk;
int m_ss, m_in_bit, m_clk_state;
u8 m_in_latch, m_out_latch, m_cur_bit;

100
src/devices/machine/stvcd.cpp
View File

@ -478,12 +478,12 @@ int stvcd_device::get_track_index(uint32_t fad)
uint32_t rel_fad;
uint8_t track;
if(cdrom->get_track_type(cdrom->get_track(fad)) != cdrom_file::CD_TRACK_AUDIO)
if(m_cdrom_image->get_track_type(m_cdrom_image->get_track(fad)) != cdrom_file::CD_TRACK_AUDIO)
return 1;
track = cdrom->get_track( fad );
track = m_cdrom_image->get_track( fad );
rel_fad = fad - cdrom->get_track_start( track );
rel_fad = fad - m_cdrom_image->get_track_start( track );
if(rel_fad < 150)
return 0;
@ -491,14 +491,14 @@ int stvcd_device::get_track_index(uint32_t fad)
return 1;
}
int stvcd_device::sega_cdrom_get_adr_control(cdrom_file *file, int track)
int stvcd_device::sega_cdrom_get_adr_control(int track)
{
return bitswap<8>(file->get_adr_control(cur_track),3,2,1,0,7,6,5,4);
return bitswap<8>(m_cdrom_image->get_adr_control(cur_track),3,2,1,0,7,6,5,4);
}
void stvcd_device::cr_standard_return(uint16_t cur_status)
{
if (!cdrom)
if (!m_cdrom_image->exists())
{
cr1 = cur_status;
cr2 = 0;
@ -508,17 +508,17 @@ void stvcd_device::cr_standard_return(uint16_t cur_status)
else if ((cd_stat & 0x0f00) == CD_STAT_SEEK)
{
/* During seek state, values returned are from the target position */
uint8_t seek_track = cdrom->get_track(cd_fad_seek-150);
uint8_t seek_track = m_cdrom_image->get_track(cd_fad_seek-150);
cr1 = cur_status | (playtype << 7) | 0x00 | (cdda_repeat_count & 0xf);
cr2 = (seek_track == 0xff) ? 0xffff : ((sega_cdrom_get_adr_control(cdrom, seek_track)<<8) | seek_track);
cr2 = (seek_track == 0xff) ? 0xffff : ((sega_cdrom_get_adr_control(seek_track)<<8) | seek_track);
cr3 = (get_track_index(cd_fad_seek)<<8) | (cd_fad_seek>>16); //index & 0xff00
cr4 = cd_fad_seek;
}
else
{
cr1 = cur_status | (playtype << 7) | 0x00 | (cdda_repeat_count & 0xf); //options << 4 | repeat & 0xf
cr2 = (cur_track == 0xff) ? 0xffff : ((sega_cdrom_get_adr_control(cdrom, cur_track)<<8) | (cdrom->get_track(cd_curfad-150)+1));
cr2 = (cur_track == 0xff) ? 0xffff : ((sega_cdrom_get_adr_control(cur_track)<<8) | (m_cdrom_image->get_track(cd_curfad-150)+1));
cr3 = (get_track_index(cd_curfad)<<8) | (cd_curfad>>16); //index & 0xff00
cr4 = cd_curfad;
}
@ -768,7 +768,7 @@ void stvcd_device::cmd_play_disc()
cd_curfad = start_pos & 0xfffff;
logerror("fad mode\n");
cur_track = cdrom->get_track(cd_curfad-150);
cur_track = m_cdrom_image->get_track(cd_curfad-150);
}
else
{
@ -776,7 +776,7 @@ void stvcd_device::cmd_play_disc()
if(((start_pos)>>8) != 0)
{
cur_track = (start_pos)>>8;
cd_fad_seek = cdrom->get_track_start(cur_track-1);
cd_fad_seek = m_cdrom_image->get_track_start(cur_track-1);
cd_stat = CD_STAT_SEEK;
m_cdda->pause_audio(0);
}
@ -802,7 +802,7 @@ void stvcd_device::cmd_play_disc()
uint8_t end_track;
end_track = (end_pos)>>8;
fadstoplay = cdrom->get_track_start(end_track) - cd_fad_seek;
fadstoplay = m_cdrom_image->get_track_start(end_track) - cd_fad_seek;
}
}
else // play until the end of the disc
@ -818,9 +818,9 @@ void stvcd_device::cmd_play_disc()
else
{
if(end_pos == 0)
fadstoplay = (cdrom->get_track_start(0xaa)) - cd_curfad;
fadstoplay = (m_cdrom_image->get_track_start(0xaa)) - cd_curfad;
else
fadstoplay = (cdrom->get_track_start((end_pos & 0xff00) >> 8)) - cd_curfad;
fadstoplay = (m_cdrom_image->get_track_start((end_pos & 0xff00) >> 8)) - cd_curfad;
}
logerror("track mode %08x %08x\n",cd_curfad,fadstoplay);
}
@ -835,8 +835,8 @@ void stvcd_device::cmd_play_disc()
// be countless possible combinations ...
if(fadstoplay == 0)
{
cd_curfad = cdrom->get_track_start(cur_track-1);
fadstoplay = cdrom->get_track_start(cur_track) - cd_curfad;
cd_curfad = m_cdrom_image->get_track_start(cur_track-1);
fadstoplay = m_cdrom_image->get_track_start(cur_track) - cd_curfad;
}
logerror("track resume %08x %08x\n",cd_curfad,fadstoplay);
}
@ -852,7 +852,7 @@ void stvcd_device::cmd_play_disc()
playtype = 0;
// cdda
if(cdrom->get_track_type(cdrom->get_track(cd_curfad)) == cdrom_file::CD_TRACK_AUDIO)
if(m_cdrom_image->get_track_type(m_cdrom_image->get_track(cd_curfad)) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->pause_audio(0);
//m_cdda->start_audio(cd_curfad, fadstoplay);
@ -899,7 +899,7 @@ void stvcd_device::cmd_seek_disc()
{
cd_stat = CD_STAT_PAUSE;
cur_track = cr2>>8;
cd_curfad = cdrom->get_track_start(cur_track-1);
cd_curfad = m_cdrom_image->get_track_start(cur_track-1);
m_cdda->pause_audio(1);
// (index is cr2 low byte)
}
@ -960,12 +960,12 @@ void stvcd_device::cmd_get_subcode_q_rw_channel()
*/
msf_abs = cdrom_file::lba_to_msf_alt( cd_curfad - 150 );
track = cdrom->get_track( cd_curfad );
msf_rel = cdrom_file::lba_to_msf_alt( cd_curfad - 150 - cdrom->get_track_start( track ) );
track = m_cdrom_image->get_track( cd_curfad );
msf_rel = cdrom_file::lba_to_msf_alt( cd_curfad - 150 - m_cdrom_image->get_track_start( track ) );
xfertype = XFERTYPE_SUBQ;
xfercount = 0;
subqbuf[0] = 0x01 | ((cdrom->get_track_type(cdrom->get_track(track+1)) == cdrom_file::CD_TRACK_AUDIO) ? 0x00 : 0x40);
subqbuf[0] = 0x01 | ((m_cdrom_image->get_track_type(m_cdrom_image->get_track(track+1)) == cdrom_file::CD_TRACK_AUDIO) ? 0x00 : 0x40);
subqbuf[1] = dec_2_bcd(track+1);
subqbuf[2] = dec_2_bcd(get_track_index(cd_curfad));
subqbuf[3] = dec_2_bcd((msf_rel >> 16) & 0xff);
@ -1919,7 +1919,7 @@ void stvcd_device::cd_exec_command()
1)
logerror("Command exec %04x %04x %04x %04x %04x (stat %04x)\n", hirqreg, cr1, cr2, cr3, cr4, cd_stat);
if(!cdrom && ((cr1 >> 8) & 0xff) != 0x00) {
if(!m_cdrom_image->exists() && ((cr1 >> 8) & 0xff) != 0x00) {
hirqreg |= (CMOK);
return;
}
@ -2012,7 +2012,7 @@ TIMER_DEVICE_CALLBACK_MEMBER( stvcd_device::stv_sh1_sim )
TIMER_DEVICE_CALLBACK_MEMBER( stvcd_device::stv_sector_cb )
{
if(!cdrom)
if(!m_cdrom_image->exists())
return;
//m_sector_timer->reset();
@ -2021,7 +2021,7 @@ TIMER_DEVICE_CALLBACK_MEMBER( stvcd_device::stv_sector_cb )
cd_playdata();
if(cdrom->get_track_type(cdrom->get_track(cd_curfad)) == cdrom_file::CD_TRACK_AUDIO)
if(m_cdrom_image->get_track_type(m_cdrom_image->get_track(cd_curfad)) == cdrom_file::CD_TRACK_AUDIO)
m_sector_timer->adjust(attotime::from_hz(75)); // 75 sectors / second = 150kBytes/second (cdda track ignores cd_speed setting)
else
m_sector_timer->adjust(attotime::from_hz(75*cd_speed)); // 75 / 150 sectors / second = 150 / 300kBytes/second
@ -2088,11 +2088,9 @@ void stvcd_device::device_reset()
}
// open device
cdrom = m_cdrom_image->get_cdrom_file();
m_cdda->set_cdrom(m_cdrom_image);
m_cdda->set_cdrom(cdrom);
if (cdrom)
if (m_cdrom_image->exists())
{
LOG("Opened CD-ROM successfully, reading root directory\n");
read_new_dir(0xffffff); // read root directory
@ -2383,11 +2381,6 @@ void stvcd_device::make_dir_current(uint32_t fad)
void stvcd_device::device_stop()
{
curdir.clear();
if (cdrom)
{
cdrom = (cdrom_file *)nullptr;
}
}
void stvcd_device::cd_readTOC(void)
@ -2397,9 +2390,9 @@ void stvcd_device::cd_readTOC(void)
xfertype = XFERTYPE_TOC;
xfercount = 0;
if (cdrom)
if (m_cdrom_image->exists())
{
ntrks = cdrom->get_last_track();
ntrks = m_cdrom_image->get_last_track();
}
else
{
@ -2420,20 +2413,20 @@ void stvcd_device::cd_readTOC(void)
for (i = 0; i < ntrks; i++)
{
if (cdrom)
if (m_cdrom_image->exists())
{
//tocbuf[tocptr] = sega_cdrom_get_adr_control(cdrom, i);
//HACK: ddsom does not enter ingame with the line above!
tocbuf[tocptr] = cdrom->get_adr_control(i)<<4 | 0x01;
tocbuf[tocptr] = m_cdrom_image->get_adr_control(i)<<4 | 0x01;
}
else
{
tocbuf[tocptr] = 0xff;
}
if (cdrom)
if (m_cdrom_image->exists())
{
fad = cdrom->get_track_start(i) + 150;
fad = m_cdrom_image->get_track_start(i) + 150;
tocbuf[tocptr+1] = (fad>>16)&0xff;
tocbuf[tocptr+2] = (fad>>8)&0xff;
@ -2474,7 +2467,7 @@ void stvcd_device::cd_readTOC(void)
tocbuf[tocptr+7] = 0;
// get total disc length (start of lead-out)
fad = cdrom->get_track_start(0xaa) + 150;
fad = m_cdrom_image->get_track_start(0xaa) + 150;
tocbuf[tocptr+8] = tocbuf[0];
tocbuf[tocptr+9] = (fad>>16)&0xff;
@ -2645,20 +2638,20 @@ stvcd_device::partitionT *stvcd_device::cd_read_filtered_sector(int32_t fad, uin
if ((cddevice != nullptr) && (!buffull))
{
// find out the track's type
trktype = cdrom->get_track_type(cdrom->get_track(fad-150));
trktype = m_cdrom_image->get_track_type(m_cdrom_image->get_track(fad-150));
// now get a raw 2352 byte sector - if it's mode 1, get mode1_raw
if ((trktype == cdrom_file::CD_TRACK_MODE1) || (trktype == cdrom_file::CD_TRACK_MODE1_RAW))
{
cdrom->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_MODE1_RAW);
m_cdrom_image->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_MODE1_RAW);
}
else if (trktype != cdrom_file::CD_TRACK_AUDIO) // if not audio it must be mode 2 so get mode2_raw
{
cdrom->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_MODE2_RAW);
m_cdrom_image->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_MODE2_RAW);
}
else
{
cdrom->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_AUDIO);
m_cdrom_image->read_data(fad-150, curblock.data, cdrom_file::CD_TRACK_AUDIO);
}
curblock.size = sectlenin;
@ -2725,11 +2718,11 @@ void stvcd_device::cd_playdata()
{
logerror("STVCD: Reading FAD %d\n", cd_curfad);
if (cdrom)
if (m_cdrom_image->exists())
{
uint8_t p_ok;
if(cdrom->get_track_type(cdrom->get_track(cd_curfad)) != cdrom_file::CD_TRACK_AUDIO)
if(m_cdrom_image->get_track_type(m_cdrom_image->get_track(cd_curfad)) != cdrom_file::CD_TRACK_AUDIO)
{
cd_read_filtered_sector(cd_curfad,&p_ok);
m_cdda->stop_audio(); //stop any pending CD-DA
@ -2767,8 +2760,8 @@ void stvcd_device::cd_playdata()
if(cdda_repeat_count < 0xe)
cdda_repeat_count++;
cd_curfad = cdrom->get_track_start(cur_track-1) + 150;
fadstoplay = cdrom->get_track_start(cur_track) - cd_curfad;
cd_curfad = m_cdrom_image->get_track_start(cur_track-1) + 150;
fadstoplay = m_cdrom_image->get_track_start(cur_track) - cd_curfad;
}
}
}
@ -2780,9 +2773,9 @@ void stvcd_device::cd_playdata()
// loads a single sector off the CD, anywhere from FAD 150 on up
void stvcd_device::cd_readblock(uint32_t fad, uint8_t *dat)
{
if (cdrom)
if (m_cdrom_image->exists())
{
cdrom->read_data(fad-150, dat, cdrom_file::CD_TRACK_MODE1);
m_cdrom_image->read_data(fad-150, dat, cdrom_file::CD_TRACK_MODE1);
}
}
@ -2794,7 +2787,6 @@ void stvcd_device::set_tray_open()
hirqreg |= DCHG;
cd_stat = CD_STAT_OPEN;
cdrom = (cdrom_file *)nullptr;
tray_is_closed = 0;
popmessage("Tray Open");
@ -2807,11 +2799,9 @@ void stvcd_device::set_tray_close()
return;
hirqreg |= DCHG;
cdrom = m_cdrom_image->get_cdrom_file();
m_cdda->set_cdrom(m_cdrom_image);
m_cdda->set_cdrom(cdrom);
if (cdrom)
if (m_cdrom_image->exists())
{
LOG("Opened CD-ROM successfully, reading root directory\n");
//read_new_dir(0xffffff); // read root directory

6
src/devices/machine/stvcd.h
View File

@ -7,7 +7,7 @@
#pragma once
#include "cdrom.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/timer.h"
#include "sound/cdda.h"
@ -119,7 +119,7 @@ private:
};
int get_track_index(uint32_t fad);
int sega_cdrom_get_adr_control(cdrom_file *file, int track);
int sega_cdrom_get_adr_control(int track);
void cr_standard_return(uint16_t cur_status);
void mpeg_standard_return(uint16_t cur_status);
void cd_free_block(blockT *blktofree);
@ -139,8 +139,6 @@ private:
partitionT *cd_filterdata(filterT *flt, int trktype, uint8_t *p_ok);
partitionT *cd_read_filtered_sector(int32_t fad, uint8_t *p_ok);
cdrom_file *cdrom;// = (cdrom_file *)nullptr;
// local variables
partitionT partitions[MAX_FILTERS];
partitionT *transpart;

96
src/devices/machine/t10mmc.cpp
View File

@ -30,8 +30,7 @@ void t10mmc::t10_reset()
{
t10spc::t10_reset();
SetDevice( m_image->get_cdrom_file() );
if( !m_cdrom )
if( !m_image->exists() )
{
m_device->logerror( "T10MMC %s: no CD found!\n", m_image->tag() );
}
@ -72,7 +71,7 @@ t10mmc::toc_format_t t10mmc::toc_format()
int t10mmc::toc_tracks()
{
int start_track = command[6];
int end_track = m_cdrom->get_last_track();
int end_track = m_image->get_last_track();
if (start_track == 0)
{
@ -157,7 +156,7 @@ void t10mmc::ExecCommand()
break;
case T10SBC_CMD_READ_10:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -188,7 +187,7 @@ void t10mmc::ExecCommand()
break;
case T10MMC_CMD_READ_SUB_CHANNEL:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -204,7 +203,7 @@ void t10mmc::ExecCommand()
case T10MMC_CMD_READ_TOC_PMA_ATIP:
{
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -245,7 +244,7 @@ void t10mmc::ExecCommand()
break;
}
case T10MMC_CMD_PLAY_AUDIO_10:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -261,8 +260,8 @@ void t10mmc::ExecCommand()
// A request for LBA 0 will return something different depending on the type of media being played.
// For data and mixed media, LBA 0 is assigned to MSF 00:02:00 (= LBA 150).
// For audio media, LBA 0 is assigned to the actual starting address of track 1.
if (m_cdrom->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_cdrom->get_track_start(0);
if (m_image->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_image->get_track_start(0);
else
m_lba = 150;
}
@ -273,9 +272,9 @@ void t10mmc::ExecCommand()
//m_device->logerror("T10MMC: PLAY AUDIO(10) at LBA %x for %x blocks\n", m_lba, m_blocks);
trk = m_cdrom->get_track(m_lba);
trk = m_image->get_track(m_lba);
if (m_cdrom->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
if (m_image->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->start_audio(m_lba, m_blocks);
m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
@ -292,7 +291,7 @@ void t10mmc::ExecCommand()
break;
case T10MMC_CMD_PLAY_AUDIO_MSF:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -305,8 +304,8 @@ void t10mmc::ExecCommand()
if (m_lba == 0)
{
if (m_cdrom->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_cdrom->get_track_start(0);
if (m_image->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_image->get_track_start(0);
else
m_lba = 150;
}
@ -318,9 +317,9 @@ void t10mmc::ExecCommand()
//m_device->logerror("T10MMC: PLAY AUDIO MSF at LBA %x for %x blocks (MSF %i:%i:%i - %i:%i:%i)\n",
//m_lba, m_blocks, command[3], command[4], command[5], command[6], command[7], command[8]);
trk = m_cdrom->get_track(m_lba);
trk = m_image->get_track(m_lba);
if (m_cdrom->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
if (m_image->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->start_audio(m_lba, m_blocks);
m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
@ -337,7 +336,7 @@ void t10mmc::ExecCommand()
break;
case T10MMC_CMD_PLAY_AUDIO_TRACK_INDEX:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -362,7 +361,7 @@ void t10mmc::ExecCommand()
// be careful: tracks here are zero-based, but the SCSI command
// uses the real CD track number which is 1-based!
//m_device->logerror("T10MMC: PLAY AUDIO T/I: strk %d idx %d etrk %d idx %d frames %d\n", command[4], command[5], command[7], command[8], m_blocks);
int end_track = m_cdrom->get_last_track();
int end_track = m_image->get_last_track();
if (end_track > command[7])
end_track = command[7];
@ -377,11 +376,11 @@ void t10mmc::ExecCommand()
end_track = command[4];
}
m_lba = m_cdrom->get_track_start(command[4] - 1);
m_blocks = m_cdrom->get_track_start(end_track) - m_lba;
trk = m_cdrom->get_track(m_lba);
m_lba = m_image->get_track_start(command[4] - 1);
m_blocks = m_image->get_track_start(end_track) - m_lba;
trk = m_image->get_track(m_lba);
if (m_cdrom->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
if (m_image->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->start_audio(m_lba, m_blocks);
m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
@ -402,7 +401,7 @@ void t10mmc::ExecCommand()
break;
case T10MMC_CMD_PAUSE_RESUME:
if (m_cdrom)
if (m_image)
{
m_cdda->pause_audio((command[8] & 0x01) ^ 0x01);
}
@ -436,7 +435,7 @@ void t10mmc::ExecCommand()
break;
case T10MMC_CMD_PLAY_AUDIO_12:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -449,8 +448,8 @@ void t10mmc::ExecCommand()
if (m_lba == 0)
{
if (m_cdrom->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_cdrom->get_track_start(0);
if (m_image->get_track_type(0) == cdrom_file::CD_TRACK_AUDIO)
m_lba = m_image->get_track_start(0);
else
m_lba = 150;
}
@ -461,9 +460,9 @@ void t10mmc::ExecCommand()
//m_device->logerror("T10MMC: PLAY AUDIO(12) at LBA %x for %x blocks\n", m_lba, m_blocks);
trk = m_cdrom->get_track(m_lba);
trk = m_image->get_track(m_lba);
if (m_cdrom->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
if (m_image->get_track_type(trk) == cdrom_file::CD_TRACK_AUDIO)
{
m_cdda->start_audio(m_lba, m_blocks);
m_audio_sense = SCSI_SENSE_ASC_ASCQ_AUDIO_PLAY_OPERATION_IN_PROGRESS;
@ -480,7 +479,7 @@ void t10mmc::ExecCommand()
break;
case T10SBC_CMD_READ_12:
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -519,7 +518,7 @@ void t10mmc::ExecCommand()
case T10MMC_CMD_READ_CD:
{
if (m_cdrom == nullptr)
if (!m_image->exists())
{
m_phase = SCSI_PHASE_STATUS;
m_status_code = SCSI_STATUS_CODE_CHECK_CONDITION;
@ -534,8 +533,8 @@ void t10mmc::ExecCommand()
// m_device->logerror("T10MMC: READ CD start_lba[%08x] block_len[%06x] %02x %02x %02x %02x\n", m_lba, m_blocks, command[1], command[9], command[10], command[11]);
auto expected_sector_type = BIT(command[1], 2, 3);
auto trk = m_cdrom->get_track(m_lba);
auto track_type = m_cdrom->get_track_type(trk);
auto trk = m_image->get_track(m_lba);
auto track_type = m_image->get_track_type(trk);
if (expected_sector_type != 0)
{
m_device->logerror("T10MMC: READ CD requested a sector type of %d which is unhandled\n", expected_sector_type);
@ -616,7 +615,7 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
case T10SBC_CMD_READ_CAPACITY:
m_device->logerror("T10MMC: READ CAPACITY\n");
temp = m_cdrom->get_track_start(0xaa);
temp = m_image->get_track_start(0xaa);
temp--; // return the last used block on the disc
data[0] = (temp>>24) & 0xff;
@ -633,11 +632,11 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
case T10SBC_CMD_READ_12:
case T10MMC_CMD_READ_CD: // TODO: Will need its own logic once more support is implemented
//m_device->logerror("T10MMC: read %x dataLength lba=%x\n", dataLength, m_lba);
if ((m_cdrom) && (m_blocks))
if ((m_image) && (m_blocks))
{
while (dataLength > 0)
{
if (!m_cdrom->read_data(m_lba, tmp_buffer, cdrom_file::CD_TRACK_MODE1))
if (!m_image->read_data(m_lba, tmp_buffer, cdrom_file::CD_TRACK_MODE1))
{
m_device->logerror("T10MMC: CD read error! (%08x)\n", m_lba);
return;
@ -668,7 +667,7 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
{
case 1: // return current position
{
if (!m_cdrom)
if (!m_image)
{
return;
}
@ -713,7 +712,7 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
data[3] = 12; // data length
data[4] = 0x01; // sub-channel format code
data[5] = 0x10 | (audio_active ? 0 : 4);
data[6] = m_cdrom->get_track(m_last_lba) + 1; // track
data[6] = m_image->get_track(m_last_lba) + 1; // track
data[7] = 0; // index
uint32_t frame = m_last_lba;
@ -728,7 +727,7 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
data[10] = (frame>>8)&0xff;
data[11] = frame&0xff;
frame = m_last_lba - m_cdrom->get_track_start(data[6] - 1);
frame = m_last_lba - m_image->get_track_start(data[6] - 1);
if (msf)
{
@ -776,7 +775,7 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
data[dptr++] = (len>>8) & 0xff;
data[dptr++] = (len & 0xff);
data[dptr++] = 1;
data[dptr++] = m_cdrom->get_last_track();
data[dptr++] = m_image->get_last_track();
int first_track = command[6];
if (first_track == 0)
@ -800,11 +799,11 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
}
data[dptr++] = 0;
data[dptr++] = m_cdrom->get_adr_control(cdrom_track);
data[dptr++] = m_image->get_adr_control(cdrom_track);
data[dptr++] = track;
data[dptr++] = 0;
uint32_t tstart = m_cdrom->get_track_start(cdrom_track);
uint32_t tstart = m_image->get_track_start(cdrom_track);
if (msf)
{
@ -830,11 +829,11 @@ void t10mmc::ReadData( uint8_t *data, int dataLength )
data[dptr++] = 1;
data[dptr++] = 0;
data[dptr++] = m_cdrom->get_adr_control(0);
data[dptr++] = m_image->get_adr_control(0);
data[dptr++] = 1;
data[dptr++] = 0;
uint32_t tstart = m_cdrom->get_track_start(0);
uint32_t tstart = m_image->get_track_start(0);
if (msf)
{
@ -969,14 +968,3 @@ void t10mmc::WriteData( uint8_t *data, int dataLength )
break;
}
}
void t10mmc::GetDevice( void **_cdrom )
{
*(cdrom_file **)_cdrom = m_cdrom;
}
void t10mmc::SetDevice( void *_cdrom )
{
m_cdrom = (cdrom_file *)_cdrom;
m_cdda->set_cdrom(m_cdrom);
}

7
src/devices/machine/t10mmc.h
View File

@ -12,19 +12,17 @@ t10mmc.h
#pragma once
#include "t10spc.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "sound/cdda.h"
class t10mmc : public virtual t10spc
{
public:
t10mmc()
: t10spc(), m_image(nullptr), m_cdda(nullptr), m_cdrom(nullptr), m_lba(0), m_blocks(0), m_last_lba(0), m_num_subblocks(0), m_cur_subblock(0), m_audio_sense(0), m_device(nullptr)
: t10spc(), m_image(nullptr), m_cdda(nullptr), m_lba(0), m_blocks(0), m_last_lba(0), m_num_subblocks(0), m_cur_subblock(0), m_audio_sense(0), m_device(nullptr)
{
}
virtual void SetDevice( void *device ) override;
virtual void GetDevice( void **device ) override;
virtual void ExecCommand() override;
virtual void WriteData( uint8_t *data, int dataLength ) override;
virtual void ReadData( uint8_t *data, int dataLength ) override;
@ -59,7 +57,6 @@ protected:
cdrom_image_device *m_image;
cdda_device *m_cdda;
cdrom_file *m_cdrom;
uint32_t m_lba;
uint32_t m_blocks;

33
src/devices/machine/t10sbc.cpp
View File

@ -20,15 +20,14 @@ void t10sbc::t10_reset()
m_blocks = 0;
m_sector_bytes = 512;
m_disk = m_image->get_hard_disk_file();
if (!m_disk)
if (!m_image->exists())
{
m_device->logerror("T10SBC %s: no HD found!\n", m_image->owner()->tag());
}
else
{
// get hard disk sector size from CHD metadata
m_sector_bytes = m_disk->get_info().sectorbytes;
m_sector_bytes = m_image->get_info().sectorbytes;
}
}
@ -141,7 +140,7 @@ void t10sbc::ExecCommand()
void t10sbc::ReadData( uint8_t *data, int dataLength )
{
// if we're a drive without a disk, return all zeroes
if (!m_disk)
if (!m_image->exists())
{
memset(data, 0, dataLength);
return;
@ -272,12 +271,12 @@ void t10sbc::ReadData( uint8_t *data, int dataLength )
case T10SBC_CMD_READ_6:
case T10SBC_CMD_READ_10:
case T10SBC_CMD_READ_12:
if ((m_disk) && (m_blocks))
if (m_image->exists() && (m_blocks))
{
m_device->logerror("T10SBC: Reading %d bytes from HD\n", dataLength);
while (dataLength > 0)
{
if (!m_disk->read(m_lba, data))
if (!m_image->read(m_lba, data))
{
m_device->logerror("T10SBC: HD read error!\n");
}
@ -302,7 +301,7 @@ void t10sbc::ReadData( uint8_t *data, int dataLength )
void t10sbc::WriteData( uint8_t *data, int dataLength )
{
if (!m_disk)
if (!m_image->exists())
{
return;
}
@ -314,12 +313,12 @@ void t10sbc::WriteData( uint8_t *data, int dataLength )
case T10SBC_CMD_WRITE_6:
case T10SBC_CMD_WRITE_10:
if ((m_disk) && (m_blocks))
if (m_image->exists() && (m_blocks))
{
m_device->logerror("T10SBC: Writing %d bytes to HD\n", dataLength);
while (dataLength > 0)
{
if (!m_disk->write(m_lba, data))
if (!m_image->write(m_lba, data))
{
m_device->logerror("T10SBC: HD write error!\n");
}
@ -337,19 +336,9 @@ void t10sbc::WriteData( uint8_t *data, int dataLength )
}
}
void t10sbc::GetDevice( void **_disk )
{
*(hard_disk_file **)_disk = m_disk;
}
void t10sbc::SetDevice( void *_disk )
{
m_disk = (hard_disk_file *)_disk;
}
void t10sbc::GetFormatPage( format_page_t *page )
{
const auto &info = m_disk->get_info();
const auto &info = m_image->get_info();
memset(page, 0, sizeof(format_page_t));
page->m_page_code = 0x03;
@ -363,7 +352,7 @@ void t10sbc::GetFormatPage( format_page_t *page )
void t10sbc::GetGeometryPage( geometry_page_t *page )
{
const auto &info = m_disk->get_info();
const auto &info = m_image->get_info();
memset(page, 0, sizeof(geometry_page_t));
page->m_page_code = 0x04;
@ -378,7 +367,7 @@ void t10sbc::GetGeometryPage( geometry_page_t *page )
void t10sbc::ReadCapacity( uint8_t *data )
{
const auto &info = m_disk->get_info();
const auto &info = m_image->get_info();
// get # of sectors
uint32_t temp = info.cylinders * info.heads * info.sectors - 1;

5
src/devices/machine/t10sbc.h
View File

@ -18,12 +18,10 @@ class t10sbc : public virtual t10spc
{
public:
t10sbc()
: t10spc(), m_image(nullptr), m_lba(0), m_blocks(0), m_disk(nullptr), m_device(nullptr)
: t10spc(), m_image(nullptr), m_lba(0), m_blocks(0), m_device(nullptr)
{
}
virtual void SetDevice( void *device ) override;
virtual void GetDevice( void **device ) override;
virtual void ExecCommand() override;
virtual void WriteData( uint8_t *data, int dataLength ) override;
virtual void ReadData( uint8_t *data, int dataLength ) override;
@ -94,7 +92,6 @@ protected:
uint32_t m_lba;
uint32_t m_blocks;
hard_disk_file *m_disk;
device_t *m_device;
};

2
src/devices/machine/t10spc.h
View File

@ -20,8 +20,6 @@ public:
}
virtual ~t10spc() { }
virtual void SetDevice( void *device ) = 0;
virtual void GetDevice( void **device ) = 0;
virtual void SetCommand( uint8_t *command, int commandLength );
virtual void ExecCommand();

8
src/devices/machine/wd1000.cpp
View File

@ -238,7 +238,7 @@ void wd1000_device::end_command()
int wd1000_device::get_lbasector()
{
hard_disk_file *file = m_drives[drive()]->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()];
const auto &info = file->get_info();
int lbasector;
@ -573,7 +573,7 @@ void wd1000_device::cmd_restore()
// so it is not necessary to guard that case in these functions.
void wd1000_device::cmd_read_sector()
{
hard_disk_file *file = m_drives[drive()]->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()];
uint8_t dma = BIT(m_command, 3);
file->read(get_lbasector(), m_buffer);
@ -594,7 +594,7 @@ void wd1000_device::cmd_read_sector()
void wd1000_device::cmd_write_sector()
{
hard_disk_file *file = m_drives[drive()]->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()];
if (m_buffer_index != sector_bytes())
{
@ -608,7 +608,7 @@ void wd1000_device::cmd_write_sector()
void wd1000_device::cmd_format_sector()
{
hard_disk_file *file = m_drives[drive()]->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()];
uint8_t buffer[512];
// The m_buffer appears to be loaded with an interleave table which is

6
src/devices/machine/wd1010.cpp
View File

@ -305,7 +305,7 @@ void wd1010_device::end_command()
int wd1010_device::get_lbasector()
{
hard_disk_file *file = m_drives[drive()].drive->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()].drive;
const auto &info = file->get_info();
int lbasector;
@ -537,7 +537,7 @@ void wd1010_device::cmd_read_sector()
}
}
hard_disk_file *file = m_drives[drive()].drive->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()].drive;
const auto &info = file->get_info();
// verify that we can read
@ -605,7 +605,7 @@ void wd1010_device::cmd_write_sector()
return;
}
hard_disk_file *file = m_drives[drive()].drive->get_hard_disk_file();
harddisk_image_device *file = m_drives[drive()].drive;
uint8_t buffer[512];
set_bdrq(0);

4
src/devices/sound/cdda.cpp
View File

@ -58,9 +58,9 @@ void cdda_device::device_start()
given CDDA stream
-------------------------------------------------*/
void cdda_device::set_cdrom(void *file)
void cdda_device::set_cdrom(cdrom_image_device *file)
{
m_disc = (cdrom_file *)file;
m_disc = file;
}

6
src/devices/sound/cdda.h
View File

@ -5,7 +5,7 @@
#pragma once
#include "cdrom.h"
#include "imagedev/cdromimg.h"
class cdda_device : public device_t, public device_sound_interface
@ -13,7 +13,7 @@ class cdda_device : public device_t, public device_sound_interface
public:
cdda_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock = 44'100);
void set_cdrom(void *file);
void set_cdrom(cdrom_image_device *file);
void start_audio(uint32_t startlba, uint32_t numblocks);
void stop_audio();
@ -37,7 +37,7 @@ protected:
private:
void get_audio_data(write_stream_view &bufL, write_stream_view &bufR);
cdrom_file * m_disc;
cdrom_image_device * m_disc;
// internal state
sound_stream * m_stream;

154
src/emu/diimage.cpp
View File

@ -67,7 +67,10 @@ device_image_interface::device_image_interface(const machine_config &mconfig, de
: device_interface(device, "image")
, m_file()
, m_mame_file()
, m_default_region(-1)
, m_current_region(-1)
, m_software_part_ptr(nullptr)
, m_sequence_counter(0)
, m_readonly(false)
, m_created(false)
, m_create_format(0)
@ -88,6 +91,17 @@ device_image_interface::~device_image_interface()
{
}
//-------------------------------------------------
// add_region - register a region that may
// have a chd image
//-------------------------------------------------
void device_image_interface::add_region(std::string name, bool is_default)
{
if (is_default)
m_default_region = m_possible_preset_regions.size();
m_possible_preset_regions.push_back(name);
}
//-------------------------------------------------
// interface_config_complete - perform any
@ -101,6 +115,128 @@ void device_image_interface::interface_config_complete()
update_names();
}
//-------------------------------------------------
// interface_pre_start - lookup the chds, if any
//-------------------------------------------------
void device_image_interface::interface_pre_start()
{
if (!m_possible_preset_regions.empty())
{
for(const auto &r : m_possible_preset_regions)
m_preset_images.push_back(device().machine().rom_load().get_disk_handle(":" + r));
if (m_default_region != -1 && m_preset_images[m_default_region])
m_current_region = m_default_region;
else
{
for (m_current_region = 0; m_current_region != int(m_preset_images.size()) && !m_preset_images[m_current_region]; m_current_region++);
if (m_current_region == int(m_preset_images.size()))
fatalerror("%s: No configured region has an image\n", device().tag());
}
}
else
{
std::string tag = device().tag();
auto *chd = device().machine().rom_load().get_disk_handle(tag);
if (chd)
{
m_possible_preset_regions.push_back(tag);
m_preset_images.push_back(chd);
m_current_region = 0;
}
}
}
//-------------------------------------------------
// has_preset_images - does the device have an
// image to retrieve through current_image_*
//-------------------------------------------------
bool device_image_interface::has_preset_images() const
{
return !m_possible_preset_regions.empty();
}
//-------------------------------------------------
// has_preset_images - does the device have
// multiple preset images with user selection
//-------------------------------------------------
bool device_image_interface::has_preset_images_selection() const
{
int icount = 0;
for (const auto *f : m_preset_images)
if (f)
icount ++;
return icount > 1;
}
//-------------------------------------------------
// preset_images_list -- generate the list of
// available image names
//-------------------------------------------------
std::vector<std::string> device_image_interface::preset_images_list() const
{
std::vector<std::string> result;
for (unsigned int i = 0; i != m_preset_images.size(); i++)
if (m_preset_images[i])
result.push_back(m_possible_preset_regions[i]);
return result;
}
//-------------------------------------------------
// current_preset_image_id -- current image id,
// recomputed to ignore non-present images.
// returns -1 if not in preset mode
//-------------------------------------------------
int device_image_interface::current_preset_image_id() const
{
if (m_current_region == -1)
return -1;
int id = 0;
for (int i = 0; i != m_current_region; i++)
if (m_preset_images[i])
id++;
return id;
}
//-------------------------------------------------
// current_preset_image_chd -- return the chd of
// the current active image, nullptr if non
//-------------------------------------------------
chd_file *device_image_interface::current_preset_image_chd() const
{
if (m_current_region == -1)
return nullptr;
return m_preset_images[m_current_region];
}
//-------------------------------------------------
// switch_preset_image -- change of preset image
//-------------------------------------------------
void device_image_interface::switch_preset_image(int id)
{
for (unsigned int i = 0; i != m_preset_images.size(); i++)
if (m_preset_images[i])
{
if(!id)
{
call_unload();
m_current_region = i;
call_load();
break;
}
id--;
}
return;
}
//-------------------------------------------------
// set_image_filename - specifies the filename of
@ -130,6 +266,20 @@ void device_image_interface::set_image_filename(std::string_view filename)
m_filetype = core_filename_extract_extension(m_basename, true);
}
//-------------------------------------------------
// set_image_tag - specifies the filename of
// an image as the device tag
//-------------------------------------------------
void device_image_interface::set_image_tag()
{
m_image_name = device().owner()->tag();
m_working_directory = "";
m_basename = "";
m_basename_noext = "";
m_filetype = "";
}
//-------------------------------------------------
// is_filetype - check if the filetype matches
@ -665,6 +815,7 @@ std::pair<std::error_condition, std::string> device_image_interface::load_intern
// we are now loading
m_is_loading = true;
m_sequence_counter ++;
// record the filename
set_image_filename(path);
@ -894,6 +1045,8 @@ void device_image_interface::clear() noexcept
m_software_list_name.clear();
m_hash.reset();
m_sequence_counter ++;
}
@ -905,6 +1058,7 @@ void device_image_interface::unload()
{
if (is_loaded() || loaded_through_softlist())
{
m_sequence_counter ++;
call_unload();
}
clear();

18
src/emu/diimage.h
View File

@ -94,6 +94,15 @@ public:
virtual const char *image_type_name() const noexcept = 0;
virtual const char *image_brief_type_name() const noexcept = 0;
// Set block device image regions for arcade systems
void add_region(std::string name, bool is_default = false);
bool has_preset_images() const;
bool has_preset_images_selection() const;
std::vector<std::string> preset_images_list() const;
int current_preset_image_id() const;
void switch_preset_image(int id);
chd_file *current_preset_image_chd() const;
const image_device_format *device_get_indexed_creatable_format(int index) const noexcept { return (index < m_formatlist.size()) ? m_formatlist.at(index).get() : nullptr; }
const image_device_format *device_get_named_creatable_format(std::string_view format_name) const noexcept;
const util::option_guide &device_get_creation_option_guide() const { return create_option_guide(); }
@ -110,6 +119,7 @@ public:
bool is_open() const noexcept { return bool(m_file); }
util::core_file &image_core_file() const noexcept { assert(is_open()); return *m_file; }
bool is_readonly() const noexcept { return m_readonly; }
u32 sequence_counter() const { return m_sequence_counter; } // Increments on media load/unload/etc
// image file I/O wrappers
// TODO: move away from using these and let implementations use the I/O interface directly
@ -211,6 +221,7 @@ public:
protected:
// interface-level overrides
virtual void interface_config_complete() override;
virtual void interface_pre_start() override;
virtual const software_list_loader &get_software_list_loader() const;
virtual bool use_software_list_file_extension_for_filetype() const noexcept { return false; }
@ -221,6 +232,7 @@ protected:
bool is_loaded() const noexcept { return m_file != nullptr; }
void set_image_filename(std::string_view filename);
void set_image_tag();
void check_for_file() const { if (!m_file) throw emu_fatalerror("%s(%s): Illegal operation on unmounted image", device().shortname(), device().tag()); }
@ -243,6 +255,11 @@ private:
std::string m_basename_noext;
std::string m_filetype;
// preset images regions
std::vector<std::string> m_possible_preset_regions;
std::vector<chd_file *> m_preset_images;
int m_default_region, m_current_region;
// Software information
std::string m_full_software_name;
const software_part *m_software_part_ptr;
@ -266,6 +283,7 @@ private:
std::string m_working_directory;
// flags
u32 m_sequence_counter;
bool m_readonly;
bool m_created;

25
src/frontend/mame/ui/filemngr.cpp
View File

@ -17,6 +17,7 @@
#include "ui/filesel.h"
#include "ui/floppycntrl.h"
#include "ui/imgcntrl.h"
#include "ui/prscntrl.h"
#include "ui/miscmenu.h"
#include "ui/ui.h"
@ -136,6 +137,16 @@ void menu_file_manager::populate()
// if so, cycle through all its image interfaces
for (device_image_interface &scan : subiter)
{
if (scan.has_preset_images_selection())
{
if (devtags.insert(scan.device().tag()).second)
{
item_append(string_format(_("[root%1$s]"), scan.device().owner()->tag()), FLAG_UI_HEADING | FLAG_DISABLE, nullptr);
item_append(scan.image_type_name(), scan.preset_images_list()[scan.current_preset_image_id()], 0, (void *)&scan);
}
continue;
}
if (!scan.user_loadable())
continue;
@ -198,11 +209,17 @@ bool menu_file_manager::handle(event const *ev)
if (selected_device && (IPT_UI_SELECT == ev->iptkey))
{
floppy_image_device *floppy_device = dynamic_cast<floppy_image_device *>(selected_device);
if (floppy_device)
menu::stack_push<menu_control_floppy_image>(ui(), container(), *floppy_device);
if (selected_device->has_preset_images_selection())
menu::stack_push<menu_control_device_preset>(ui(), container(), *selected_device);
else
menu::stack_push<menu_control_device_image>(ui(), container(), *selected_device);
{
floppy_image_device *floppy_device = dynamic_cast<floppy_image_device *>(selected_device);
if (floppy_device)
menu::stack_push<menu_control_floppy_image>(ui(), container(), *floppy_device);
else
menu::stack_push<menu_control_device_image>(ui(), container(), *selected_device);
}
// reset the existing menu
reset(reset_options::REMEMBER_POSITION);

3
src/frontend/mame/ui/info.cpp
View File

@ -659,6 +659,9 @@ bool menu_image_info::handle(event const *ev)
void menu_image_info::image_info(device_image_interface *image)
{
if (!image->user_loadable())
return;
if (image->exists())
{
// display device type and filename

69
src/frontend/mame/ui/prscntrl.cpp Normal file
View File

@ -0,0 +1,69 @@
// license:BSD-3-Clause
// copyright-holders:Nathan Woods
/***************************************************************************
ui/prscntrl.cpp
MAME's clunky built-in preset selection in a fixed list
***************************************************************************/
#include "emu.h"
#include "ui/prscntrl.h"
#include "ui/ui.h"
namespace ui {
/***************************************************************************
IMPLEMENTATION
***************************************************************************/
//-------------------------------------------------
// ctor
//-------------------------------------------------
menu_control_device_preset::menu_control_device_preset(mame_ui_manager &mui, render_container &container, device_image_interface &image)
: menu(mui, container)
, m_image(image)
{
}
//-------------------------------------------------
// dtor
//-------------------------------------------------
menu_control_device_preset::~menu_control_device_preset()
{
}
//-------------------------------------------------
// populate
//-------------------------------------------------
void menu_control_device_preset::populate()
{
auto presets = m_image.preset_images_list();
for(int i = 0; i != int(presets.size()); i++)
item_append(presets[i], 0, reinterpret_cast<void *>(i));
set_selection(reinterpret_cast<void *>(m_image.current_preset_image_id()));
}
//-------------------------------------------------
// handle
//-------------------------------------------------
bool menu_control_device_preset::handle(event const *ev)
{
if (ev && (ev->iptkey == IPT_UI_SELECT)) {
int id = reinterpret_cast<uintptr_t>(ev->itemref);
m_image.switch_preset_image(id);
stack_pop();
}
return false;
}
} // namespace ui

45
src/frontend/mame/ui/prscntrl.h Normal file
View File

@ -0,0 +1,45 @@
// license:BSD-3-Clause
// copyright-holders:Nathan Woods
/***************************************************************************
ui/prscntrl.h
MAME's clunky built-in preset selection in a fixed list
***************************************************************************/
#ifndef MAME_FRONTEND_UI_PRESETCNTRL_H
#define MAME_FRONTEND_UI_PRESETCNTRL_H
#pragma once
#include "ui/filesel.h"
#include "ui/menu.h"
#include "ui/swlist.h"
namespace ui {
// ======================> menu_control_device_preset
class menu_control_device_preset : public menu
{
public:
menu_control_device_preset(mame_ui_manager &mui, render_container &container, device_image_interface &image);
virtual ~menu_control_device_preset() override;
protected:
// methods
virtual bool handle(event const *ev) override;
private:
// instance variables
device_image_interface & m_image;
// methods
virtual void populate() override;
};
} // namespace ui
#endif // MAME_FRONTEND_UI_PRESETCNTRL_H

42
src/lib/util/chd.cpp
View File

@ -133,7 +133,7 @@ struct chd_file::metadata_hash
// a byte buffer
//-------------------------------------------------
inline uint64_t chd_file::be_read(const uint8_t *base, int numbytes)
inline uint64_t chd_file::be_read(const uint8_t *base, int numbytes) const
{
uint64_t result = 0;
while (numbytes--)
@ -163,7 +163,7 @@ inline void chd_file::be_write(uint8_t *base, uint64_t value, int numbytes)
// stream in bigendian order
//-------------------------------------------------
inline util::sha1_t chd_file::be_read_sha1(const uint8_t *base)
inline util::sha1_t chd_file::be_read_sha1(const uint8_t *base)const
{
util::sha1_t result;
memcpy(&result.m_raw[0], base, sizeof(result.m_raw));
@ -187,7 +187,7 @@ inline void chd_file::be_write_sha1(uint8_t *base, util::sha1_t value)
// offset; on failure throw an error
//-------------------------------------------------
inline void chd_file::file_read(uint64_t offset, void *dest, uint32_t length)
inline void chd_file::file_read(uint64_t offset, void *dest, uint32_t length) const
{
// no file = failure
if (!m_file)
@ -2637,7 +2637,7 @@ void chd_file::hunk_copy_from_parent(uint32_t hunknum, uint64_t parentunit)
* @return true if it succeeds, false if it fails.
*/
bool chd_file::metadata_find(chd_metadata_tag metatag, int32_t metaindex, metadata_entry &metaentry, bool resume)
bool chd_file::metadata_find(chd_metadata_tag metatag, int32_t metaindex, metadata_entry &metaentry, bool resume) const
{
// start at the beginning unless we're resuming a previous search
if (!resume)
@ -3302,3 +3302,37 @@ void chd_file_compressor::hashmap::add(uint64_t itemnum, util::crc16_t crc16, ut
entry->m_next = m_map[crc16];
m_map[crc16] = entry;
}
bool chd_file::is_hd() const
{
metadata_entry metaentry;
return metadata_find(HARD_DISK_METADATA_TAG, 0, metaentry);
}
bool chd_file::is_cd() const
{
metadata_entry metaentry;
return metadata_find(CDROM_OLD_METADATA_TAG, 0, metaentry)
|| metadata_find(CDROM_TRACK_METADATA_TAG, 0, metaentry)
|| metadata_find(CDROM_TRACK_METADATA2_TAG, 0, metaentry);
}
bool chd_file::is_gd() const
{
metadata_entry metaentry;
return metadata_find(GDROM_OLD_METADATA_TAG, 0, metaentry)
|| metadata_find(GDROM_TRACK_METADATA_TAG, 0, metaentry);
}
bool chd_file::is_dvd() const
{
metadata_entry metaentry;
return metadata_find(DVD_METADATA_TAG, 0, metaentry);
}
bool chd_file::is_av() const
{
metadata_entry metaentry;
return metadata_find(AV_METADATA_TAG, 0, metaentry);
}

18
src/lib/util/chd.h
View File

@ -231,6 +231,9 @@ constexpr chd_metadata_tag GDROM_OLD_METADATA_TAG = CHD_MAKE_TAG('C','H','G','T'
constexpr chd_metadata_tag GDROM_TRACK_METADATA_TAG = CHD_MAKE_TAG('C', 'H', 'G', 'D');
extern const char *GDROM_TRACK_METADATA_FORMAT;
// standard DVD metafata
constexpr chd_metadata_tag DVD_METADATA_TAG = CHD_MAKE_TAG('D', 'V', 'D', ' ');
// standard A/V metadata
constexpr chd_metadata_tag AV_METADATA_TAG = CHD_MAKE_TAG('A','V','A','V');
extern const char *AV_METADATA_FORMAT;
@ -352,16 +355,23 @@ public:
// codec interfaces
std::error_condition codec_configure(chd_codec_type codec, int param, void *config);
// typing
bool is_hd() const;
bool is_cd() const;
bool is_gd() const;
bool is_dvd() const;
bool is_av() const;
private:
struct metadata_entry;
struct metadata_hash;
// inline helpers
uint64_t be_read(const uint8_t *base, int numbytes);
uint64_t be_read(const uint8_t *base, int numbytes) const;
void be_write(uint8_t *base, uint64_t value, int numbytes);
util::sha1_t be_read_sha1(const uint8_t *base);
util::sha1_t be_read_sha1(const uint8_t *base) const;
void be_write_sha1(uint8_t *base, util::sha1_t value);
void file_read(uint64_t offset, void *dest, uint32_t length);
void file_read(uint64_t offset, void *dest, uint32_t length) const;
void file_write(uint64_t offset, const void *source, uint32_t length);
uint64_t file_append(const void *source, uint32_t length, uint32_t alignment = 0);
uint8_t bits_for_value(uint64_t value);
@ -380,7 +390,7 @@ private:
void hunk_write_compressed(uint32_t hunknum, int8_t compression, const uint8_t *compressed, uint32_t complength, util::crc16_t crc16);
void hunk_copy_from_self(uint32_t hunknum, uint32_t otherhunk);
void hunk_copy_from_parent(uint32_t hunknum, uint64_t parentunit);
bool metadata_find(chd_metadata_tag metatag, int32_t metaindex, metadata_entry &metaentry, bool resume = false);
bool metadata_find(chd_metadata_tag metatag, int32_t metaindex, metadata_entry &metaentry, bool resume = false) const;
void metadata_set_previous_next(uint64_t prevoffset, uint64_t nextoffset);
void metadata_update_hash();
static int CLIB_DECL metadata_hash_compare(const void *elem1, const void *elem2);

105
src/lib/util/dvdrom.cpp Normal file
View File

@ -0,0 +1,105 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles,R. Belmont
/***************************************************************************
dvdrom.c
Generic MAME DVD-ROM utilties - build IDE and SCSI DVD-ROMs on top of this
***************************************************************************/
#include "dvdrom.h"
#include "corestr.h"
#include "osdfile.h"
#include "strformat.h"
#include <cassert>
#include <cstdlib>
/**
* @fn constructor
*
* @brief Open a dvdrom for a file.
*
* @param inputfile The inputfile.
*/
dvdrom_file::dvdrom_file(std::string_view inputfile)
{
fhandle = nullptr;
}
/*-------------------------------------------------
constructor - "open" a DVD-ROM file from an
already-opened CHD file
-------------------------------------------------*/
/**
* @fn dvdrom_file *dvdrom_open(chd_file *chd)
*
* @brief Queries if a given dvdrom open.
*
* @param [in,out] chd If non-null, the chd.
*
* @return null if it fails, else a dvdrom_file*.
*/
dvdrom_file::dvdrom_file(chd_file *_chd)
{
chd = _chd;
/* validate the CHD information */
if (chd->hunk_bytes() != 2048)
throw nullptr;
if (chd->unit_bytes() != 2048)
throw nullptr;
/* check it's actually a DVD-ROM */
if (!chd->is_dvd())
throw nullptr;
sector_count = chd->unit_count();
}
/*-------------------------------------------------
destructor - "close" a DVD-ROM file
-------------------------------------------------*/
dvdrom_file::~dvdrom_file()
{
}
/***************************************************************************
CORE READ ACCESS
***************************************************************************/
/*-------------------------------------------------
dvdrom_read_data - read one 2048 bytes sector
from a DVD-ROM
-------------------------------------------------*/
/**
* @fn bool read_data(uint32_t lbasector, void *buffer)
*
* @brief Dvdrom read data.
*
* @param lbasector The lbasector.
* @param buffer The buffer.
*
* @return Success status.
*/
std::error_condition dvdrom_file::read_data(uint32_t lbasector, void *buffer)
{
if (lbasector >= sector_count)
return std::error_condition(chd_file::error::HUNK_OUT_OF_RANGE);
return chd->read_hunk(lbasector, buffer);
}

41
src/lib/util/dvdrom.h Normal file
View File

@ -0,0 +1,41 @@
// license:BSD-3-Clause
// copyright-holders:Aaron Giles,R. Belmont
/***************************************************************************
dvdrom.h
Generic MAME dvd-rom implementation
***************************************************************************/
#ifndef MAME_LIB_UTIL_DVDROM_H
#define MAME_LIB_UTIL_DVDROM_H
#pragma once
#include "chd.h"
#include "ioprocs.h"
#include "osdcore.h"
class dvdrom_file {
public:
dvdrom_file(chd_file *chd);
dvdrom_file(std::string_view inputfile);
~dvdrom_file();
uint32_t get_sector_count() const { return sector_count; }
/* core read access */
std::error_condition read_data(uint32_t lbasector, void *buffer);
private:
/** @brief The chd, when there's one */
chd_file * chd; /* CHD file */
/** @brief The raw file, when there isn't */
util::random_read_write * fhandle; // file if not a CHD
/** @brief Size of the dvd image in sectors */
uint32_t sector_count;
};
#endif // MAME_LIB_UTIL_DVDROM_H

12
src/mame/altos/altos8600.cpp
View File

@ -138,8 +138,8 @@ void altos8600_state::machine_start()
save_item(NAME(m_sechi));
save_item(NAME(m_sector));
if(m_hdd->get_hard_disk_file())
m_geom = &m_hdd->get_hard_disk_file()->get_info();
if(m_hdd->exists())
m_geom = &m_hdd->get_info();
else
m_geom = nullptr;
}
@ -154,8 +154,8 @@ void altos8600_state::machine_reset()
m_nmistat = false;
m_cylhi = m_sechi = false;
m_stat = 0;
if(m_hdd->get_hard_disk_file())
m_geom = &m_hdd->get_hard_disk_file()->get_info();
if(m_hdd->exists())
m_geom = &m_hdd->get_info();
else
m_geom = nullptr;
}
@ -201,7 +201,7 @@ u8 altos8600_state::read_sector()
secoff -= 3;
}
if(!secoff)
m_hdd->get_hard_disk_file()->read(m_lba, m_sector);
m_hdd->read(m_lba, m_sector);
if(secoff >= 511)
{
m_dmac->drq1_w(CLEAR_LINE);
@ -223,7 +223,7 @@ bool altos8600_state::write_sector(u8 data)
{
m_stat &= ~1;
m_stat |= 2;
m_hdd->get_hard_disk_file()->write(m_lba, m_sector);
m_hdd->write(m_lba, m_sector);
m_dmac->drq1_w(CLEAR_LINE);
m_pic[1]->ir0_w(ASSERT_LINE);
return true;

2
src/mame/amiga/cubo.cpp
View File

@ -318,7 +318,7 @@ routines :
#include "emu.h"
#include "amiga.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/microtch.h"
#include "speaker.h"

2
src/mame/apple/pippin.cpp
View File

@ -48,7 +48,7 @@
#include "emu.h"
#include "cpu/powerpc/ppc.h"
#include "cpu/mn1880/mn1880.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/ram.h"
#include "sound/cdda.h"

15
src/mame/atari/jaguar.cpp
View File

@ -343,7 +343,7 @@ Notes:
#include "cpu/m68000/m68020.h"
#include "cpu/mips/mips1.h"
#include "cpu/jaguar/jaguar.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "imagedev/snapquik.h"
#include "machine/eepromser.h"
#include "machine/watchdog.h"
@ -479,7 +479,6 @@ void jaguarcd_state::machine_reset()
m_shared_ram[0x4/4] = 0x00802000; /* hack until I understand */
m_cd_file = m_cdrom->get_cdrom_file();
m_butch_cmd_index = 0;
m_butch_cmd_size = 1;
}
@ -1232,7 +1231,7 @@ void jaguarcd_state::butch_regs_w(offs_t offset, uint32_t data, uint32_t mem_mas
{
case 0x03: // Read TOC
{
if(!m_cd_file) // No disc
if(!m_cdrom->exists()) // No disc
{
m_butch_cmd_response[0] = 0x400;
m_butch_regs[0] |= 0x2000;
@ -1249,12 +1248,12 @@ void jaguarcd_state::butch_regs_w(offs_t offset, uint32_t data, uint32_t mem_mas
return;
}
uint32_t msf = m_cd_file->get_track_start(0) + 150;
uint32_t msf = m_cdrom->get_track_start(0) + 150;
/* first track number */
m_butch_cmd_response[0] = 0x2000 | 1;
/* last track number */
m_butch_cmd_response[1] = 0x2100 | m_cd_file->get_last_track();
m_butch_cmd_response[1] = 0x2100 | m_cdrom->get_last_track();
/* start of first track minutes */
m_butch_cmd_response[2] = 0x2200 | ((msf / 60) / 60);
@ -1270,7 +1269,7 @@ void jaguarcd_state::butch_regs_w(offs_t offset, uint32_t data, uint32_t mem_mas
case 0x14: // Read Long TOC
{
if(!m_cd_file) // No disc
if(!m_cdrom->exists()) // No disc
{
m_butch_cmd_response[0] = 0x400;
m_butch_regs[0] |= 0x2000;
@ -1279,11 +1278,11 @@ void jaguarcd_state::butch_regs_w(offs_t offset, uint32_t data, uint32_t mem_mas
return;
}
int ntrks = m_cd_file->get_last_track();
int ntrks = m_cdrom->get_last_track();
for(int i=0;i<ntrks;i++)
{
uint32_t msf = m_cd_file->get_track_start(i) + 150;
uint32_t msf = m_cdrom->get_track_start(i) + 150;
/* track number */
m_butch_cmd_response[i*5+0] = 0x6000 | (i+1);

5
src/mame/atari/jaguar.h
View File

@ -15,7 +15,7 @@
#include "jag_blitter.h"
#include "cdrom.h"
#include "bus/generic/slot.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "screen.h"
#include "emupal.h"
@ -405,7 +405,4 @@ private:
uint32_t m_butch_cmd_response[0x102]{};
uint8_t m_butch_cmd_index = 0U;
uint8_t m_butch_cmd_size = 0U;
cdrom_file *m_cd_file = nullptr;
//const cdrom_toc* m_toc = nullptr;
};

6
src/mame/ceres/ceres.cpp
View File

@ -81,7 +81,7 @@ public:
void wfc_w(offs_t offset, u8 data);
u8 wfc_r(offs_t offset);
void wfc_command(u8 command);
int get_lbasector(hard_disk_file *hdf);
int get_lbasector(harddisk_image_device *hdf);
DECLARE_INPUT_CHANGED_MEMBER(mouse_x);
DECLARE_INPUT_CHANGED_MEMBER(mouse_y);
@ -191,7 +191,7 @@ void ceres1_state::wfc_command(u8 command)
m_wfc_status &= ~WFC_S_ERR;
m_wfc_error = 0;
hard_disk_file *hdf = m_hdd[(m_wfc_sdh >> 3) & 3]->get_hard_disk_file();
harddisk_image_device *hdf = m_hdd[(m_wfc_sdh >> 3) & 3];
switch (command >> 4)
{
@ -227,7 +227,7 @@ void ceres1_state::wfc_command(u8 command)
m_icu->ireq3_w(1);
}
int ceres1_state::get_lbasector(hard_disk_file *hdf)
int ceres1_state::get_lbasector(harddisk_image_device *hdf)
{
const auto &info = hdf->get_info();

15
src/mame/dec/rainbow.cpp
View File

@ -674,7 +674,7 @@ protected:
void hdc_buffer_counter_reset();
void hdc_reset();
hard_disk_file *rainbow_hdc_file(int ref);
harddisk_image_device *rainbow_hdc_file(int ref);
uint8_t m_gdc_write_buffer[16]; // 16 x 8 bits for CPU, 8 x 16 for GDC
uint8_t m_gdc_color_map[32];
@ -1196,7 +1196,7 @@ void rainbow_base_state::machine_reset()
m_hdc_drive_ready = true;
m_hdc_write_fault = false;
hard_disk_file *local_hard_disk;
harddisk_image_device *local_hard_disk;
local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
m_leds[0] = 0;
@ -1665,7 +1665,7 @@ void rainbow_base_state::hdc_reset()
// Return 'hard_disk_file' object for harddisk 1 (fixed).
// < nullptr if geometry is insane or other errors occured >
hard_disk_file *rainbow_base_state::rainbow_hdc_file(int drv)
harddisk_image_device *rainbow_base_state::rainbow_hdc_file(int drv)
{
m_hdc_drive_ready = false;
@ -1683,8 +1683,7 @@ hard_disk_file *rainbow_base_state::rainbow_hdc_file(int drv)
if (!img->exists())
return nullptr;
hard_disk_file *file = img->get_hard_disk_file();
const auto &info = file->get_info();
const auto &info = img->get_info();
// MFM ALLOWS UP TO 17 SECTORS / TRACK.
// CYLINDERS: 151 (~ 5 MB) to 1024 (max. cylinders on WD1010 controller)
@ -1693,7 +1692,7 @@ hard_disk_file *rainbow_base_state::rainbow_hdc_file(int drv)
((info.cylinders > 150) && (info.cylinders <= RD51_MAX_CYLINDER)))
{
m_hdc_drive_ready = true;
return file; // HAS SANE GEOMETRY
return img; // HAS SANE GEOMETRY
}
else
{
@ -1744,7 +1743,7 @@ WRITE_LINE_MEMBER(rainbow_base_state::hdc_read_sector)
uint16_t cylinder = (m_hdc->read(0x04)) | (hi << 8);
uint8_t sector_number = m_hdc->read(0x03);
hard_disk_file *local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
harddisk_image_device *local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
if (local_hard_disk)
{
@ -1842,7 +1841,7 @@ int rainbow_base_state::do_write_sector()
m_leds[0] = 0; // ON
switch_off_timer->adjust(attotime::from_msec(500));
hard_disk_file *local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
harddisk_image_device *local_hard_disk = rainbow_hdc_file(0); // one hard disk for now.
if (local_hard_disk)
{

26
src/mame/fujitsu/fmtowns.cpp
View File

@ -1158,7 +1158,7 @@ uint8_t towns_state::towns_cd_get_track()
for(track=1;track<99;track++)
{
if(cdrom->get_cdrom_file()->get_track_start(track) > lba)
if(cdrom->get_track_start(track) > lba)
break;
}
return track;
@ -1206,7 +1206,7 @@ TIMER_CALLBACK_MEMBER(towns_state::towns_cdrom_read_byte)
m_towns_cd.extra_status = 0;
towns_cd_set_status(0x22,0x00,0x00,0x00);
towns_cdrom_set_irq(TOWNS_CD_IRQ_DMA,1);
m_cdrom->get_cdrom_file()->read_data(++m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
m_cdrom->read_data(++m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
m_towns_cd.read_timer->adjust(attotime::from_hz(300000),1);
m_towns_cd.buffer_ptr = -1;
}
@ -1237,7 +1237,7 @@ uint8_t towns_state::towns_cdrom_read_byte_software()
}
else
{
m_cdrom->get_cdrom_file()->read_data(++m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
m_cdrom->read_data(++m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
m_towns_cd.extra_status = 0;
towns_cd_set_status(0x21,0x00,0x00,0x00);
towns_cdrom_set_irq(TOWNS_CD_IRQ_DMA,1);
@ -1269,7 +1269,7 @@ void towns_state::towns_cdrom_read(cdrom_image_device* device)
m_towns_cd.lba_current = msf_to_lbafm(lba1);
m_towns_cd.lba_last = msf_to_lbafm(lba2);
track = device->get_cdrom_file()->get_track(m_towns_cd.lba_current);
track = device->get_track(m_towns_cd.lba_current);
// parameter 7 = sector count?
// lemmings 2 sets this to 4 but hates 4 extra sectors being read
@ -1285,7 +1285,7 @@ void towns_state::towns_cdrom_read(cdrom_image_device* device)
}
else
{
device->get_cdrom_file()->read_data(m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
device->read_data(m_towns_cd.lba_current,m_towns_cd.buffer,cdrom_file::CD_TRACK_MODE1);
if(m_towns_cd.software_tx)
{
m_towns_cd.status &= ~0x10; // not a DMA transfer
@ -1332,7 +1332,7 @@ void towns_state::towns_cdrom_play_cdda(cdrom_image_device* device)
m_towns_cd.cdda_current = msf_to_lbafm(lba1);
m_towns_cd.cdda_length = msf_to_lbafm(lba2) - m_towns_cd.cdda_current + 1;
m_cdda->set_cdrom(device->get_cdrom_file());
m_cdda->set_cdrom(device);
m_cdda->start_audio(m_towns_cd.cdda_current,m_towns_cd.cdda_length);
if(LOG_CD) logerror("CD: CD-DA start from LBA:%i length:%i\n",m_towns_cd.cdda_current,m_towns_cd.cdda_length);
if(m_towns_cd.command & 0x20)
@ -1350,7 +1350,7 @@ TIMER_CALLBACK_MEMBER(towns_state::towns_delay_cdda)
void towns_state::towns_cdrom_execute_command(cdrom_image_device* device)
{
towns_cdrom_set_irq(TOWNS_CD_IRQ_MPU,0); // TODO: this isn't sufficiently tested
if((device->get_cdrom_file() == nullptr) && (m_towns_cd.command != 0xa0))
if(!device->exists() && (m_towns_cd.command != 0xa0))
{ // No CD in drive
if(m_towns_cd.command & 0x20)
{
@ -1527,7 +1527,7 @@ uint8_t towns_state::towns_cdrom_r(offs_t offset)
break;
case 4: // st1 = last track number (BCD)
towns_cd_set_status(0x17,
byte_to_bcd(m_cdrom->get_cdrom_file()->get_last_track()),
byte_to_bcd(m_cdrom->get_last_track()),
0x00,0x00);
m_towns_cd.extra_status++;
break;
@ -1536,7 +1536,7 @@ uint8_t towns_state::towns_cdrom_r(offs_t offset)
m_towns_cd.extra_status++;
break;
case 6: // st1/2/3 = address of track 0xaa? (BCD)
addr = m_cdrom->get_cdrom_file()->get_track_start(0xaa);
addr = m_cdrom->get_track_start(0xaa);
addr = cdrom_file::lba_to_msf(addr + 150);
towns_cd_set_status(0x17,
(addr & 0xff0000) >> 16,(addr & 0x00ff00) >> 8,addr & 0x0000ff);
@ -1546,19 +1546,19 @@ uint8_t towns_state::towns_cdrom_r(offs_t offset)
if(m_towns_cd.extra_status & 0x01)
{
towns_cd_set_status(0x16,
((m_cdrom->get_cdrom_file()->get_adr_control((m_towns_cd.extra_status/2)-3) & 0x0f) << 4)
| ((m_cdrom->get_cdrom_file()->get_adr_control((m_towns_cd.extra_status/2)-3) & 0xf0) >> 4),
((m_cdrom->get_adr_control((m_towns_cd.extra_status/2)-3) & 0x0f) << 4)
| ((m_cdrom->get_adr_control((m_towns_cd.extra_status/2)-3) & 0xf0) >> 4),
byte_to_bcd((m_towns_cd.extra_status/2)-2),0x00);
m_towns_cd.extra_status++;
}
else
{
int track = (m_towns_cd.extra_status/2)-4;
addr = m_cdrom->get_cdrom_file()->get_track_start(track);
addr = m_cdrom->get_track_start(track);
addr = cdrom_file::lba_to_msf(addr + 150);
towns_cd_set_status(0x17,
(addr & 0xff0000) >> 16,(addr & 0x00ff00) >> 8,addr & 0x0000ff);
if(track >= m_cdrom->get_cdrom_file()->get_last_track())
if(track >= m_cdrom->get_last_track())
{
m_towns_cd.extra_status = 0;
}

2
src/mame/fujitsu/fmtowns.h
View File

@ -8,7 +8,7 @@
#include "fmt_icmem.h"
#include "cpu/i386/i386.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "imagedev/floppy.h"
#include "machine/fm_scsi.h"
#include "machine/i8251.h"

7
src/mame/konami/firebeat.cpp
View File

@ -375,6 +375,7 @@ struct IBUTTON
static void firebeat_ata_devices(device_slot_interface &device)
{
device.option_add("cdrom", ATAPI_FIXED_CDROM);
device.option_add("dvdrom", ATAPI_FIXED_DVDROM);
device.option_add("hdd", IDE_HARDDISK);
}
@ -1540,10 +1541,10 @@ void firebeat_popn_state::firebeat_popn(machine_config &config)
{
firebeat_spu_base(config);
ATA_INTERFACE(config, m_spuata).options(firebeat_ata_devices, "cdrom", nullptr, true);
ATA_INTERFACE(config, m_spuata).options(firebeat_ata_devices, "dvdrom", nullptr, true);
m_spuata->irq_handler().set(FUNC(firebeat_popn_state::spu_ata_interrupt));
m_spuata->dmarq_handler().set(FUNC(firebeat_popn_state::spu_ata_dmarq));
m_spuata->slot(0).set_option_machine_config("cdrom", dvdrom_config);
m_spuata->slot(0).set_option_machine_config("dvdrom", dvdrom_config);
m_spuata->slot(0).set_fixed(true);
// 500 hz works best for pop'n music.
@ -2375,7 +2376,7 @@ ROM_START( popn4 )
DISK_IMAGE_READONLY( "gq986jaa01", 0, SHA1(e5368ac029b0bdf29943ae66677b5521ae1176e1) )
DISK_REGION( "spu_ata:0:cdrom" ) // data DVD-ROM
DISK_IMAGE( "gq986jaa02", 0, SHA1(53367d3d5f91422fe386c42716492a0ae4332390) )
DISK_IMAGE( "gq986jaa02", 0, SHA1(c34ac216b3e0bef1d1813119469364c6403feaa4) )
ROM_REGION(0x1038, "rtc", ROMREGION_ERASE00) // Default unlocked RTC
ROM_LOAD("rtc", 0x0000, 0x1038, CRC(4a5c946c) SHA1(9de6085d45c39ba91934cea3abaa37e1203888c7))

34
src/mame/konami/konamim2.cpp
View File

@ -286,9 +286,6 @@ public:
protected:
virtual void machine_start() override;
virtual void machine_reset() override;
void update_disc();
public:
DECLARE_WRITE_LINE_MEMBER(ppc1_int);
@ -322,9 +319,6 @@ public:
if (!(data & 0x8000))
{
logerror("ATAPI RESET!\n");
// TODO: Do we need any of this?
update_disc();
}
}
@ -699,34 +693,6 @@ void konamim2_state::machine_start()
}
}
void konamim2_state::machine_reset()
{
update_disc();
}
void konamim2_state::update_disc()
{
cdrom_file *new_cdrom = m_available_cdroms;
atapi_hle_device *image = subdevice<atapi_hle_device>("ata:0:cr589");
if (image != nullptr)
{
void *current_cdrom = nullptr;
image->GetDevice(&current_cdrom);
if (current_cdrom != new_cdrom)
{
current_cdrom = new_cdrom;
image->SetDevice(new_cdrom);
}
}
else
{
abort();
}
}
/*************************************
*
* Address map

390
src/mame/konami/ksys573.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/mame/misc/3do.cpp
View File

@ -98,7 +98,7 @@ Part list of Goldstar 3DO Interactive Multiplayer
#include "cpu/arm/arm.h"
#include "cpu/arm7/arm7.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#define X2_CLOCK_PAL 59000000

49
src/mame/nec/pce_cd.cpp
View File

@ -142,8 +142,6 @@ void pce_cd_device::device_start()
m_ack_clear_timer = timer_alloc(FUNC(pce_cd_device::clear_ack), this);
m_ack_clear_timer->adjust(attotime::never);
// m_cd_file pointer is setup at a later stage because it is still empty when this function is called
// TODO: add proper restore for the cd data...
save_pointer(NAME(m_bram), PCE_BRAM_SIZE * 2);
save_pointer(NAME(m_adpcm_ram), PCE_ADPCM_RAM_SIZE);
@ -240,13 +238,12 @@ void pce_cd_device::device_reset()
void pce_cd_device::late_setup()
{
// at device start, the cdrom is not 'ready' yet, so we postpone this part of the initialization at machine_start in the driver
m_cd_file = m_cdrom->get_cdrom_file();
if (m_cd_file)
if (m_cdrom->exists())
{
m_toc = &m_cd_file->get_toc();
m_cdda->set_cdrom(m_cd_file);
m_last_frame = m_cd_file->get_track_start(m_cd_file->get_last_track() - 1);
m_last_frame += m_toc->tracks[m_cd_file->get_last_track() - 1].frames;
m_toc = &m_cdrom->get_toc();
m_cdda->set_cdrom(m_cdrom);
m_last_frame = m_cdrom->get_track_start(m_cdrom->get_last_track() - 1);
m_last_frame += m_toc->tracks[m_cdrom->get_last_track() - 1].frames;
m_end_frame = m_last_frame;
}
@ -381,7 +378,7 @@ void pce_cd_device::reply_status_byte(uint8_t status)
void pce_cd_device::test_unit_ready()
{
LOGCMD("0x00 TEST UNIT READY: status send ");
if (m_cd_file)
if (m_cdrom)
{
LOGCMD("STATUS_OK\n");
reply_status_byte(SCSI_STATUS_OK);
@ -401,7 +398,7 @@ void pce_cd_device::read_6()
LOGCMD("0x08 READ(6): frame: %08x size: %08x\n", frame, frame_count);
/* Check for presence of a CD */
if (!m_cd_file)
if (!m_cdrom)
{
reply_status_byte(SCSI_CHECK_CONDITION);
return;
@ -440,7 +437,7 @@ void pce_cd_device::nec_set_audio_start_position()
const uint8_t mode = m_command_buffer[9] & 0xc0;
LOGCMD("0xd8 SET AUDIO PLAYBACK START POSITION (NEC): mode %02x\n", mode);
if (!m_cd_file)
if (!m_cdrom)
{
/* Throw some error here */
reply_status_byte(SCSI_CHECK_CONDITION);
@ -460,7 +457,7 @@ void pce_cd_device::nec_set_audio_start_position()
const u8 f = bcd_2_dec(m_command_buffer[4]);
frame = f + 75 * (s + m * 60);
const u32 pregap = m_toc->tracks[m_cd_file->get_track(frame)].pregap;
const u32 pregap = m_toc->tracks[m_cdrom->get_track(frame)].pregap;
LOGCMD("MSF=%d %02d:%02d:%02d (pregap = %d)\n", frame, m, s, f, pregap);
// PCE tries to be clever here and set (start of track + track pregap size) to skip the pregap
@ -473,7 +470,7 @@ void pce_cd_device::nec_set_audio_start_position()
case 0x80:
{
const u8 track_number = bcd_2_dec(m_command_buffer[2]);
const u32 pregap = m_toc->tracks[m_cd_file->get_track(track_number - 1)].pregap;
const u32 pregap = m_toc->tracks[m_cdrom->get_track(track_number - 1)].pregap;
LOGCMD("TRACK=%d (pregap = %d)\n", track_number, pregap);
frame = m_toc->tracks[ track_number - 1 ].logframeofs;
// Not right for emeraldd, breaks intro lip sync
@ -518,8 +515,8 @@ void pce_cd_device::nec_set_audio_start_position()
else
{
//m_cdda_status = PCE_CD_CDDA_PLAYING;
m_end_frame = m_toc->tracks[ m_cd_file->get_track(m_current_frame) ].logframeofs
+ m_toc->tracks[ m_cd_file->get_track(m_current_frame) ].logframes;
m_end_frame = m_toc->tracks[ m_cdrom->get_track(m_current_frame) ].logframeofs
+ m_toc->tracks[ m_cdrom->get_track(m_current_frame) ].logframes;
LOGCDDA("Audio start (end of track) current %d end %d\n", m_current_frame, m_end_frame);
// Several places definitely don't want this to start redbook,
@ -558,7 +555,7 @@ void pce_cd_device::nec_set_audio_stop_position()
const uint8_t mode = m_command_buffer[9] & 0xc0;
LOGCMD("0xd9 SET AUDIO PLAYBACK END POSITION (NEC): mode %02x\n", mode);
if (!m_cd_file)
if (!m_cdrom)
{
/* Throw some error here */
reply_status_byte(SCSI_CHECK_CONDITION);
@ -578,7 +575,7 @@ void pce_cd_device::nec_set_audio_stop_position()
const u8 m = bcd_2_dec(m_command_buffer[2]);
const u8 s = bcd_2_dec(m_command_buffer[3]);
const u8 f = bcd_2_dec(m_command_buffer[4]);
const u32 pregap = m_toc->tracks[m_cd_file->get_track(frame)].pregap;
const u32 pregap = m_toc->tracks[m_cdrom->get_track(frame)].pregap;
frame = f + 75 * (s + m * 60);
LOGCMD("MSF=%d %02d:%02d:%02d (pregap = %d)\n", frame, m, s, f, pregap);
@ -588,7 +585,7 @@ void pce_cd_device::nec_set_audio_stop_position()
case 0x80:
{
const u8 track_number = bcd_2_dec(m_command_buffer[2]);
const u32 pregap = m_toc->tracks[m_cd_file->get_track(track_number - 1)].pregap;
const u32 pregap = m_toc->tracks[m_cdrom->get_track(track_number - 1)].pregap;
// NB: crazyhos uses this command with track = 1 on pre-title screen intro.
// It's not supposed to playback anything according to real HW refs.
frame = m_toc->tracks[ track_number - 1 ].logframeofs;
@ -645,7 +642,7 @@ void pce_cd_device::nec_set_audio_stop_position()
void pce_cd_device::nec_pause()
{
/* If no cd mounted throw an error */
if (!m_cd_file)
if (!m_cdrom)
{
reply_status_byte(SCSI_CHECK_CONDITION);
return;
@ -675,7 +672,7 @@ void pce_cd_device::nec_get_subq()
uint32_t msf_abs, msf_rel, track, frame;
//LOGCMD("0xdd READ SUBCHANNEL Q (NEC) %d\n", m_cdda_status);
if (!m_cd_file)
if (!m_cdrom)
{
/* Throw some error here */
reply_status_byte(SCSI_CHECK_CONDITION);
@ -700,10 +697,10 @@ void pce_cd_device::nec_get_subq()
}
msf_abs = cdrom_file::lba_to_msf_alt(frame);
track = m_cd_file->get_track(frame);
msf_rel = cdrom_file::lba_to_msf_alt(frame - m_cd_file->get_track_start(track));
track = m_cdrom->get_track(frame);
msf_rel = cdrom_file::lba_to_msf_alt(frame - m_cdrom->get_track_start(track));
m_data_buffer[1] = 0x01 | ((m_cd_file->get_track_type(m_cd_file->get_track(track+1)) == cdrom_file::CD_TRACK_AUDIO) ? 0x00 : 0x40);
m_data_buffer[1] = 0x01 | ((m_cdrom->get_track_type(m_cdrom->get_track(track+1)) == cdrom_file::CD_TRACK_AUDIO) ? 0x00 : 0x40);
// track
m_data_buffer[2] = dec_2_bcd(track+1);
// index
@ -742,13 +739,13 @@ void pce_cd_device::nec_get_dir_info()
uint32_t frame, msf, track = 0;
LOGCMD("0xde GET DIR INFO (NEC)\n");
if (!m_cd_file)
if (!m_cdrom)
{
/* Throw some error here */
reply_status_byte(SCSI_CHECK_CONDITION);
}
const cdrom_file::toc &toc = m_cd_file->get_toc();
const cdrom_file::toc &toc = m_cdrom->get_toc();
switch (m_command_buffer[1])
{
@ -1097,7 +1094,7 @@ TIMER_CALLBACK_MEMBER(pce_cd_device::data_timer_callback)
{
/* Read next data sector */
LOGSCSI("read sector %d\n", m_current_frame);
if (! m_cd_file->read_data(m_current_frame, m_data_buffer.get(), cdrom_file::CD_TRACK_MODE1))
if (! m_cdrom->read_data(m_current_frame, m_data_buffer.get(), cdrom_file::CD_TRACK_MODE1))
{
LOGSCSI("Mode1 CD read failed for frame #%d\n", m_current_frame);
}

3
src/mame/nec/pce_cd.h
View File

@ -9,7 +9,7 @@
TYPE DEFINITIONS
***************************************************************************/
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/nvram.h"
#include "sound/cdda.h"
#include "sound/msm5205.h"
@ -198,7 +198,6 @@ private:
required_device<nvram_device> m_nvram;
required_device<cdrom_image_device> m_cdrom;
cdrom_file *m_cd_file = nullptr;
const cdrom_file::toc* m_toc = nullptr;
emu_timer *m_data_timer = nullptr;
emu_timer *m_adpcm_dma_timer = nullptr;

2
src/mame/neogeo/neogeocd.cpp
View File

@ -28,7 +28,7 @@
#include "megacdcd.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/74259.h"
#include "machine/nvram.h"

2
src/mame/next/next.h
View File

@ -16,7 +16,7 @@
#include "machine/ncr53c90.h"
#include "machine/mb8795.h"
#include "nextmo.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "imagedev/harddriv.h"
class next_state : public driver_device

95
src/mame/nichibutsu/csplayh5.cpp
View File

@ -14,12 +14,6 @@
DVD Notes:
- Testing currently requires converting the data to cd mode 1
format (extracthd, rename to .iso, createcd) then change the
checksum. This will be fixed and the checksums changed to
something different again, so don't do the intermediate step
yet
- TMP68301 communicates with h8 via their respective internal serial comms
- TMP sends "?P", h8 answers "P01", TMP tends "?S", h8 answers "NG", games says the dvd drive has a problem
@ -438,7 +432,7 @@ void csplayh5_state::tmp68301_parallel_port_w(uint16_t data)
static void atapi_devs(device_slot_interface &device)
{
device.option_add("cdrom", ATAPI_FIXED_CDROM);
device.option_add("dvdrom", ATAPI_FIXED_DVDROM);
}
void csplayh5_state::csplayh5(machine_config &config)
@ -455,7 +449,7 @@ void csplayh5_state::csplayh5(machine_config &config)
m_maincpu->tx0_handler().set(*m_subcpu->subdevice<h8_sci_device>("sci0"), FUNC(h8_sci_device::rx_w));
m_subcpu->subdevice<h8_sci_device>("sci0")->tx_handler().set(m_maincpu, FUNC(tmp68301_device::rx0_w));
HRDVD_ATA_CONTROLLER_DEVICE(config, m_ata).options(atapi_devs, "cdrom", nullptr, true); // dvd
HRDVD_ATA_CONTROLLER_DEVICE(config, m_ata).options(atapi_devs, "dvdrom", nullptr, true);
m_ata->irq_handler().set(FUNC(csplayh5_state::ata_irq));
m_ata->dmarq_handler().set(FUNC(csplayh5_state::ata_drq));
@ -500,7 +494,7 @@ ROM_START( nichidvd )
ROM_REGION16_BE( 0x400000, "blit_gfx", ROMREGION_ERASEFF ) // blitter based gfxs
DISK_REGION( "ata:0:cdrom" )
DISK_REGION( "ata:0:dvdrom" )
ROM_END
// TODO: this surely uses a different subboard
@ -519,7 +513,7 @@ ROM_START( csplayh1 )
ROM_LOAD16_BYTE( "4.bin", 0x000001, 0x080000, CRC(2e63ee15) SHA1(78fefbc277234458212cded997d393bd8b82cf76) )
ROM_LOAD16_BYTE( "8.bin", 0x000000, 0x080000, CRC(a8567f1b) SHA1(2a854ef8b1988ad097bbcbeddc4b275ad738e1e1) )
DISK_REGION( "ata:0:cdrom" )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "csplayh1", 0, SHA1(d6514882c2626e62c5079df9ac68ecb70fc33209) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
@ -543,8 +537,8 @@ ROM_START( mjgalpri )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.020", 0x000000, 0x040000, CRC(4c92a523) SHA1(51da73fdfdfccdc070fa8a13163e031438b50876) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8001", 0, SHA1(30f356af4e08567273a88758bb0ddd3544eea228) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8001", 0, SHA1(7860688f8152ba7fdaeef5fec9eeb8e85c90b9a5) )
ROM_END
ROM_START( sengomjk )
@ -561,8 +555,8 @@ ROM_START( sengomjk )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(20791a5a) SHA1(03c38e9b8e60b0dded7504b2725210df5405110c) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(1ed72387) SHA1(7e2b8ce49561d6fd79dcf0d427569e5f6ef8dc67) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8002", 0, SHA1(d3502496526e62a877f12dccc27b32ae33d3704d) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8002", 0, SHA1(0fac6bbe52bc7ed56ce786ed0690f7e150fc4f3e) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.bin", 0x000000, 0x000117, CRC(9f0dec43) SHA1(d836e564da496c3049e16f025daf362cced413d4) )
@ -583,9 +577,8 @@ ROM_START( junai )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(4182dc30) SHA1(89601c62b74aff3d65b075d4b5cd1eb2ccf4e386) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "junai", 0, SHA1(0491533e0ce3e4d2af608ea0b9d9646316b512bd) )
// DISK_IMAGE_READONLY( "junai", 0, SHA1(282cc528ff175ac55f1545481ca1c40377cf9347) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "junai", 0, SHA1(098925d09cfdd2c970edf40054b36423f6e71a42) )
ROM_END
ROM_START( csplayh5 )
@ -603,8 +596,8 @@ ROM_START( csplayh5 )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(113d7e96) SHA1(f3fb9c719544417a6a018b82f07c65bf73de21ff) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "csplayh5", 0, SHA1(ce4883ce1351ce5299e41bfbd9a5ae8078b82b8c) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "csplayh5", 0, SHA1(30a5262529196d2bf6608114781ccf20ab284e37) )
ROM_END
ROM_START( junai2 )
@ -622,8 +615,8 @@ ROM_START( junai2 )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(5b37c8dd) SHA1(8de5e2f92721c6679c6506850a442cafff89653f) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "junai2", 0, SHA1(dc9633a101f20f03fd9b4414c10274d2539fb7c2) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "junai2", 0, SHA1(ec11caa96833b80324e68f0345b000d702eaf6cb) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.ic8", 0x000000, 0x0008c1, BAD_DUMP CRC(01c2895a) SHA1(782166a60fa14d5faa5a92629f7ca65a878ad7fe) )
@ -644,8 +637,8 @@ ROM_START( mogitate )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(ea655990) SHA1(7f59cfab21e8858625e82a9501acc943b07f799c) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(4c910b86) SHA1(48007f03f4e445b9de15531afe821c1b18fccae1) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8006", 0, SHA1(aa911e46e791d89ce4fed4a32b4b0637ba3a9920) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8006", 0, SHA1(334c37710affc852bec750721280488530b3d1e0) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.020", 0x000000, 0x040000, CRC(ac5c9495) SHA1(1c54ecf6dedbf8c3a29207c1c91b52e2ff394d9d) )
@ -665,8 +658,8 @@ ROM_START( mjmania )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(37dde764) SHA1(0530b63d8e682cdf01128057fdc3a8c23262afc9) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(dea4a2d2) SHA1(0118eb1330c9da8fead99f64fc015fd343fed79b) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "mjmania", 0, SHA1(7117f2045fd04a3d8f8e06a6a98e8f585c4da301) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "mjmania", 0, SHA1(777668854058b1586f599d266d1cea55c35aa30d) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.ic8", 0x000000, 0x0008c1, BAD_DUMP CRC(6a92b563) SHA1(a6c4305cf021f37845f99713427daa9394b6ec7d) )
@ -687,8 +680,8 @@ ROM_START( renaimj )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(6d1c9efd) SHA1(c9ea9d6e6d34db5635fc55d41e7bb54a41948d27) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8008", 0, SHA1(49c92cb9b08ee7773f3d93fce0bbecc3c0ae654d) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8008", 0, SHA1(8dd445030e287f9e4380277d2163c4163182ab51) )
ROM_REGION( 0x40000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal18v8b.020", 0x000000, 0x040000, CRC(0a32a144) SHA1(f3b4a1174adbb2f7b7500adeafa20142f6a16d08) )
@ -709,8 +702,8 @@ ROM_START( bikiniko )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(1e2e1cf3) SHA1(f71b5dedf4f897644d519e412651152d0d81edb8) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "bikiniko", 0, SHA1(2189b676746dd848b9b5eb69f9663d6dccd63787) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "bikiniko", 0, SHA1(cac9a6c7fe86751c968cd15f7b779edbc14d5f0b) )
ROM_END
ROM_START( csplayh6 )
@ -728,8 +721,8 @@ ROM_START( csplayh6 )
ROM_LOAD16_BYTE( "4.ic41", 0x00000, 0x80000, CRC(858e0604) SHA1(64c23bc06898188798937770129697b3c4b547d6) )
// 0x100000 - 0x3fffff empty sockets
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8010", 0, SHA1(01e247fe1b86bbfe743e09a625432874f881a9a0) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8010", 0, SHA1(5c3fab40d0cce94e80f2bdd533569d5507496ad4) )
ROM_REGION( 0x40000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "palce16v8h.020_bad", 0x000000, 0x040000, BAD_DUMP CRC(2aec4e37) SHA1(79d64394c0f6f2c5e17ae9fc62eaa279da466ccd) )
@ -749,8 +742,8 @@ ROM_START( thenanpa )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(ee6b88c4) SHA1(64ae66a24f1639801c7bdda7faa0d604bb97ceb1) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(ce987845) SHA1(2f7dca32a79ad6afbc55ca1d492b582f952688ff) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "thenanpa", 0, SHA1(72bf8c75189e877508c5a64d5591738d23ed7e96) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "thenanpa", 0, SHA1(730848295802b8596929ffd22b81712ec4ea30a6) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.ic8", 0x000000, 0x0008c1, BAD_DUMP CRC(daffd0ac)SHA1(cbeff914163d425a9cb30fe8d62f91fca281b11f) )
@ -770,8 +763,8 @@ ROM_START( pokoachu )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(843c288e) SHA1(2741b9da83fd35c7472b8c67bc02313a1c5e4e25) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(6920a9b8) SHA1(0a4cb9e2a0d871aed60c1293b7cac4bf79a9446c) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8012", 0, SHA1(06c611f110377f5d02bbde1ab1d43d3623772b7b) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8012", 0, SHA1(be6450351d6da4c96cbff353d587980a2728e306) )
ROM_REGION( 0x40000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.020", 0x000000, 0x040000, CRC(ac5c9495) SHA1(1c54ecf6dedbf8c3a29207c1c91b52e2ff394d9d) )
@ -791,8 +784,8 @@ ROM_START( csplayh7 )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(1d67ca95) SHA1(9b45045b6fa67308bade324f91c21010aa8d121e) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(b4f5f990) SHA1(88cccae04f89fef43d88f4e82b65de3de946e9af) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "csplayh7", 0, SHA1(f81e772745b0c62b17d91bd294993e49fe8da4d9) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "csplayh7", 0, SHA1(be6450351d6da4c96cbff353d587980a2728e306) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "mjdvd12.gal16v8b.ic8.bin", 0x000000, 0x0008c1, BAD_DUMP CRC(6a92b563)SHA1(a6c4305cf021f37845f99713427daa9394b6ec7d) )
@ -812,8 +805,8 @@ ROM_START( aimode )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(4a9863cf) SHA1(ccf08befe773fb94fa78423ed19b6b8d255ca3a7) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(893aac1a) SHA1(14dd3f07363858c2be3a9400793f720b1f5baf1a) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8014", 0, SHA1(c5ad9bd66f0930e1c477126301286e38f077c164) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8014", 0, SHA1(f2aea46961630328d82ffc221c4b817b20fa9f5c) )
ROM_REGION( 0x40000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.020", 0x000000, 0x040000, CRC(0a32a144) SHA1(f3b4a1174adbb2f7b7500adeafa20142f6a16d08) )
@ -833,8 +826,8 @@ ROM_START( fuudol )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(5c9e8665) SHA1(2a1b040e5c72d4400d4b5c467c75ae99e9bb01e2) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(fdd79d8f) SHA1(f8bb82afaa28affb04b83270eb407129f1c7e611) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "fuudol", 0, SHA1(fabab43543ed14da4fe7c63a2a2cc4e68936938a) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "fuudol", 0, SHA1(d6b5af48775304caa1d98878dc8dc154c975720e) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.ic8", 0x000000, 0x0008c1, CRC(30719630) SHA1(a8c7b6d0304c38691775c5af6c32fbeeefd9f9fa) )
@ -854,8 +847,8 @@ ROM_START( nuretemi )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(5c7af7f6) SHA1(78e58e3a81a6585c2c61f0026b7dc73a72c0d862) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(335b6388) SHA1(c5427b42af011b5a5026d905b1740684b9f6f953) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8016", 0, SHA1(607d9f390265da3f0c50753d0ea32257b12e8c08) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8016", 0, SHA1(76c7257e6c98e9dd8c594489c3104b2d032a9099) )
ROM_REGION( 0x1000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.bin", 0x000000, 0x000117, CRC(865de327) SHA1(a97374ee765443d9da6919d0e226108c062f7942) )
@ -875,8 +868,8 @@ ROM_START( tsuwaku )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(00657ca3) SHA1(a02bb8a177f3915ddf0bf97fd69426a3a28061a5) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(edf56c94) SHA1(76d95a45aced3ad8bfe8a561f355731f4f99603e) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8017", 0, SHA1(6c86985574d53f990c4eec573d7fa84782cb9c4c) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8017", 0, SHA1(0db86e6157b4bd402f0c41d0d69c1a80d2156b27) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8h.020", 0x000000, 0x040000, CRC(ac5c9495) SHA1(1c54ecf6dedbf8c3a29207c1c91b52e2ff394d9d) )
@ -896,8 +889,8 @@ ROM_START( torarech )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(cbbbab5c) SHA1(ab8ae64b1f2acfab55ba7cbb173f3036a46001e6) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(18412fd8) SHA1(6907ce2739549519e1f3dcee2186f6add219a3c2) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8018", 0, SHA1(cf8758bb2caaba6377b354694123ddec71a4f8e1) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8018", 0, SHA1(b6cf54735bf6fded2ffb17e6fac84ae9a86ccaf2) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "palce16v8h.020", 0x000000, 0xbb2, BAD_DUMP CRC(c8e8605a) SHA1(02e43d9de73256e5c73d6f99834a23cef321d56b) )
@ -917,8 +910,8 @@ ROM_START( nichisel )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(5ab63481) SHA1(fc81fbdd1df496813fc0d80bcab6d0434b75d311) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(50085861) SHA1(b8f99a66a743c9bf66ef307fe4b581586e293fe5) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb80sp", 0, SHA1(48eb9f8adba0ea5f59cfcbdee61c29b4af84ac97) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb80sp", 0, SHA1(3bf53fef4b002bfd8515e4133f636e1c9b031931) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "palce16v8h.020", 0x000000, 0x040000, CRC(228b98fb) SHA1(53b57a09610425a5bb9d0ffe0f68dce2d9ab3bf6) )
@ -938,8 +931,8 @@ ROM_START( konhaji )
ROM_LOAD16_BYTE( "3.ic40", 0x000001, 0x080000, CRC(88f31da7) SHA1(dc76532fa3261b3b238a42e2ca8f270f2b2ea1fa) )
ROM_LOAD16_BYTE( "4.ic41", 0x000000, 0x080000, CRC(35893109) SHA1(6a55bd147a75913af59bc355abf010e1b75063bf) )
DISK_REGION( "ata:0:cdrom" )
DISK_IMAGE_READONLY( "nb8019", 0, SHA1(f59ac1587009d7d15618549dc60cbd24c263a95f) )
DISK_REGION( "ata:0:dvdrom" )
DISK_IMAGE_READONLY( "nb8019", 0, SHA1(a7b6dc0374b374b02e4a4eaf706330f961ebb563) )
ROM_REGION( 0x040000, "gal", ROMREGION_ERASE00 )
ROM_LOAD( "gal16v8b.bin", 0x000000, 0x000117, CRC(9f0dec43) SHA1(d836e564da496c3049e16f025daf362cced413d4) )

4
src/mame/philips/cdi.cpp
View File

@ -51,7 +51,7 @@ TODO:
#include "cdi.h"
#include "cpu/m6805/m6805.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/timekpr.h"
#include "sound/cdda.h"
@ -478,6 +478,8 @@ void cdi_state::cdimono1_base(machine_config &config)
CDI_SLAVE_HLE(config, m_slave_hle, 0);
m_slave_hle->int_callback().set(m_maincpu, FUNC(scc68070_device::in2_w));
CDROM(config, "cdrom").set_interface("cdi_cdrom");
/* sound hardware */
SPEAKER(config, "lspeaker").front_left();
SPEAKER(config, "rspeaker").front_right();

17
src/mame/philips/cdicdic.cpp
View File

@ -931,7 +931,7 @@ void cdicdic_device::process_disc_sector()
LOGMASKED(LOG_SECTORS, "Disc sector, current LBA: %08x, MSF: %02x %02x %02x\n", real_lba, mins_bcd, secs_bcd, frac_bcd);
uint8_t buffer[2560] = { 0 };
m_cd->read_data(m_curr_lba, buffer, cdrom_file::CD_TRACK_RAW_DONTCARE);
m_cdrom->read_data(m_curr_lba, buffer, cdrom_file::CD_TRACK_RAW_DONTCARE);
// Detect (badly) if we're dealing with a byteswapped loose-bin image
if (buffer[0] == 0xff && buffer[1] == 0x00)
@ -1022,7 +1022,7 @@ void cdicdic_device::process_disc_sector()
if (m_disc_mode == DISC_TOC)
{
uint8_t *toc_buffer = buffer;
const cdrom_file::toc &toc = m_cd->get_toc();
const cdrom_file::toc &toc = m_cdrom->get_toc();
uint32_t entry_count = 0;
// Determine total frame count for data, and total audio track count
@ -1473,7 +1473,7 @@ cdicdic_device::cdicdic_device(const machine_config &mconfig, const char *tag, d
, m_memory_space(*this, ":maincpu", AS_PROGRAM)
, m_dmadac(*this, ":dac%u", 1U)
, m_scc(*this, ":maincpu")
, m_cdrom_dev(*this, ":cdrom")
, m_cdrom(*this, ":cdrom")
, m_clock2(clock)
{
}
@ -1564,17 +1564,6 @@ void cdicdic_device::device_reset()
m_decoding_audio_map = false;
m_decode_addr = 0;
if (m_cdrom_dev)
{
// Console case (has CDROM device)
m_cd = m_cdrom_dev->get_cdrom_file();
}
else
{
// Arcade case
m_cd = new cdrom_file(machine().rom_load().get_disk_handle(":cdrom"));
}
m_audio_timer->adjust(attotime::from_hz(75), 0, attotime::from_hz(75));
m_sector_timer->adjust(attotime::from_hz(75), 0, attotime::from_hz(75));

6
src/mame/philips/cdicdic.h
View File

@ -26,11 +26,10 @@ TODO:
#pragma once
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/scc68070.h"
#include "sound/cdda.h"
#include "sound/dmadac.h"
#include "cdrom.h"
//**************************************************************************
// TYPE DEFINITIONS
@ -156,7 +155,7 @@ private:
required_address_space m_memory_space;
required_device_array<dmadac_sound_device, 2> m_dmadac;
required_device<scc68070_device> m_scc;
optional_device<cdrom_image_device> m_cdrom_dev;
required_device<cdrom_image_device> m_cdrom;
uint32_t m_clock2;
@ -174,7 +173,6 @@ private:
uint16_t m_interrupt_vector; // CDIC Interrupt Vector Register (0x303ffc)
uint16_t m_data_buffer; // CDIC Data Buffer Register (0x303ffe)
cdrom_file *m_cd;
bool m_cd_byteswap;
emu_timer *m_sector_timer;

25
src/mame/quantel/dpb7000.cpp
View File

@ -111,7 +111,6 @@ public:
, m_floppy0(*this, "0")
, m_hdd(*this, "hdd")
, m_floppy(nullptr)
, m_hdd_file(nullptr)
, m_output_cursor(*this, "output_timing_cursor")
, m_output_hlines(*this, "output_timing_hlines")
, m_output_hflags(*this, "output_timing_hflags")
@ -241,9 +240,6 @@ private:
uint8_t m_fdd_side;
fdc_pll_t m_fdd_pll;
// Hard Disk
hard_disk_file *m_hdd_file;
// Timers
emu_timer *m_diskseq_complete_clk;
emu_timer *m_field_in_clk;
@ -999,9 +995,6 @@ void dpb7000_state::machine_reset()
m_fdd_pll.reset(machine().time());
m_floppy = nullptr;
// Hard Disc Handling
m_hdd_file = m_hdd->get_hard_disk_file();
// Disc Data Buffer Card
m_diskbuf_ram_addr = 0;
memset(m_diskbuf_ram, 0, 14 * 0x800);
@ -2409,7 +2402,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
int head_index = m_diskseq_cmd_word_from_cpu & 0xf;
int image_lba = SECTORS_PER_TRACK * head_count * (int)m_diskseq_cyl_from_cpu + SECTORS_PER_TRACK * head_index;
if (m_hdd_file != nullptr)
if (m_hdd->exists())
{
if (m_diskseq_cyl_write_pending)
{
@ -2420,14 +2413,14 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
{
for (int sector = start_sector; sector < 19200 / 256; sector++, image_lba++)
{
m_hdd_file->read(image_lba, sector_buffer);
m_hdd->read(image_lba, sector_buffer);
for (int stride_idx = 0; stride_idx < 256; stride_idx += 2)
{
sector_buffer[stride_idx] = m_diskbuf_ram[ram_addr];
ram_addr += 2;
}
LOGMASKED(LOG_HDD, "Performing write to LBA %d: Cylinder %03x, head %x, command word %03x, Stride 2 (RAM address %04x, offset %04x)\n", image_lba, m_diskseq_cyl_from_cpu, head_index, m_diskseq_cmd_word_from_cpu, m_diskbuf_ram_addr, sector * 256);
m_hdd_file->write(image_lba, sector_buffer);
m_hdd->write(image_lba, sector_buffer);
}
}
else
@ -2442,7 +2435,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
sector_buffer[i + 0] = process_byte_to_disc();
sector_buffer[i + 1] = process_byte_to_disc();
}
m_hdd_file->write(image_lba, sector_buffer);
m_hdd->write(image_lba, sector_buffer);
}
}
else
@ -2450,7 +2443,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
for (int sector = start_sector; sector < 19200 / 256; sector++, image_lba++)
{
LOGMASKED(LOG_HDD, "Performing write to LBA %d: Cylinder %03x, head %x, command word %03x (RAM address %04x, offset %04x)\n", image_lba, m_diskseq_cyl_from_cpu, head_index, m_diskseq_cmd_word_from_cpu, m_diskbuf_ram_addr, sector * 256);
m_hdd_file->write(image_lba, m_diskbuf_ram + sector * 256);
m_hdd->write(image_lba, m_diskbuf_ram + sector * 256);
}
}
}
@ -2464,7 +2457,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
for (int sector = 0; sector < 19200 / 256; sector++, image_lba++)
{
LOGMASKED(LOG_HDD, "Performing read of LBA %d: Cylinder %03x, head %x, command word %03x\n", image_lba, m_diskseq_cyl_from_cpu, head_index, m_diskseq_cmd_word_from_cpu);
m_hdd_file->read(image_lba, sector_buffer);
m_hdd->read(image_lba, sector_buffer);
for (int clear_idx = 0; clear_idx < 256; clear_idx += 2)
{
sector_buffer[clear_idx] = 0;
@ -2489,7 +2482,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
if (partial_bytes && !BIT(m_diskseq_cmd, 2))
{
LOGMASKED(LOG_HDD, "Performing partial read of sector into disk buffer address %04x\n", m_diskbuf_ram_addr);
m_hdd_file->read(image_lba, sector_buffer);
m_hdd->read(image_lba, sector_buffer);
memcpy(m_diskbuf_ram + m_diskbuf_ram_addr, sector_buffer + partial_bytes, 0x100 - partial_bytes);
m_diskbuf_ram_addr += 0x100;
m_diskbuf_ram_addr &= 0xff00;
@ -2501,7 +2494,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
LOGMASKED(LOG_HDD, "Performing read of LBA %d: Cylinder %03x, head %x, command word %03x\n", image_lba, m_diskseq_cyl_from_cpu, head_index, m_diskseq_cmd_word_from_cpu);
if (BIT(m_diskseq_cmd, 2))
{
m_hdd_file->read(image_lba, sector_buffer);
m_hdd->read(image_lba, sector_buffer);
for (int i = 0; i < 256; i++)
{
process_byte_from_disc(sector_buffer[i]);
@ -2509,7 +2502,7 @@ TIMER_CALLBACK_MEMBER(dpb7000_state::execute_hdd_command)
}
else
{
m_hdd_file->read(image_lba, m_diskbuf_ram + sector * 256);
m_hdd->read(image_lba, m_diskbuf_ram + sector * 256);
}
}
}

4
src/mame/sega/dccons.cpp
View File

@ -55,7 +55,7 @@
#include "cpu/arm7/arm7.h"
#include "cpu/arm7/arm7core.h"
#include "cpu/sh/sh4.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/aicartc.h"
//#include "emupal.h"
@ -429,7 +429,7 @@ void dc_cons_state::dc_base(machine_config &config)
m_ata->irq_handler().set(FUNC(dc_cons_state::ata_interrupt));
ata_slot_device &ata_0(*subdevice<ata_slot_device>("ata:0"));
ata_0.option_add("gdrom", GDROM);
ata_0.option_add("gdrom", ATAPI_GDROM);
ata_0.set_option_machine_config("gdrom", gdrom_config);
ata_0.set_default_option("gdrom");
}

2
src/mame/sega/dccons.h
View File

@ -8,7 +8,7 @@
#include "dc.h"
#include "bus/ata/ataintf.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/intelfsh.h"
class dc_cons_state : public dc_state

3
src/mame/sega/mdconsole.cpp
View File

@ -6,7 +6,8 @@
#include "bus/generic/carts.h"
#include "bus/sms_ctrl/controllers.h"
#include "imagedev/chd_cd.h"
#include "bus/generic/slot.h"
#include "imagedev/cdromimg.h"
#include "sound/sn76496.h"
#include "softlist.h"

2
src/mame/sega/naomigd.cpp
View File

@ -434,7 +434,7 @@ void idegdrom_device::map_extra(uint64_t memory_window_start, uint64_t memory_wi
static void gdrom_devices(device_slot_interface &device)
{
device.option_add("gdrom", GDROM);
device.option_add("gdrom", ATAPI_GDROM);
}

12
src/mame/shared/isbc_215g.cpp
View File

@ -64,7 +64,7 @@ uint16_t isbc_215g_device::read_sector()
uint16_t wps = 64 << ((m_idcompare[0] >> 4) & 3);
harddisk_image_device *drive = (m_drive ? m_hdd1 : m_hdd0);
if(!m_secoffset)
drive->get_hard_disk_file()->read(m_lba[m_drive], m_sector);
drive->read(m_lba[m_drive], m_sector);
if(m_secoffset >= wps)
return 0;
return m_sector[m_secoffset++];
@ -79,7 +79,7 @@ bool isbc_215g_device::write_sector(uint16_t data)
m_sector[m_secoffset++] = data;
if(m_secoffset == wps)
{
drive->get_hard_disk_file()->write(m_lba[m_drive], m_sector);
drive->write(m_lba[m_drive], m_sector);
return true;
}
return false;
@ -386,12 +386,12 @@ const tiny_rom_entry *isbc_215g_device::device_rom_region() const
void isbc_215g_device::device_reset()
{
if(m_hdd0->get_hard_disk_file())
m_geom[0] = &m_hdd0->get_hard_disk_file()->get_info();
if(m_hdd0->exists())
m_geom[0] = &m_hdd0->get_info();
else
m_geom[0] = nullptr;
if(m_hdd1->get_hard_disk_file())
m_geom[1] = &m_hdd1->get_hard_disk_file()->get_info();
if(m_hdd1->exists())
m_geom[1] = &m_hdd1->get_info();
else
m_geom[1] = nullptr;

56
src/mame/shared/megacdcd.cpp
View File

@ -311,7 +311,7 @@ void lc89510_temp_device::CDD_GetPos(void)
CLEAR_CDD_RESULT
uint32_t msf;
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
CDD_STATUS |= SCD_STATUS;
msf = cdrom_file::lba_to_msf_alt(SCD_CURLBA+150);
@ -327,12 +327,12 @@ void lc89510_temp_device::CDD_GetTrackPos(void)
uint32_t msf;
CDD_STATUS &= 0xFF;
// uint32_t end_msf = ;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
CDD_STATUS |= SCD_STATUS;
elapsedlba = SCD_CURLBA - segacd.toc->tracks[ segacd.cd->get_track(SCD_CURLBA) ].logframeofs;
elapsedlba = SCD_CURLBA - segacd.toc->tracks[ m_cdrom->get_track(SCD_CURLBA) ].logframeofs;
msf = cdrom_file::lba_to_msf_alt (elapsedlba);
//popmessage("%08x %08x",SCD_CURLBA,segacd.toc->tracks[ cdrom_get_track(segacd.cd, SCD_CURLBA) + 1 ].logframeofs);
//popmessage("%08x %08x",SCD_CURLBA,segacd.toc->tracks[ cdrom_get_track(m_cdrom, SCD_CURLBA) + 1 ].logframeofs);
CDD_MIN = to_bcd(((msf & 0x00ff0000)>>16),false);
CDD_SEC = to_bcd(((msf & 0x0000ff00)>>8),false);
CDD_FRAME = to_bcd(((msf & 0x000000ff)>>0),false);
@ -342,10 +342,10 @@ void lc89510_temp_device::CDD_GetTrack(void)
{
CLEAR_CDD_RESULT
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
CDD_STATUS |= SCD_STATUS;
SCD_CURTRK = segacd.cd->get_track(SCD_CURLBA)+1;
SCD_CURTRK = m_cdrom->get_track(SCD_CURLBA)+1;
CDD_MIN = to_bcd(SCD_CURTRK, false);
}
@ -353,11 +353,11 @@ void lc89510_temp_device::CDD_Length(void)
{
CLEAR_CDD_RESULT
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
CDD_STATUS |= SCD_STATUS;
uint32_t startlba = (segacd.toc->tracks[segacd.cd->get_last_track()].logframeofs);
uint32_t startlba = (segacd.toc->tracks[m_cdrom->get_last_track()].logframeofs);
uint32_t startmsf = cdrom_file::lba_to_msf_alt( startlba );
CDD_MIN = to_bcd((startmsf&0x00ff0000)>>16,false);
@ -370,11 +370,11 @@ void lc89510_temp_device::CDD_FirstLast(void)
{
CLEAR_CDD_RESULT
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
CDD_STATUS |= SCD_STATUS;
CDD_MIN = 1; // first
CDD_SEC = to_bcd(segacd.cd->get_last_track(),false); // last
CDD_SEC = to_bcd(m_cdrom->get_last_track(),false); // last
}
void lc89510_temp_device::CDD_GetTrackAdr(void)
@ -382,11 +382,11 @@ void lc89510_temp_device::CDD_GetTrackAdr(void)
CLEAR_CDD_RESULT
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
int track = (CDD_TX[5] & 0xF) + (CDD_TX[4] & 0xF) * 10;
int last_track = segacd.cd->get_last_track();
int last_track = m_cdrom->get_last_track();
CDD_STATUS |= SCD_STATUS;
@ -415,11 +415,11 @@ void lc89510_temp_device::CDD_GetTrackType(void)
CLEAR_CDD_RESULT
CDD_STATUS &= 0xFF;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
int track = (CDD_TX[5] & 0xF) + (CDD_TX[4] & 0xF) * 10;
int last_track = segacd.cd->get_last_track();
int last_track = m_cdrom->get_last_track();
CDD_STATUS |= SCD_STATUS;
@ -455,10 +455,10 @@ void lc89510_temp_device::CDD_Play()
CLEAR_CDD_RESULT
uint32_t msf = getmsf_from_regs();
SCD_CURLBA = cdrom_file::msf_to_lba(msf)-150;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
uint32_t track_length = segacd.toc->tracks[ segacd.cd->get_track(SCD_CURLBA) ].logframes;
SCD_CURTRK = segacd.cd->get_track(SCD_CURLBA)+1;
uint32_t track_length = segacd.toc->tracks[ m_cdrom->get_track(SCD_CURLBA) ].logframes;
SCD_CURTRK = m_cdrom->get_track(SCD_CURLBA)+1;
LC8951UpdateHeader();
SCD_STATUS = CDD_PLAYINGCDDA;
CDD_STATUS = 0x0102;
@ -480,9 +480,9 @@ void lc89510_temp_device::CDD_Seek(void)
CLEAR_CDD_RESULT
uint32_t msf = getmsf_from_regs();
SCD_CURLBA = cdrom_file::msf_to_lba(msf)-150;
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
SCD_CURTRK = segacd.cd->get_track(SCD_CURLBA)+1;
SCD_CURTRK = m_cdrom->get_track(SCD_CURLBA)+1;
LC8951UpdateHeader();
STOP_CDC_READ
SCD_STATUS = CDD_READY;
@ -513,9 +513,9 @@ void lc89510_temp_device::CDD_Resume()
{
CLEAR_CDD_RESULT
STOP_CDC_READ
if(segacd.cd == nullptr) // no CD is there, bail out
if(m_cdrom == nullptr) // no CD is there, bail out
return;
SCD_CURTRK = segacd.cd->get_track(SCD_CURLBA)+1;
SCD_CURTRK = m_cdrom->get_track(SCD_CURLBA)+1;
SCD_STATUS = CDD_PLAYINGCDDA;
CDD_STATUS = 0x0102;
set_data_audio_mode();
@ -1107,19 +1107,13 @@ void lc89510_temp_device::reset_cd(void)
lc89510_Reset();
{
segacd.cd = m_cdrom->get_cdrom_file();
if ( segacd.cd )
if ( m_cdrom->exists() )
{
segacd.toc = &segacd.cd->get_toc();
m_cdda->set_cdrom(segacd.cd);
segacd.toc = &m_cdrom->get_toc();
m_cdda->set_cdrom(m_cdrom);
m_cdda->stop_audio(); //stop any pending CD-DA
}
}
// if (segacd.cd)
// printf("cd found\n");
}
@ -1335,7 +1329,7 @@ int lc89510_temp_device::Read_LBA_To_Buffer()
if (CDD_CONTROL & 0x0100) data_track = true;
if (data_track)
segacd.cd->read_data(SCD_CURLBA, SCD_BUFFER, cdrom_file::CD_TRACK_MODE1);
m_cdrom->read_data(SCD_CURLBA, SCD_BUFFER, cdrom_file::CD_TRACK_MODE1);
LC8951UpdateHeader();

3
src/mame/shared/megacdcd.h
View File

@ -3,7 +3,7 @@
#ifndef MAME_SHARED_SEGACDCD_H
#define MAME_SHARED_SEGACDCD_H
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "machine/timer.h"
#include "sound/cdda.h"
@ -91,7 +91,6 @@ protected:
struct segacd_t
{
cdrom_file *cd;
const cdrom_file::toc *toc;
uint32_t current_frame;
};

2
src/mame/skeleton/vsmilepro.cpp
View File

@ -22,7 +22,7 @@
#include "cdrom.h"
#include "cpu/arm7/arm7.h"
#include "cpu/arm7/arm7core.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "softlist.h"

2
src/mame/sony/psx.cpp
View File

@ -15,7 +15,7 @@
#include "bus/psx/parallel.h"
#include "cpu/m6805/m6805.h"
#include "cpu/psx/psx.h"
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "imagedev/snapquik.h"
#include "psxcd.h"
#include "machine/ram.h"

2
src/mame/sony/psxcd.h
View File

@ -5,7 +5,7 @@
#pragma once
#include "imagedev/chd_cd.h"
#include "imagedev/cdromimg.h"
#include "sound/spu.h"

94
src/tools/chdman.cpp
View File

@ -70,6 +70,7 @@ const int MODE_GDI = 2;
#define COMMAND_CREATE_RAW "createraw"
#define COMMAND_CREATE_HD "createhd"
#define COMMAND_CREATE_CD "createcd"
#define COMMAND_CREATE_DVD "createdvd"
#define COMMAND_CREATE_LD "createld"
#define COMMAND_EXTRACT_RAW "extractraw"
#define COMMAND_EXTRACT_HD "extracthd"
@ -124,6 +125,7 @@ static void do_verify(parameters_map &params);
static void do_create_raw(parameters_map &params);
static void do_create_hd(parameters_map &params);
static void do_create_cd(parameters_map &params);
static void do_create_dvd(parameters_map &params);
static void do_create_ld(parameters_map &params);
static void do_copy(parameters_map &params);
static void do_extract_raw(parameters_map &params);
@ -699,6 +701,16 @@ static const command_description s_commands[] =
OPTION_NUMPROCESSORS
}
},
{ COMMAND_CREATE_DVD, do_create_dvd, ": create a DVD CHD from the input file",
{
REQUIRED OPTION_OUTPUT,
OPTION_OUTPUT_PARENT,
OPTION_OUTPUT_FORCE,
REQUIRED OPTION_INPUT,
OPTION_COMPRESSION,
OPTION_NUMPROCESSORS
}
},
{ COMMAND_CREATE_LD, do_create_ld, ": create a laserdisc CHD from the input file",
{
@ -2064,6 +2076,88 @@ static void do_create_cd(parameters_map &params)
}
//-------------------------------------------------
// do_create_dvd - create a new compressed dvd
// image from a raw file
//-------------------------------------------------
static void do_create_dvd(parameters_map &params)
{
// process input file
util::core_file::ptr input_file;
auto input_file_str = params.find(OPTION_INPUT);
if (input_file_str != params.end())
{
std::error_condition const filerr = util::core_file::open(*input_file_str->second, OPEN_FLAG_READ, input_file);
if (filerr)
report_error(1, "Unable to open file (%s): %s", *input_file_str->second, filerr.message());
}
// process output CHD
chd_file output_parent;
std::string *output_chd_str = parse_output_chd_parameters(params, output_parent);
// process input start/end
uint64_t filesize = 0;
input_file->length(filesize); // FIXME: check error return
// process compression
chd_codec_type compression[4];
memcpy(compression, s_default_hd_compression, sizeof(compression)); // No reason to be different than HD for compression
if (!input_file)
compression[0] = compression[1] = compression[2] = compression[3] = CHD_CODEC_NONE;
parse_compression(params, compression);
// process numprocessors
parse_numprocessors(params);
// validate the size
if (filesize % 2048 != 0)
report_error(1, "Data size is not divisible by 2048");
uint32_t totalsectors = filesize / 2048;
// print some info
printf("Output CHD: %s\n", output_chd_str->c_str());
if (output_parent.opened())
printf("Parent CHD: %s\n", params.find(OPTION_OUTPUT_PARENT)->second->c_str());
printf("Input file: %s\n", input_file_str->second->c_str());
printf("Compression: %s\n", compression_string(compression).c_str());
printf("Logical size: %s\n", big_int_string(uint64_t(totalsectors) * 2048).c_str());
// catch errors so we can close & delete the output file
try
{
// create the new dvd
std::unique_ptr<chd_file_compressor> chd;
chd.reset(new chd_rawfile_compressor(*input_file, 0, filesize));
std::error_condition err;
if (output_parent.opened())
err = chd->create(output_chd_str->c_str(), uint64_t(totalsectors) * 2048, 2048, compression, output_parent);
else
err = chd->create(output_chd_str->c_str(), uint64_t(totalsectors) * 2048, 2048, 2048, compression);
if (err)
report_error(1, "Error creating CHD file (%s): %s", output_chd_str, err.message());
// add the standard dvd type tag
err = chd->write_metadata(DVD_METADATA_TAG, 0, "");
if (err)
report_error(1, "Error adding dvd metadata: %s", err.message());
// compress it generically
compress_common(*chd);
}
catch (...)
{
// delete the output file
auto output_chd_str = params.find(OPTION_OUTPUT);
if (output_chd_str != params.end())
osd_file::remove(*output_chd_str->second);
throw;
}
}
//-------------------------------------------------
// do_create_ld - create a new A/V file from an
// input AVI file and metadata