Sprinter/mame
2
0
Fork 0
mirror of https://github.com/holub/mame synced 2025-06-05 04:16:28 +03:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity

Merge pull request #3273 from wilbertpol/destatic_devices_sound

Browse Source 
de-staticify initializations for src/devices/sound (nw)
This commit is contained in:
R. Belmont 2018-02-28 14:01:14 -05:00 committed by GitHub
commit 71d728f348
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
84 changed files with 480 additions and 599 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/devices/imagedev/floppy.cpp
View File

@ -1107,7 +1107,7 @@ void floppy_sound_device::device_start()
{
// What kind of drive do we have?
bool is525 = strstr(tag(), "525") != nullptr;
static_set_samples_names(*this, is525? floppy525_sample_names : floppy35_sample_names);
set_samples_names(is525? floppy525_sample_names : floppy35_sample_names);
m_motor_on = false;

6
src/devices/sound/2203intf.h
View File

@ -12,15 +12,15 @@ struct ssg_callbacks;
#define MCFG_YM2203_IRQ_HANDLER(cb) \
devcb = &ym2203_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ym2203_device &>(*device).set_irq_handler((DEVCB_##cb));
class ym2203_device : public ay8910_device
{
public:
ym2203_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym2203_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/2608intf.h
View File

@ -12,15 +12,15 @@ struct ssg_callbacks;
#define MCFG_YM2608_IRQ_HANDLER(cb) \
devcb = &ym2608_device::set_irq_handler(*device, DEVCB_##cb);
devcb = &downcast<ym2608_device &>(*device).set_irq_handler(DEVCB_##cb);
class ym2608_device : public ay8910_device
{
public:
ym2608_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym2608_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/2610intf.h
View File

@ -12,15 +12,15 @@ struct ssg_callbacks;
#define MCFG_YM2610_IRQ_HANDLER(cb) \
devcb = &ym2610_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ym2610_device &>(*device).set_irq_handler((DEVCB_##cb));
class ym2610_device : public ay8910_device
{
public:
ym2610_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym2610_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/2612intf.h
View File

@ -7,15 +7,15 @@
#define MCFG_YM2612_IRQ_HANDLER(cb) \
devcb = &ym2612_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ym2612_device &>(*device).set_irq_handler((DEVCB_##cb));
class ym2612_device : public device_t, public device_sound_interface
{
public:
ym2612_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym2612_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/262intf.h
View File

@ -7,15 +7,15 @@
#define MCFG_YMF262_IRQ_HANDLER(cb) \
devcb = &ymf262_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ymf262_device &>(*device).set_irq_handler((DEVCB_##cb));
class ymf262_device : public device_t, public device_sound_interface
{
public:
ymf262_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ymf262_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/3526intf.h
View File

@ -7,15 +7,15 @@
#define MCFG_YM3526_IRQ_HANDLER(cb) \
devcb = &ym3526_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ym3526_device &>(*device).set_irq_handler((DEVCB_##cb));
class ym3526_device : public device_t, public device_sound_interface
{
public:
ym3526_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym3526_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

6
src/devices/sound/3812intf.h
View File

@ -5,15 +5,15 @@
#define MCFG_YM3812_IRQ_HANDLER(cb) \
devcb = &ym3812_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<ym3812_device &>(*device).set_irq_handler((DEVCB_##cb));
class ym3812_device : public device_t, public device_sound_interface
{
public:
ym3812_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym3812_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

22
src/devices/sound/8950intf.h
View File

@ -7,31 +7,31 @@
#define MCFG_Y8950_IRQ_HANDLER(cb) \
devcb = &y8950_device::set_irq_handler(*device, (DEVCB_##cb));
devcb = &downcast<y8950_device &>(*device).set_irq_handler((DEVCB_##cb));
#define MCFG_Y8950_KEYBOARD_READ_HANDLER(cb) \
devcb = &y8950_device::set_keyboard_read_handler(*device, (DEVCB_##cb));
devcb = &downcast<y8950_device &>(*device).set_keyboard_read_handler((DEVCB_##cb));
#define MCFG_Y8950_KEYBOARD_WRITE_HANDLER(cb) \
devcb = &y8950_device::set_keyboard_write_handler(*device, (DEVCB_##cb));
devcb = &downcast<y8950_device &>(*device).set_keyboard_write_handler((DEVCB_##cb));
#define MCFG_Y8950_IO_READ_HANDLER(cb) \
devcb = &y8950_device::set_io_read_handler(*device, (DEVCB_##cb));
devcb = &downcast<y8950_device &>(*device).set_io_read_handler((DEVCB_##cb));
#define MCFG_Y8950_IO_WRITE_HANDLER(cb) \
devcb = &y8950_device::set_io_write_handler(*device, (DEVCB_##cb));
devcb = &downcast<y8950_device &>(*device).set_io_write_handler((DEVCB_##cb));
class y8950_device : public device_t, public device_sound_interface
{
public:
y8950_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<y8950_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_keyboard_read_handler(device_t &device, Object &&cb) { return downcast<y8950_device &>(device).m_keyboard_read_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_keyboard_write_handler(device_t &device, Object &&cb) { return downcast<y8950_device &>(device).m_keyboard_write_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_io_read_handler(device_t &device, Object &&cb) { return downcast<y8950_device &>(device).m_io_read_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_io_write_handler(device_t &device, Object &&cb) { return downcast<y8950_device &>(device).m_io_write_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_keyboard_read_handler(Object &&cb) { return m_keyboard_read_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_keyboard_write_handler(Object &&cb) { return m_keyboard_write_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_io_read_handler(Object &&cb) { return m_io_read_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_io_write_handler(Object &&cb) { return m_io_write_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

8
src/devices/sound/ad1848.h
View File

@ -9,18 +9,18 @@
#define MCFG_AD1848_IRQ_CALLBACK(cb) \
devcb = &ad1848_device::set_irq_callback(*device, (DEVCB_##cb));
devcb = &downcast<ad1848_device &>(*device).set_irq_callback((DEVCB_##cb));
#define MCFG_AD1848_DRQ_CALLBACK(cb) \
devcb = &ad1848_device::set_drq_callback(*device, (DEVCB_##cb));
devcb = &downcast<ad1848_device &>(*device).set_drq_callback((DEVCB_##cb));
class ad1848_device : public device_t
{
public:
ad1848_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_irq_callback(device_t &device, Object &&cb) { return downcast<ad1848_device &>(device).m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_drq_callback(device_t &device, Object &&cb) { return downcast<ad1848_device &>(device).m_drq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_irq_callback(Object &&cb) { return m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_drq_callback(Object &&cb) { return m_drq_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER(read);
DECLARE_WRITE8_MEMBER(write);

16
src/devices/sound/aica.h
View File

@ -15,16 +15,16 @@
#define MCFG_AICA_MASTER \
aica_device::set_master(*device);
downcast<aica_device &>(*device).set_master(true);
#define MCFG_AICA_ROFFSET(offs) \
aica_device::set_roffset(*device, (offs));
downcast<aica_device &>(*device).set_roffset((offs));
#define MCFG_AICA_IRQ_CB(cb) \
devcb = &aica_device::set_irq_callback(*device, (DEVCB_##cb));
devcb = &downcast<aica_device &>(*device).set_irq_callback((DEVCB_##cb));
#define MCFG_AICA_MAIN_IRQ_CB(cb) \
devcb = &aica_device::set_main_irq_callback(*device, (DEVCB_##cb));
devcb = &downcast<aica_device &>(*device).set_main_irq_callback((DEVCB_##cb));
class aica_device : public device_t,
public device_sound_interface
@ -32,10 +32,10 @@ class aica_device : public device_t,
public:
aica_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_master(device_t &device) { downcast<aica_device &>(device).m_master = true; }
static void set_roffset(device_t &device, int roffset) { downcast<aica_device &>(device).m_roffset = roffset; }
template <class Object> static devcb_base &set_irq_callback(device_t &device, Object &&cb) { return downcast<aica_device &>(device).m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_main_irq_callback(device_t &device, Object &&cb) { return downcast<aica_device &>(device).m_main_irq_cb.set_callback(std::forward<Object>(cb)); }
void set_master(bool master) { m_master = master; }
void set_roffset(int roffset) { m_roffset = roffset; }
template <class Object> devcb_base &set_irq_callback(Object &&cb) { return m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_main_irq_callback(Object &&cb) { return m_main_irq_cb.set_callback(std::forward<Object>(cb)); }
// AICA register access
DECLARE_READ16_MEMBER( read );

11
src/devices/sound/asc.cpp
View File

@ -55,17 +55,6 @@ asc_device::asc_device(const machine_config &mconfig, const char *tag, device_t
}
//-------------------------------------------------
// static_set_type - configuration helper to set
// the chip type
//-------------------------------------------------
void asc_device::static_set_type(device_t &device, asc_type type)
{
asc_device &asc = downcast<asc_device &>(device);
asc.m_chip_type = type;
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------

4
src/devices/sound/asc.h
View File

@ -31,7 +31,7 @@
MCFG_IRQ_FUNC(_irqf)
#define MCFG_ASC_TYPE(_type) \
asc_device::static_set_type(*device, asc_device::asc_type::_type);
downcast<asc_device &>(*device).set_type(asc_device::asc_type::_type);
#define MCFG_IRQ_FUNC(_irqf) \
devcb = &downcast<asc_device *>(device)->set_irqf(DEVCB_##_irqf);
@ -64,7 +64,7 @@ public:
asc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_type(device_t &device, asc_type type);
void set_type(asc_type type) { m_chip_type = type; }
template <class Write> devcb_base &set_irqf(Write &&wr)

28
src/devices/sound/ay8910.h
View File

@ -53,22 +53,22 @@
#define MCFG_AY8910_OUTPUT_TYPE(_flag) \
ay8910_device::set_flags(*device, _flag);
downcast<ay8910_device &>(*device).set_flags(_flag);
#define MCFG_AY8910_RES_LOADS(_res0, _res1, _res2) \
ay8910_device::set_resistors_load(*device, _res0, _res1, _res2);
downcast<ay8910_device &>(*device).set_resistors_load(_res0, _res1, _res2);
#define MCFG_AY8910_PORT_A_READ_CB(_devcb) \
devcb = &ay8910_device::set_port_a_read_callback(*device, DEVCB_##_devcb);
devcb = &downcast<ay8910_device &>(*device).set_port_a_read_callback(DEVCB_##_devcb);
#define MCFG_AY8910_PORT_B_READ_CB(_devcb) \
devcb = &ay8910_device::set_port_b_read_callback(*device, DEVCB_##_devcb);
devcb = &downcast<ay8910_device &>(*device).set_port_b_read_callback(DEVCB_##_devcb);
#define MCFG_AY8910_PORT_A_WRITE_CB(_devcb) \
devcb = &ay8910_device::set_port_a_write_callback(*device, DEVCB_##_devcb);
devcb = &downcast<ay8910_device &>(*device).set_port_a_write_callback(DEVCB_##_devcb);
#define MCFG_AY8910_PORT_B_WRITE_CB(_devcb) \
devcb = &ay8910_device::set_port_b_write_callback(*device, DEVCB_##_devcb);
devcb = &downcast<ay8910_device &>(*device).set_port_b_write_callback(DEVCB_##_devcb);
class ay8910_device : public device_t,
@ -84,14 +84,14 @@ public:
// construction/destruction
ay8910_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
static void set_flags(device_t &device, int flags) { downcast<ay8910_device &>(device).m_flags = flags; }
static void set_psg_type(device_t &device, psg_type_t psg_type) { downcast<ay8910_device &>(device).set_type(psg_type); }
static void set_resistors_load(device_t &device, int res_load0, int res_load1, int res_load2) { downcast<ay8910_device &>(device).m_res_load[0] = res_load0; downcast<ay8910_device &>(device).m_res_load[1] = res_load1; downcast<ay8910_device &>(device).m_res_load[2] = res_load2; }
template <class Object> static devcb_base &set_port_a_read_callback(device_t &device, Object &&cb) { return downcast<ay8910_device &>(device).m_port_a_read_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_port_b_read_callback(device_t &device, Object &&cb) { return downcast<ay8910_device &>(device).m_port_b_read_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_port_a_write_callback(device_t &device, Object &&cb) { return downcast<ay8910_device &>(device).m_port_a_write_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_port_b_write_callback(device_t &device, Object &&cb) { return downcast<ay8910_device &>(device).m_port_b_write_cb.set_callback(std::forward<Object>(cb)); }
// configuration helpers
void set_flags(int flags) { m_flags = flags; }
void set_psg_type(psg_type_t psg_type) { set_type(psg_type); }
void set_resistors_load(int res_load0, int res_load1, int res_load2) { m_res_load[0] = res_load0; m_res_load[1] = res_load1; m_res_load[2] = res_load2; }
template <class Object> devcb_base &set_port_a_read_callback(Object &&cb) { return m_port_a_read_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_port_b_read_callback(Object &&cb) { return m_port_b_read_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_port_a_write_callback(Object &&cb) { return m_port_a_write_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_port_b_write_callback(Object &&cb) { return m_port_b_write_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( data_r );
DECLARE_WRITE8_MEMBER( address_w );

12
src/devices/sound/bsmt2000.cpp
View File

@ -77,18 +77,6 @@ bsmt2000_device::bsmt2000_device(const machine_config &mconfig, const char *tag,
}
//-------------------------------------------------
// static_set_ready_callback - configuration
// helper to set the ready callback
//-------------------------------------------------
void bsmt2000_device::static_set_ready_callback(device_t &device, ready_callback &&callback)
{
bsmt2000_device &bsmt = downcast<bsmt2000_device &>(device);
bsmt.m_ready_callback = std::move(callback);
}
//-------------------------------------------------
// rom_region - return a pointer to the device's
// internal ROM region

4
src/devices/sound/bsmt2000.h
View File

@ -25,7 +25,7 @@
#define MCFG_BSMT2000_REPLACE(_tag, _clock) \
MCFG_DEVICE_REPLACE(_tag, BSMT2000, _clock)
#define MCFG_BSMT2000_READY_CALLBACK(_class, _method) \
bsmt2000_device::static_set_ready_callback(*device, bsmt2000_device::ready_callback(&_class::_method, #_class "::" #_method, nullptr, (_class *)nullptr));
downcast<bsmt2000_device &>(*device).set_ready_callback(bsmt2000_device::ready_callback(&_class::_method, #_class "::" #_method, nullptr, (_class *)nullptr));
//**************************************************************************
@ -46,7 +46,7 @@ public:
bsmt2000_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_ready_callback(device_t &device, ready_callback &&callback);
template <typename Object> void set_ready_callback(Object &&cb) { m_ready_callback = std::forward<Object>(cb); }
// public interface
uint16_t read_status();

10
src/devices/sound/c140.h
View File

@ -12,13 +12,13 @@
//**************************************************************************
#define MCFG_C140_ADD(tag, clock) \
MCFG_DEVICE_ADD((tag), C140, (clock))
MCFG_DEVICE_ADD((tag), C140, (clock))
#define MCFG_C140_REPLACE(tag, clock) \
MCFG_DEVICE_REPLACE((tag), C140, (clock))
MCFG_DEVICE_REPLACE((tag), C140, (clock))
#define MCFG_C140_BANK_TYPE(type) \
c140_device::set_bank_type(*device, (c140_device::C140_TYPE::type));
downcast<c140_device &>(*device).set_bank_type((c140_device::C140_TYPE::type));
//**************************************************************************
@ -41,8 +41,8 @@ public:
c140_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void set_bank_type(device_t &device, C140_TYPE bank) { downcast<c140_device &>(device).m_banking_type = bank; }
// configuration
void set_bank_type(C140_TYPE bank) { m_banking_type = bank; }
DECLARE_READ8_MEMBER( c140_r );
DECLARE_WRITE8_MEMBER( c140_w );

11
src/devices/sound/c352.cpp
View File

@ -52,17 +52,6 @@ void c352_device::rom_bank_updated()
m_stream->update();
}
//-------------------------------------------------
// static_set_dividder - configuration helper to
// set the divider setting
//-------------------------------------------------
void c352_device::static_set_divider(device_t &device, int setting)
{
c352_device &c352 = downcast<c352_device &>(device);
c352.m_divider = setting;
}
void c352_device::fetch_sample(c352_voice_t* v)
{
v->last_sample = v->sample;

8
src/devices/sound/c352.h
View File

@ -11,11 +11,11 @@
//**************************************************************************
#define MCFG_C352_ADD(tag, clock, setting) \
MCFG_DEVICE_ADD((tag), C352, (clock)) \
MCFG_C352_DIVIDER(setting)
MCFG_DEVICE_ADD((tag), C352, (clock)) \
MCFG_C352_DIVIDER(setting)
#define MCFG_C352_DIVIDER(setting) \
c352_device::static_set_divider(*device, (setting));
downcast<c352_device &>(*device).set_divider((setting));
//**************************************************************************
@ -33,7 +33,7 @@ public:
c352_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_divider(device_t &device, int setting);
void set_divider(int setting) { m_divider = setting; }
DECLARE_READ16_MEMBER(read);
DECLARE_WRITE16_MEMBER(write);

4
src/devices/sound/c6280.h
View File

@ -12,7 +12,7 @@ class c6280_device : public device_t, public device_sound_interface
public:
c6280_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_devicecpu_tag(device_t &device, const char *tag) { downcast<c6280_device &>(device).m_cpudevice.set_tag(tag); }
void set_devicecpu_tag(const char *tag) { m_cpudevice.set_tag(tag); }
// read/write
DECLARE_READ8_MEMBER( c6280_r );
@ -57,6 +57,6 @@ private:
DECLARE_DEVICE_TYPE(C6280, c6280_device)
#define MCFG_C6280_CPU(tag) \
c6280_device::set_devicecpu_tag(*device, ("^" tag));
downcast<c6280_device &>(*device).set_devicecpu_tag(("^" tag));
#endif // MAME_SOUND_C6280_H

12
src/devices/sound/cdp1863.cpp
View File

@ -57,18 +57,6 @@ cdp1863_device::cdp1863_device(const machine_config &mconfig, const char *tag, d
}
//-------------------------------------------------
// static_set_clock2 - configuration helper
//-------------------------------------------------
void cdp1863_device::static_set_clock2(device_t &device, int clock2)
{
cdp1863_device &cdp1863 = downcast<cdp1863_device &>(device);
cdp1863.m_clock2 = clock2;
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------

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

@ -31,7 +31,7 @@
#define MCFG_CDP1863_ADD(_tag, _clock, _clock2) \
MCFG_DEVICE_ADD(_tag, CDP1863, _clock) \
cdp1863_device::static_set_clock2(*device, _clock2);
downcast<cdp1863_device &>(*device).set_clock2(_clock2);
@ -49,8 +49,8 @@ public:
cdp1863_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_clock2(device_t &device, int clock2);
static void static_set_clock2(device_t &device, const XTAL &xtal) { xtal.validate("selecting cdp1863 clock"); static_set_clock2(device, xtal.value()); }
void set_clock2(int clock2) { m_clock2 = clock2; }
void set_clock2(const XTAL &xtal) { xtal.validate("selecting cdp1863 clock"); set_clock2(xtal.value()); }
DECLARE_WRITE8_MEMBER( str_w );
void str_w(uint8_t data);

42
src/devices/sound/cdp1869.h
View File

@ -87,18 +87,18 @@
//**************************************************************************
#define MCFG_CDP1869_ADD(_tag, _pixclock, _map) \
MCFG_DEVICE_ADD(_tag, CDP1869, _pixclock) \
MCFG_DEVICE_ADDRESS_MAP(0, _map)
MCFG_DEVICE_ADD(_tag, CDP1869, _pixclock) \
MCFG_DEVICE_ADDRESS_MAP(0, _map)
#define MCFG_CDP1869_SCREEN_PAL_ADD(_cdptag, _tag, _clock) \
MCFG_SCREEN_ADD(_tag, RASTER) \
MCFG_SCREEN_UPDATE_DEVICE(_cdptag, cdp1869_device, screen_update) \
MCFG_SCREEN_RAW_PARAMS(_clock, cdp1869_device::SCREEN_WIDTH, cdp1869_device::HBLANK_END, cdp1869_device::HBLANK_START, cdp1869_device::TOTAL_SCANLINES_PAL, cdp1869_device::SCANLINE_VBLANK_END_PAL, cdp1869_device::SCANLINE_VBLANK_START_PAL)
MCFG_SCREEN_ADD(_tag, RASTER) \
MCFG_SCREEN_UPDATE_DEVICE(_cdptag, cdp1869_device, screen_update) \
MCFG_SCREEN_RAW_PARAMS(_clock, cdp1869_device::SCREEN_WIDTH, cdp1869_device::HBLANK_END, cdp1869_device::HBLANK_START, cdp1869_device::TOTAL_SCANLINES_PAL, cdp1869_device::SCANLINE_VBLANK_END_PAL, cdp1869_device::SCANLINE_VBLANK_START_PAL)
#define MCFG_CDP1869_SCREEN_NTSC_ADD(_cdptag, _tag, _clock) \
MCFG_SCREEN_ADD(_tag, RASTER) \
MCFG_SCREEN_UPDATE_DEVICE(_cdptag, cdp1869_device, screen_update) \
MCFG_SCREEN_RAW_PARAMS(_clock, cdp1869_device::SCREEN_WIDTH, cdp1869_device::HBLANK_END, cdp1869_device::HBLANK_START, cdp1869_device::TOTAL_SCANLINES_NTSC, cdp1869_device::SCANLINE_VBLANK_END_NTSC, cdp1869_device::SCANLINE_VBLANK_START_NTSC)
MCFG_SCREEN_ADD(_tag, RASTER) \
MCFG_SCREEN_UPDATE_DEVICE(_cdptag, cdp1869_device, screen_update) \
MCFG_SCREEN_RAW_PARAMS(_clock, cdp1869_device::SCREEN_WIDTH, cdp1869_device::HBLANK_END, cdp1869_device::HBLANK_START, cdp1869_device::TOTAL_SCANLINES_NTSC, cdp1869_device::SCANLINE_VBLANK_END_NTSC, cdp1869_device::SCANLINE_VBLANK_START_NTSC)
#define MCFG_CDP1869_SET_SCREEN MCFG_VIDEO_SET_SCREEN
@ -107,22 +107,22 @@
#define CDP1869_PCB_READ_MEMBER(name) int name(uint16_t pma, uint8_t cma, uint8_t pmd)
#define MCFG_CDP1869_PAL_NTSC_CALLBACK(_read) \
devcb = &cdp1869_device::set_pal_ntsc_rd_callback(*device, DEVCB_##_read);
devcb = &downcast<cdp1869_device &>(*device).set_pal_ntsc_rd_callback(DEVCB_##_read);
#define MCFG_CDP1869_PRD_CALLBACK(_write) \
devcb = &cdp1869_device::set_prd_wr_callback(*device, DEVCB_##_write);
devcb = &downcast<cdp1869_device &>(*device).set_prd_wr_callback(DEVCB_##_write);
#define MCFG_CDP1869_COLOR_CLOCK(_clk) \
cdp1869_device::static_set_color_clock(*device, _clk);
downcast<cdp1869_device &>(*device).set_color_clock(_clk);
#define MCFG_CDP1869_CHAR_RAM_READ_OWNER(_class, _method) \
cdp1869_device::static_set_char_ram_read(*device, cdp1869_device::char_ram_read_delegate(&_class::_method, #_class "::" #_method, this));
downcast<cdp1869_device &>(*device).set_char_ram_read(cdp1869_device::char_ram_read_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_CDP1869_CHAR_RAM_WRITE_OWNER(_class, _method) \
cdp1869_device::static_set_char_ram_write(*device, cdp1869_device::char_ram_write_delegate(&_class::_method, #_class "::" #_method, this));
downcast<cdp1869_device &>(*device).set_char_ram_write(cdp1869_device::char_ram_write_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_CDP1869_CHAR_PCB_READ_OWNER(_class, _method) \
cdp1869_device::static_set_pcb_read(*device, cdp1869_device::pcb_read_delegate(&_class::_method, #_class "::" #_method, this));
downcast<cdp1869_device &>(*device).set_pcb_read(cdp1869_device::pcb_read_delegate(&_class::_method, #_class "::" #_method, this));
//**************************************************************************
@ -188,13 +188,13 @@ public:
// construction/destruction
cdp1869_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_pal_ntsc_rd_callback(device_t &device, Object &&cb) { return downcast<cdp1869_device &>(device).m_read_pal_ntsc.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_prd_wr_callback(device_t &device, Object &&cb) { return downcast<cdp1869_device &>(device).m_write_prd.set_callback(std::forward<Object>(cb)); }
static void static_set_char_ram_read(device_t &device, char_ram_read_delegate &&cb) { downcast<cdp1869_device &>(device).m_in_char_ram_func = std::move(cb); }
static void static_set_char_ram_write(device_t &device, char_ram_write_delegate &&cb) { downcast<cdp1869_device &>(device).m_out_char_ram_func = std::move(cb); }
static void static_set_pcb_read(device_t &device, pcb_read_delegate &&cb) { downcast<cdp1869_device &>(device).m_in_pcb_func = std::move(cb); }
static void static_set_color_clock(device_t &device, int color_clock) { downcast<cdp1869_device &>(device).m_color_clock = color_clock; }
static void static_set_color_clock(device_t &device, const XTAL &xtal) { xtal.validate("selecting cdp1869 clock"); static_set_color_clock(device, xtal.value()); }
template <class Object> devcb_base &set_pal_ntsc_rd_callback(Object &&cb) { return m_read_pal_ntsc.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_prd_wr_callback(Object &&cb) { return m_write_prd.set_callback(std::forward<Object>(cb)); }
template <typename Object> void set_char_ram_read(Object &&cb) { m_in_char_ram_func = std::forward<Object>(cb); }
template <typename Object> void set_char_ram_write(Object &&cb) { m_out_char_ram_func = std::forward<Object>(cb); }
template <typename Object> void set_pcb_read(Object &&cb) { m_in_pcb_func = std::forward<Object>(cb); }
void set_color_clock(int color_clock) { m_color_clock = color_clock; }
void set_color_clock(const XTAL &xtal) { xtal.validate("selecting cdp1869 clock"); set_color_clock(xtal.value()); }
virtual void io_map(address_map &map);
virtual void char_map(address_map &map);

12
src/devices/sound/cem3394.h
View File

@ -17,13 +17,13 @@
MCFG_DEVICE_REPLACE(_tag, CEM3394, _clock)
#define MCFG_CEM3394_EXT_INPUT_CB(_class, _method) \
cem3394_device::set_ext_input_callback(*device, cem3394_device::ext_input_delegate(&_class::_method, #_class "::" #_method, this));
downcast<cem3394_device &>(*device).set_ext_input_callback(cem3394_device::ext_input_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_CEM3394_VCO_ZERO(_freq) \
cem3394_device::set_vco_zero_freq(*device, _freq);
downcast<cem3394_device &>(*device).set_vco_zero_freq(_freq);
#define MCFG_CEM3394_FILTER_ZERO(_freq) \
cem3394_device::set_filter_zero_freq(*device, _freq);
downcast<cem3394_device &>(*device).set_filter_zero_freq(_freq);
class cem3394_device : public device_t, public device_sound_interface
@ -48,9 +48,9 @@ public:
cem3394_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_ext_input_callback(device_t &device, ext_input_delegate &&callback) { downcast<cem3394_device &>(device).m_ext_cb = std::move(callback); }
static void set_vco_zero_freq(device_t &device, double freq) { downcast<cem3394_device &>(device).m_vco_zero_freq = freq; }
static void set_filter_zero_freq(device_t &device, double freq) { downcast<cem3394_device &>(device).m_filter_zero_freq = freq; }
template <typename Object> void set_ext_input_callback(Object &&cb) { m_ext_cb = std::forward<Object>(cb); }
void set_vco_zero_freq(double freq) { m_vco_zero_freq = freq; }
void set_filter_zero_freq(double freq) { m_filter_zero_freq = freq; }
protected:
// device-level overrides

12
src/devices/sound/dave.h
View File

@ -32,13 +32,13 @@
#define MCFG_DAVE_IRQ_CALLBACK(_write) \
devcb = &dave_device::set_irq_wr_callback(*device, DEVCB_##_write);
devcb = &downcast<dave_device &>(*device).set_irq_wr_callback(DEVCB_##_write);
#define MCFG_DAVE_LH_CALLBACK(_write) \
devcb = &dave_device::set_lh_wr_callback(*device, DEVCB_##_write);
devcb = &downcast<dave_device &>(*device).set_lh_wr_callback(DEVCB_##_write);
#define MCFG_DAVE_RH_CALLBACK(_write) \
devcb = &dave_device::set_rh_wr_callback(*device, DEVCB_##_write);
devcb = &downcast<dave_device &>(*device).set_rh_wr_callback(DEVCB_##_write);
@ -55,9 +55,9 @@ class dave_device : public device_t,
public:
dave_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_irq_wr_callback(device_t &device, Object &&cb) { return downcast<dave_device &>(device).m_write_irq.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_lh_wr_callback(device_t &device, Object &&cb) { return downcast<dave_device &>(device).m_write_lh.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_rh_wr_callback(device_t &device, Object &&cb) { return downcast<dave_device &>(device).m_write_rh.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_irq_wr_callback(Object &&cb) { return m_write_irq.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_lh_wr_callback(Object &&cb) { return m_write_lh.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_rh_wr_callback(Object &&cb) { return m_write_rh.set_callback(std::forward<Object>(cb)); }
virtual void z80_program_map(address_map &map);
virtual void z80_io_map(address_map &map);

11
src/devices/sound/discrete.cpp
View File

@ -823,17 +823,6 @@ int discrete_device::same_module_index(const discrete_base_node &node)
// DEVICE CONFIGURATION
//**************************************************************************
//-------------------------------------------------
// static_set_intf - configuration helper to set
// the interface
//-------------------------------------------------
void discrete_device::static_set_intf(device_t &device, const discrete_block *intf)
{
discrete_device &disc = downcast<discrete_device &>(device);
disc.m_intf = intf;
}
//-------------------------------------------------
// discrete_device - constructor
//-------------------------------------------------

4
src/devices/sound/discrete.h
View File

@ -4264,7 +4264,7 @@ public:
MCFG_DISCRETE_INTF(_intf)
#define MCFG_DISCRETE_INTF(_intf) \
discrete_device::static_set_intf(*device, (const discrete_block *)&(_intf##_discrete_interface));
downcast<discrete_device &>(*device).set_intf((const discrete_block *)&(_intf##_discrete_interface));
//**************************************************************************
// TYPE DEFINITIONS
@ -4286,7 +4286,7 @@ protected:
public:
// inline configuration helpers
static void static_set_intf(device_t &device, const discrete_block *intf);
void set_intf(const discrete_block *intf) { m_intf = intf; }
DECLARE_READ8_MEMBER(read);
DECLARE_WRITE8_MEMBER(write);

11
src/devices/sound/es5503.cpp
View File

@ -62,17 +62,6 @@ es5503_device::es5503_device(const machine_config &mconfig, const char *tag, dev
}
//-------------------------------------------------
// static_set_type - configuration helper to set
// the IRQ callback
//-------------------------------------------------
void es5503_device::static_set_channels(device_t &device, int channels)
{
es5503_device &es5503 = downcast<es5503_device &>(device);
es5503.output_channels = channels;
}
//-------------------------------------------------
// device_timer - called when our device timer expires
//-------------------------------------------------

12
src/devices/sound/es5503.h
View File

@ -11,13 +11,13 @@
MCFG_DEVICE_ADD(_tag, ES5503, _clock)
#define MCFG_ES5503_OUTPUT_CHANNELS(_channels) \
es5503_device::static_set_channels(*device, _channels);
downcast<es5503_device &>(*device).set_channels(_channels);
#define MCFG_ES5503_IRQ_FUNC(_write) \
devcb = &es5503_device::static_set_irqf(*device, DEVCB_##_write);
devcb = &downcast<es5503_device &>(*device).set_irqf(DEVCB_##_write);
#define MCFG_ES5503_ADC_FUNC(_read) \
devcb = &es5503_device::static_set_adcf(*device, DEVCB_##_read);
devcb = &downcast<es5503_device &>(*device).set_adcf(DEVCB_##_read);
// ======================> es5503_device
@ -29,10 +29,10 @@ public:
// construction/destruction
es5503_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void static_set_channels(device_t &device, int channels);
void set_channels(int channels) { output_channels = channels; }
template <class Object> static devcb_base &static_set_irqf(device_t &device, Object &&cb) { return downcast<es5503_device &>(device).m_irq_func.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &static_set_adcf(device_t &device, Object &&cb) { return downcast<es5503_device &>(device).m_adc_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_irqf(Object &&cb) { return m_irq_func.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_adcf(Object &&cb) { return m_adc_func.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER(read);
DECLARE_WRITE8_MEMBER(write);

38
src/devices/sound/es5506.h
View File

@ -15,53 +15,53 @@
#define ES5506_MAKE_WAVS 0
#define MCFG_ES5506_REGION0(_region) \
es5506_device::set_region0(*device, _region);
downcast<es5506_device &>(*device).set_region0(_region);
#define MCFG_ES5506_REGION1(_region) \
es5506_device::set_region1(*device, _region);
downcast<es5506_device &>(*device).set_region1(_region);
#define MCFG_ES5506_REGION2(_region) \
es5506_device::set_region2(*device, _region);
downcast<es5506_device &>(*device).set_region2(_region);
#define MCFG_ES5506_REGION3(_region) \
es5506_device::set_region3(*device, _region);
downcast<es5506_device &>(*device).set_region3(_region);
#define MCFG_ES5506_CHANNELS(_chan) \
es5506_device::set_channels(*device, _chan);
downcast<es5506_device &>(*device).set_channels(_chan);
#define MCFG_ES5506_IRQ_CB(_devcb) \
devcb = &es5506_device::set_irq_callback(*device, DEVCB_##_devcb);
devcb = &downcast<es5506_device &>(*device).set_irq_callback(DEVCB_##_devcb);
#define MCFG_ES5506_READ_PORT_CB(_devcb) \
devcb = &es5506_device::set_read_port_callback(*device, DEVCB_##_devcb);
devcb = &downcast<es5506_device &>(*device).set_read_port_callback(DEVCB_##_devcb);
#define MCFG_ES5505_REGION0(_region) \
es5505_device::set_region0(*device, _region);
downcast<es5505_device &>(*device).set_region0(_region);
#define MCFG_ES5505_REGION1(_region) \
es5505_device::set_region1(*device, _region);
downcast<es5505_device &>(*device).set_region1(_region);
#define MCFG_ES5505_CHANNELS(_chan) \
es5505_device::set_channels(*device, _chan);
downcast<es5505_device &>(*device).set_channels(_chan);
#define MCFG_ES5505_IRQ_CB(_devcb) \
devcb = &es5505_device::set_irq_callback(*device, DEVCB_##_devcb);
devcb = &downcast<es5505_device &>(*device).set_irq_callback(DEVCB_##_devcb);
#define MCFG_ES5505_READ_PORT_CB(_devcb) \
devcb = &es5505_device::set_read_port_callback(*device, DEVCB_##_devcb);
devcb = &downcast<es5505_device &>(*device).set_read_port_callback(DEVCB_##_devcb);
class es550x_device : public device_t, public device_sound_interface
{
public:
static void set_region0(device_t &device, const char *region0) { downcast<es550x_device &>(device).m_region0 = region0; }
static void set_region1(device_t &device, const char *region1) { downcast<es550x_device &>(device).m_region1 = region1; }
static void set_region2(device_t &device, const char *region2) { downcast<es550x_device &>(device).m_region2 = region2; }
static void set_region3(device_t &device, const char *region3) { downcast<es550x_device &>(device).m_region3 = region3; }
static void set_channels(device_t &device, int channels) { downcast<es550x_device &>(device).m_channels = channels; }
template <class Object> static devcb_base &set_irq_callback(device_t &device, Object &&cb) { return downcast<es550x_device &>(device).m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_read_port_callback(device_t &device, Object &&cb) { return downcast<es550x_device &>(device).m_read_port_cb.set_callback(std::forward<Object>(cb)); }
void set_region0(const char *region0) { m_region0 = region0; }
void set_region1(const char *region1) { m_region1 = region1; }
void set_region2(const char *region2) { m_region2 = region2; }
void set_region3(const char *region3) { m_region3 = region3; }
void set_channels(int channels) { m_channels = channels; }
template <class Object> devcb_base &set_irq_callback(Object &&cb) { return m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_read_port_callback(Object &&cb) { return m_read_port_cb.set_callback(std::forward<Object>(cb)); }
protected:
// struct describing a single playing voice

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

@ -16,7 +16,7 @@
#define MCFG_ES8712_REPLACE(_tag, _clock) \
MCFG_DEVICE_REPLACE(_tag, ES8712, _clock)
#define MCFG_ES8712_RESET_HANDLER(_devcb) \
devcb = &es8712_device::set_reset_handler(*device, DEVCB_##_devcb);
devcb = &downcast<es8712_device &>(*device).set_reset_handler(DEVCB_##_devcb);
//**************************************************************************
@ -31,8 +31,8 @@ class es8712_device : public device_t, public device_sound_interface
public:
es8712_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
template <class Object> static devcb_base &set_reset_handler(device_t &device, Object &&cb) { return downcast<es8712_device &>(device).m_reset_handler.set_callback(std::forward<Object>(cb)); }
// configuration
template <class Object> devcb_base &set_reset_handler(Object &&cb) { return m_reset_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER(write);
DECLARE_READ8_MEMBER(read);

21
src/devices/sound/flt_rc.cpp
View File

@ -116,24 +116,3 @@ void filter_rc_device::recalc()
/* k = (1-(EXP(-TIMEDELTA/RC))) */
m_k = 0x10000 - 0x10000 * (exp(-1 / (Req * m_C) / machine().sample_rate()));
}
void filter_rc_device::filter_rc_set_RC(int type, double R1, double R2, double R3, double C)
{
m_stream->update();
m_type = type;
m_R1 = R1;
m_R2 = R2;
m_R3 = R3;
m_C = C;
recalc();
}
void filter_rc_device::static_set_rc(device_t &device, int type, double R1, double R2, double R3, double C)
{
downcast<filter_rc_device &>(device).m_type = type;
downcast<filter_rc_device &>(device).m_R1 = R1;
downcast<filter_rc_device &>(device).m_R2 = R2;
downcast<filter_rc_device &>(device).m_R3 = R3;
downcast<filter_rc_device &>(device).m_C = C;
}

20
src/devices/sound/flt_rc.h
View File

@ -53,7 +53,7 @@
MCFG_DEVICE_REPLACE(_tag, FILTER_RC, _clock)
#define MCFG_FILTER_RC_AC() \
filter_rc_device::static_set_rc(*device, filter_rc_device::AC, 10000, 0, 0, CAP_U(1));
downcast<filter_rc_device &>(*device).set_rc(filter_rc_device::AC, 10000, 0, 0, CAP_U(1));
//**************************************************************************
@ -74,10 +74,22 @@ public:
filter_rc_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void static_set_rc(device_t &device, int type, double R1, double R2, double R3, double C);
// configuration
void set_rc(int type, double R1, double R2, double R3, double C)
{
m_type = type;
m_R1 = R1;
m_R2 = R2;
m_R3 = R3;
m_C = C;
}
void filter_rc_set_RC(int type, double R1, double R2, double R3, double C);
void filter_rc_set_RC(int type, double R1, double R2, double R3, double C)
{
m_stream->update();
set_rc(type, R1, R2, R3, C);
recalc();
}
protected:
// device-level overrides

17
src/devices/sound/gaelco.h
View File

@ -11,10 +11,10 @@
//**************************************************************************
#define MCFG_GAELCO_SND_DATA(_tag) \
gaelco_gae1_device::set_snd_data_tag(*device, "^" _tag);
downcast<gaelco_gae1_device &>(*device).set_snd_data_tag("^" _tag);
#define MCFG_GAELCO_BANKS(_offs1, _offs2, _offs3, _offs4) \
gaelco_gae1_device::set_bank_offsets(*device, _offs1, _offs2, _offs3, _offs4);
downcast<gaelco_gae1_device &>(*device).set_bank_offsets(_offs1, _offs2, _offs3, _offs4);
//**************************************************************************
@ -30,14 +30,13 @@ class gaelco_gae1_device : public device_t,
public:
gaelco_gae1_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_snd_data_tag(device_t &device, const char *tag) { downcast<gaelco_gae1_device &>(device).m_snd_data.set_tag(tag); }
static void set_bank_offsets(device_t &device, int offs1, int offs2, int offs3, int offs4)
void set_snd_data_tag(const char *tag) { m_snd_data.set_tag(tag); }
void set_bank_offsets(int offs1, int offs2, int offs3, int offs4)
{
gaelco_gae1_device &dev = downcast<gaelco_gae1_device &>(device);
dev.m_banks[0] = offs1;
dev.m_banks[1] = offs2;
dev.m_banks[2] = offs3;
dev.m_banks[3] = offs4;
m_banks[0] = offs1;
m_banks[1] = offs2;
m_banks[2] = offs3;
m_banks[3] = offs4;
}
DECLARE_WRITE16_MEMBER( gaelcosnd_w );

4
src/devices/sound/ics2115.h
View File

@ -14,7 +14,7 @@
MCFG_DEVICE_ADD(_tag, ICS2115, _clock)
#define MCFG_ICS2115_IRQ_CB(_devcb) \
devcb = &ics2115_device::set_irq_callback(*device, DEVCB_##_devcb);
devcb = &downcast<ics2115_device &>(*device).set_irq_callback(DEVCB_##_devcb);
//**************************************************************************
// TYPE DEFINITIONS
@ -28,7 +28,7 @@ public:
// construction/destruction
ics2115_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_irq_callback(device_t &device, Object &&cb) { return downcast<ics2115_device &>(device).m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_irq_callback(Object &&cb) { return m_irq_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER(read);
DECLARE_WRITE8_MEMBER(write);

4
src/devices/sound/k007232.h
View File

@ -10,7 +10,7 @@
#pragma once
#define MCFG_K007232_PORT_WRITE_HANDLER(_devcb) \
devcb = &k007232_device::set_port_write_handler(*device, DEVCB_##_devcb);
devcb = &downcast<k007232_device &>(*device).set_port_write_handler(DEVCB_##_devcb);
class k007232_device : public device_t, public device_sound_interface
@ -18,7 +18,7 @@ class k007232_device : public device_t, public device_sound_interface
public:
k007232_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_port_write_handler(device_t &device, Object &&cb) { return downcast<k007232_device &>(device).m_port_write_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_port_write_handler(Object &&cb) { return m_port_write_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER( write );
DECLARE_READ8_MEMBER( read );

12
src/devices/sound/k054539.h
View File

@ -14,13 +14,13 @@
#define K054539_CB_MEMBER(_name) void _name(double left, double right)
#define MCFG_K054539_APAN_CB(_class, _method) \
k054539_device::set_analog_callback(*device, k054539_device::cb_delegate(&_class::_method, #_class "::" #_method, this));
downcast<k054539_device &>(*device).set_analog_callback(k054539_device::cb_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_K054539_REGION_OVERRRIDE(_region) \
k054539_device::set_override(*device, "^" _region);
downcast<k054539_device &>(*device).set_override("^" _region);
#define MCFG_K054539_TIMER_HANDLER(_devcb) \
devcb = &k054539_device::set_timer_handler(*device, DEVCB_##_devcb);
devcb = &downcast<k054539_device &>(*device).set_timer_handler(DEVCB_##_devcb);
class k054539_device : public device_t,
@ -41,9 +41,9 @@ public:
// construction/destruction
k054539_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
static void set_analog_callback(device_t &device, cb_delegate &&cb) { downcast<k054539_device &>(device).m_apan_cb = std::move(cb); }
template <class Object> static devcb_base &set_timer_handler(device_t &device, Object &&cb) { return downcast<k054539_device &>(device).m_timer_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <typename Object> void set_analog_callback(Object &&cb) { m_apan_cb = std::forward<Object>(cb); }
template <class Object> devcb_base &set_timer_handler(Object &&cb) { return m_timer_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER(write);

8
src/devices/sound/k056800.h
View File

@ -15,10 +15,10 @@
***************************************************************************/
#define MCFG_K056800_ADD(tag, clock) \
MCFG_DEVICE_ADD((tag), K056800, (clock))
MCFG_DEVICE_ADD((tag), K056800, (clock))
#define MCFG_K056800_INT_HANDLER(cb) \
devcb = &k056800_device::set_int_handler(*device, (DEVCB_##cb));
devcb = &downcast<k056800_device &>(*device).set_int_handler((DEVCB_##cb));
@ -32,8 +32,8 @@ public:
// construction/destruction
k056800_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_int_handler(device_t &device, Object &&cb) { return downcast<k056800_device &>(device).m_int_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_int_handler(Object &&cb) { return m_int_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( host_r );
DECLARE_WRITE8_MEMBER( host_w );

10
src/devices/sound/lc7535.h
View File

@ -35,10 +35,10 @@
MCFG_DEVICE_ADD(_tag, LC7535, 0)
#define MCFG_LC7535_SELECT_CB(_read) \
devcb = &lc7535_device::set_select_callback(*device, DEVCB_##_read);
devcb = &downcast<lc7535_device &>(*device).set_select_callback(DEVCB_##_read);
#define MCFG_LC7535_VOLUME_CB(_class, _method) \
lc7535_device::set_volume_callback(*device, lc7535_device::volume_delegate(&_class::_method, #_class "::" #_method, this));
downcast<lc7535_device &>(*device).set_volume_callback(lc7535_device::volume_delegate(&_class::_method, #_class "::" #_method, this));
#define LC7535_VOLUME_CHANGED(name) void name(int attenuation_right, int attenuation_left, bool loudness)
@ -55,11 +55,9 @@ public:
typedef device_delegate<void (int attenuation_right, int attenuation_left, bool loudness)> volume_delegate;
static void set_volume_callback(device_t &device, volume_delegate &&cb)
{ downcast<lc7535_device &>(device).m_volume_cb = std::move(cb); }
template <typename Object> void set_volume_callback(Object &&cb) { m_volume_cb = std::forward<Object>(cb); }
template <class Object> static devcb_base &set_select_callback(device_t &device, Object &&cb)
{ return downcast<lc7535_device &>(device).m_select_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_select_callback(Object &&cb) { return m_select_cb.set_callback(std::forward<Object>(cb)); }
// serial interface
DECLARE_WRITE_LINE_MEMBER( ce_w );

4
src/devices/sound/mea8000.h
View File

@ -14,7 +14,7 @@
#pragma once
#define MCFG_MEA8000_REQ_CALLBACK(_write) \
devcb = &mea8000_device::set_reqwr_callback(*device, DEVCB_##_write);
devcb = &downcast<mea8000_device &>(*device).set_reqwr_callback(*device, DEVCB_##_write);
/* define to use double instead of int (slow but useful for debugging) */
#undef MEA8000_FLOAT_MODE
@ -25,7 +25,7 @@ class mea8000_device : public device_t, public device_sound_interface
public:
mea8000_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_req_wr_callback(device_t &device, Object &&cb) { return downcast<mea8000_device &>(device).m_write_req.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_req_wr_callback(Object &&cb) { return m_write_req.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER(read);
DECLARE_WRITE8_MEMBER(write);

9
src/devices/sound/mm5837.h
View File

@ -29,10 +29,10 @@
MCFG_DEVICE_ADD(_tag, MM5837, 0)
#define MCFG_MM5837_VDD(_voltage) \
mm5837_device::set_vdd_voltage(*device, _voltage);
downcast<mm5837_device &>(*device).set_vdd_voltage(_voltage);
#define MCFG_MM5837_OUTPUT_CB(_devcb) \
devcb = &mm5837_device::set_output_callback(*device, DEVCB_##_devcb);
devcb = &downcast<mm5837_device &>(*device).set_output_callback(DEVCB_##_devcb);
//**************************************************************************
@ -46,9 +46,8 @@ public:
mm5837_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// configuration
static void set_vdd_voltage(device_t &device, int voltage) { downcast<mm5837_device &>(device).m_vdd = voltage; }
template <class Object> static devcb_base &set_output_callback(device_t &device, Object &&cb)
{ return downcast<mm5837_device &>(device).m_output_cb.set_callback(std::forward<Object>(cb)); }
void set_vdd_voltage(int voltage) { m_vdd = voltage; }
template <class Object> devcb_base &set_output_callback(Object &&cb) { return m_output_cb.set_callback(std::forward<Object>(cb)); }
protected:
// device-level overrides

8
src/devices/sound/mos6560.h
View File

@ -79,10 +79,10 @@
#define MCFG_MOS6560_POTX_CALLBACK(_read) \
devcb = &mos6560_device::set_potx_rd_callback(*device, DEVCB_##_read);
devcb = &downcast<mos6560_device &>(*device).set_potx_rd_callback(DEVCB_##_read);
#define MCFG_MOS6560_POTY_CALLBACK(_read) \
devcb = &mos6560_device::set_poty_rd_callback(*device, DEVCB_##_read);
devcb = &downcast<mos6560_device &>(*device).set_poty_rd_callback(DEVCB_##_read);
@ -136,8 +136,8 @@ class mos6560_device : public device_t,
public:
mos6560_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_potx_rd_callback(device_t &device, Object &&cb) { return downcast<mos6560_device &>(device).m_read_potx.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_poty_rd_callback(device_t &device, Object &&cb) { return downcast<mos6560_device &>(device).m_read_poty.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_potx_rd_callback(Object &&cb) { return m_read_potx.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_poty_rd_callback(Object &&cb) { return m_read_poty.set_callback(std::forward<Object>(cb)); }
virtual space_config_vector memory_space_config() const override;

8
src/devices/sound/mos6581.h
View File

@ -36,10 +36,10 @@
//**************************************************************************
#define MCFG_MOS6581_POTX_CALLBACK(_read) \
devcb = &mos6581_device::set_potx_rd_callback(*device, DEVCB_##_read);
devcb = &downcast<mos6581_device &>(*device).set_potx_rd_callback(DEVCB_##_read);
#define MCFG_MOS6581_POTY_CALLBACK(_read) \
devcb = &mos6581_device::set_poty_rd_callback(*device, DEVCB_##_read);
devcb = &downcast<mos6581_device &>(*device).set_poty_rd_callback(DEVCB_##_read);
@ -64,8 +64,8 @@ public:
mos6581_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
~mos6581_device();
template <class Object> static devcb_base &set_potx_rd_callback(device_t &device, Object &&cb) { return downcast<mos6581_device &>(device).m_read_potx.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_poty_rd_callback(device_t &device, Object &&cb) { return downcast<mos6581_device &>(device).m_read_poty.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_potx_rd_callback(Object &&cb) { return m_read_potx.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_poty_rd_callback(Object &&cb) { return m_read_poty.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

12
src/devices/sound/msm5205.cpp
View File

@ -83,18 +83,6 @@ msm6585_device::msm6585_device(const machine_config &mconfig, const char *tag, d
{
}
//-------------------------------------------------
// set_prescaler_selector - configuration helper
//-------------------------------------------------
void msm5205_device::set_prescaler_selector(device_t &device, int select)
{
msm5205_device &msm = downcast<msm5205_device &>(device);
msm.m_s1 = BIT(select, 1);
msm.m_s2 = BIT(select, 0);
msm.m_bitwidth = (select & 4) ? 4 : 3;
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------

21
src/devices/sound/msm5205.h
View File

@ -8,19 +8,19 @@
/* an interface for the MSM5205 and similar chips */
#define MCFG_MSM5205_PRESCALER_SELECTOR(select) \
msm5205_device::set_prescaler_selector(*device, (msm5205_device::select));
downcast<msm5205_device &>(*device).set_prescaler_selector((msm5205_device::select));
#define MCFG_MSM5205_VCK_CALLBACK(cb) \
devcb = &msm5205_device::set_vck_callback(*device, (DEVCB_##cb));
devcb = &downcast<msm5205_device &>(*device).set_vck_callback((DEVCB_##cb));
#define MCFG_MSM5205_VCLK_CB(cb) \
devcb = &msm5205_device::set_vck_legacy_callback(*device, (DEVCB_##cb));
devcb = &downcast<msm5205_device &>(*device).set_vck_legacy_callback((DEVCB_##cb));
#define MCFG_MSM6585_PRESCALER_SELECTOR(select) \
msm6585_device::set_prescaler_selector(*device, (msm6585_device::select));
downcast<msm5205_device &>(*device).set_prescaler_selector((msm6585_device::select));
#define MCFG_MSM6585_VCK_CALLBACK(cb) \
devcb = &msm6585_device::set_vck_callback(*device, (DEVCB_##cb));
devcb = &downcast<msm5205_device &>(*device).set_vck_callback((DEVCB_##cb));
class msm5205_device : public device_t, public device_sound_interface
@ -38,9 +38,14 @@ public:
msm5205_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
static void set_prescaler_selector(device_t &device, int select);
template <class Object> static devcb_base &set_vck_callback(device_t &device, Object &&cb) { return downcast<msm5205_device &>(device).m_vck_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_vck_legacy_callback(device_t &device, Object &&cb) { return downcast<msm5205_device &>(device).m_vck_legacy_cb.set_callback(std::forward<Object>(cb)); }
void set_prescaler_selector(int select)
{
m_s1 = BIT(select, 1);
m_s2 = BIT(select, 0);
m_bitwidth = (select & 4) ? 4 : 3;
}
template <class Object> devcb_base &set_vck_callback(Object &&cb) { return m_vck_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_vck_legacy_callback(Object &&cb) { return m_vck_legacy_cb.set_callback(std::forward<Object>(cb)); }
// reset signal should keep for 2cycle of VCLK
DECLARE_WRITE_LINE_MEMBER(reset_w);

19
src/devices/sound/msm5232.cpp
View File

@ -128,17 +128,16 @@ void msm5232_device::device_stop()
#endif
}
void msm5232_device::static_set_capacitors(device_t &device, double cap1, double cap2, double cap3, double cap4, double cap5, double cap6, double cap7, double cap8)
void msm5232_device::set_capacitors(double cap1, double cap2, double cap3, double cap4, double cap5, double cap6, double cap7, double cap8)
{
msm5232_device &msm = downcast<msm5232_device &>(device);
msm.m_external_capacity[0] = cap1;
msm.m_external_capacity[1] = cap2;
msm.m_external_capacity[2] = cap3;
msm.m_external_capacity[3] = cap4;
msm.m_external_capacity[4] = cap5;
msm.m_external_capacity[5] = cap6;
msm.m_external_capacity[6] = cap7;
msm.m_external_capacity[7] = cap8;
m_external_capacity[0] = cap1;
m_external_capacity[1] = cap2;
m_external_capacity[2] = cap3;
m_external_capacity[3] = cap4;
m_external_capacity[4] = cap5;
m_external_capacity[5] = cap6;
m_external_capacity[6] = cap7;
m_external_capacity[7] = cap8;
}
/* Default chip clock is 2119040 Hz */

8
src/devices/sound/msm5232.h
View File

@ -7,10 +7,10 @@
#define MCFG_MSM5232_SET_CAPACITORS(_a, _b, _c, _d, _e, _f, _g, _h) \
msm5232_device::static_set_capacitors(*device, _a, _b, _c, _d, _e, _f, _g, _h);
downcast<msm5232_device &>(*device).set_capacitors(_a, _b, _c, _d, _e, _f, _g, _h);
#define MCFG_MSM5232_GATE_HANDLER_CB(_devcb) \
devcb = &msm5232_device::set_gate_handler_callback(*device, DEVCB_##_devcb);
devcb = &downcast<msm5232_device &>(*device).set_gate_handler_callback(DEVCB_##_devcb);
class msm5232_device : public device_t,
@ -19,8 +19,8 @@ class msm5232_device : public device_t,
public:
msm5232_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void static_set_capacitors(device_t &device, double cap1, double cap2, double cap3, double cap4, double cap5, double cap6, double cap7, double cap8);
template <class Object> static devcb_base &set_gate_handler_callback(device_t &device, Object &&cb) { return downcast<msm5232_device &>(device).m_gate_handler_cb.set_callback(std::forward<Object>(cb)); }
void set_capacitors(double cap1, double cap2, double cap3, double cap4, double cap5, double cap6, double cap7, double cap8);
template <class Object> devcb_base &set_gate_handler_callback(Object &&cb) { return m_gate_handler_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER( write );
void set_clock(int clock);

10
src/devices/sound/namco.h
View File

@ -7,19 +7,19 @@
#define MCFG_NAMCO_AUDIO_VOICES(_voices) \
namco_audio_device::set_voices(*device, _voices);
downcast<namco_audio_device &>(*device).set_voices(_voices);
#define MCFG_NAMCO_AUDIO_STEREO(_stereo) \
namco_audio_device::set_stereo(*device, _stereo);
downcast<namco_audio_device &>(*device).set_stereo(_stereo);
class namco_audio_device : public device_t,
public device_sound_interface
{
public:
// static configuration
static void set_voices(device_t &device, int voices) { downcast<namco_audio_device &>(device).m_voices = voices; }
static void set_stereo(device_t &device, int stereo) { downcast<namco_audio_device &>(device).m_stereo = stereo; }
// configuration
void set_voices(int voices) { m_voices = voices; }
void set_stereo(int stereo) { m_stereo = stereo; }
protected:
static constexpr unsigned MAX_VOICES = 8;

10
src/devices/sound/nes_apu.h
View File

@ -40,10 +40,10 @@
*/
#define MCFG_NES_APU_IRQ_HANDLER(_devcb) \
devcb = &nesapu_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<nesapu_device &>(*device).set_irq_handler(DEVCB_##_devcb);
#define MCFG_NES_APU_MEM_READ_CALLBACK(_devcb) \
devcb = &nesapu_device::set_mem_read_callback(*device, DEVCB_##_devcb);
devcb = &downcast<nesapu_device &>(*device).set_mem_read_callback(DEVCB_##_devcb);
class nesapu_device : public device_t,
public device_sound_interface
@ -51,9 +51,9 @@ class nesapu_device : public device_t,
public:
nesapu_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<nesapu_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_mem_read_callback(device_t &device, Object &&cb) { return downcast<nesapu_device &>(device).m_mem_read_cb.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_mem_read_callback(Object &&cb) { return m_mem_read_cb.set_callback(std::forward<Object>(cb)); }
virtual void device_clock_changed() override;

18
src/devices/sound/okim6258.h
View File

@ -11,19 +11,19 @@
//**************************************************************************
#define MCFG_OKIM6258_ADD(tag, clock) \
MCFG_DEVICE_ADD((tag), OKIM6258, (clock))
MCFG_DEVICE_ADD((tag), OKIM6258, (clock))
#define MCFG_OKIM6258_REPLACE(tag, clock) \
MCFG_DEVICE_REPLACE((tag), OKIM6258, (clock))
MCFG_DEVICE_REPLACE((tag), OKIM6258, (clock))
#define MCFG_OKIM6258_DIVIDER(div) \
okim6258_device::set_start_div(*device, (okim6258_device::div));
downcast<okim6258_device &>(*device).set_start_div((okim6258_device::div));
#define MCFG_OKIM6258_ADPCM_TYPE(type) \
okim6258_device::set_type(*device, (okim6258_device::type));
downcast<okim6258_device &>(*device).set_type((okim6258_device::type));
#define MCFG_OKIM6258_OUT_BITS(bits) \
okim6258_device::set_outbits(*device, (okim6258_device::bits));
downcast<okim6258_device &>(*device).set_outbits((okim6258_device::bits));
//**************************************************************************
@ -48,10 +48,10 @@ public:
okim6258_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void set_start_div(device_t &device, int div) { downcast<okim6258_device &>(device).m_start_divider = div; }
static void set_type(device_t &device, int type) { downcast<okim6258_device &>(device).m_adpcm_type = type; }
static void set_outbits(device_t &device, int outbit) { downcast<okim6258_device &>(device).m_output_bits = outbit; }
// configuration
void set_start_div(int div) { m_start_divider = div; }
void set_type(int type) { m_adpcm_type = type; }
void set_outbits(int outbit) { m_output_bits = outbit; }
DECLARE_READ8_MEMBER( status_r );
DECLARE_WRITE8_MEMBER( data_w );

12
src/devices/sound/okim6295.cpp
View File

@ -97,18 +97,6 @@ okim6295_device::okim6295_device(const machine_config &mconfig, const char *tag,
}
//-------------------------------------------------
// static_set_pin7 - configuration helper to set
// the pin 7 state
//-------------------------------------------------
void okim6295_device::static_set_pin7(device_t &device, int pin7)
{
okim6295_device &okim6295 = downcast<okim6295_device &>(device);
okim6295.m_pin7_state = pin7;
}
//-------------------------------------------------
// device_start - device-specific startup
//-------------------------------------------------

12
src/devices/sound/okim6295.h
View File

@ -22,15 +22,15 @@
//**************************************************************************
#define MCFG_OKIM6295_ADD(tag, clock, pin7) \
MCFG_DEVICE_ADD((tag), OKIM6295, (clock)) \
MCFG_OKIM6295_PIN7(pin7)
MCFG_DEVICE_ADD((tag), OKIM6295, (clock)) \
MCFG_OKIM6295_PIN7(pin7)
#define MCFG_OKIM6295_REPLACE(tag, clock, pin7) \
MCFG_DEVICE_REPLACE((tag), OKIM6295, (clock)) \
MCFG_OKIM6295_PIN7(pin7)
MCFG_DEVICE_REPLACE((tag), OKIM6295, (clock)) \
MCFG_OKIM6295_PIN7(pin7)
#define MCFG_OKIM6295_PIN7(pin7) \
okim6295_device::static_set_pin7(*device, (okim6295_device::pin7));
downcast<okim6295_device &>(*device).config_pin7((okim6295_device::pin7));
//**************************************************************************
@ -55,7 +55,7 @@ public:
okim6295_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// inline configuration helpers
static void static_set_pin7(device_t &device, int pin7);
void config_pin7(int pin7) { m_pin7_state = pin7; }
// runtime configuration
void set_pin7(int pin7);

38
src/devices/sound/pokey.h
View File

@ -59,45 +59,45 @@
//**************************************************************************
#define MCFG_POKEY_POT0_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<0>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<0>(DEVCB_##_devcb);
#define MCFG_POKEY_POT1_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<1>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<1>(DEVCB_##_devcb);
#define MCFG_POKEY_POT2_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<2>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<2>(DEVCB_##_devcb);
#define MCFG_POKEY_POT3_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<3>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<3>(DEVCB_##_devcb);
#define MCFG_POKEY_POT4_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<4>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<4>(DEVCB_##_devcb);
#define MCFG_POKEY_POT5_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<5>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<5>(DEVCB_##_devcb);
#define MCFG_POKEY_POT6_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<6>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<6>(DEVCB_##_devcb);
#define MCFG_POKEY_POT7_R_CB(_devcb) \
devcb = &pokey_device::set_pot_r_callback<7>(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_pot_r_callback<7>(DEVCB_##_devcb);
#define MCFG_POKEY_ALLPOT_R_CB(_devcb) \
devcb = &pokey_device::set_allpot_r_callback(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_allpot_r_callback(DEVCB_##_devcb);
#define MCFG_POKEY_SERIN_R_CB(_devcb) \
devcb = &pokey_device::set_serin_r_callback(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_serin_r_callback(DEVCB_##_devcb);
#define MCFG_POKEY_SEROUT_W_CB(_devcb) \
devcb = &pokey_device::set_serout_w_callback(*device, DEVCB_##_devcb);
devcb = &downcast<pokey_device &>(*device).set_serout_w_callback(DEVCB_##_devcb);
/* k543210 = k5 ... k0 returns bit0: kr1, bit1: kr2 */
/* all are, in contrast to actual hardware, ACTIVE_HIGH */
#define MCFG_POKEY_KEYBOARD_CB(_class, _method) \
pokey_device::set_keyboard_callback(*device, pokey_device::kb_cb_delegate(&_class::_method, #_class "::" #_method, this));
downcast<pokey_device &>(*device).set_keyboard_callback(pokey_device::kb_cb_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_POKEY_INTERRUPT_CB(_class, _method) \
pokey_device::set_interrupt_callback(*device, pokey_device::int_cb_delegate(&_class::_method, #_class "::" #_method, this));
downcast<pokey_device &>(*device).set_interrupt_callback(pokey_device::int_cb_delegate(&_class::_method, #_class "::" #_method, this));
#define MCFG_POKEY_OUTPUT_RC(_R, _C, _V) \
@ -210,13 +210,13 @@ public:
// construction/destruction
pokey_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <unsigned N, class Object> static devcb_base &set_pot_r_callback(device_t &device, Object &&cb) { return downcast<pokey_device &>(device).m_pot_r_cb[N].set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_allpot_r_callback(device_t &device, Object &&cb) { return downcast<pokey_device &>(device).m_allpot_r_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_serin_r_callback(device_t &device, Object &&cb) { return downcast<pokey_device &>(device).m_serin_r_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_serout_w_callback(device_t &device, Object &&cb) { return downcast<pokey_device &>(device).m_serout_w_cb.set_callback(std::forward<Object>(cb)); }
template <unsigned N, class Object> devcb_base &set_pot_r_callback(Object &&cb) { return m_pot_r_cb[N].set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_allpot_r_callback(Object &&cb) { return m_allpot_r_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_serin_r_callback(Object &&cb) { return m_serin_r_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_serout_w_callback(Object &&cb) { return m_serout_w_cb.set_callback(std::forward<Object>(cb)); }
static void set_keyboard_callback(device_t &device, kb_cb_delegate &&cb) { downcast<pokey_device &>(device).m_keyboard_r = std::move(cb); }
static void set_interrupt_callback(device_t &device, int_cb_delegate &&cb) { downcast<pokey_device &>(device).m_irq_f = std::move(cb); }
template <typename Object> void set_keyboard_callback(Object &&cb) { m_keyboard_r = std::forward<Object>(cb); }
template <typename Object> void set_interrupt_callback(Object &&cb) { m_irq_f = std::forward<Object>(cb); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

32
src/devices/sound/qs1000.h
View File

@ -21,28 +21,28 @@
//**************************************************************************
#define MCFG_QS1000_EXTERNAL_ROM(_bool) \
qs1000_device::set_external_rom(*device, _bool);
downcast<qs1000_device &>(*device).set_external_rom(_bool);
#define MCFG_QS1000_IN_P1_CB(_devcb) \
devcb = &qs1000_device::set_in_p1_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_in_p1_callback(DEVCB_##_devcb);
#define MCFG_QS1000_IN_P2_CB(_devcb) \
devcb = &qs1000_device::set_in_p2_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_in_p2_callback(DEVCB_##_devcb);
#define MCFG_QS1000_IN_P3_CB(_devcb) \
devcb = &qs1000_device::set_in_p3_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_in_p3_callback(DEVCB_##_devcb);
#define MCFG_QS1000_OUT_P1_CB(_devcb) \
devcb = &qs1000_device::set_out_p1_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_out_p1_callback(DEVCB_##_devcb);
#define MCFG_QS1000_OUT_P2_CB(_devcb) \
devcb = &qs1000_device::set_out_p2_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_out_p2_callback(DEVCB_##_devcb);
#define MCFG_QS1000_OUT_P3_CB(_devcb) \
devcb = &qs1000_device::set_out_p3_callback(*device, DEVCB_##_devcb);
devcb = &downcast<qs1000_device &>(*device).set_out_p3_callback(DEVCB_##_devcb);
/*#define MCFG_QS1000_SERIAL_W_CB(_devcb) \
devcb = &qs1000_device::set_serial_w_callback(*device, DEVCB_##_devcb);*/
devcb = &downcast<qs1000_device &>(*device).set_serial_w_callback(DEVCB_##_devcb);*/
//**************************************************************************
// TYPE DEFINITIONS
@ -58,14 +58,14 @@ public:
// construction/destruction
qs1000_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_external_rom(device_t &device, bool external_rom) { downcast<qs1000_device &>(device).m_external_rom = external_rom; }
template <class Object> static devcb_base &set_in_p1_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_in_p1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_in_p2_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_in_p2_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_in_p3_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_in_p3_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_out_p1_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_out_p1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_out_p2_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_out_p2_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_out_p3_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_out_p3_cb.set_callback(std::forward<Object>(cb)); }
//template <class Object> static devcb_base &set_serial_w_callback(device_t &device, Object &&cb) { return downcast<qs1000_device &>(device).m_serial_w_cb.set_callback(std::forward<Object>(cb)); }
void set_external_rom(bool external_rom) { m_external_rom = external_rom; }
template <class Object> devcb_base &set_in_p1_callback(Object &&cb) { return m_in_p1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_p2_callback(Object &&cb) { return m_in_p2_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_in_p3_callback(Object &&cb) { return m_in_p3_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_p1_callback(Object &&cb) { return m_out_p1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_p2_callback(Object &&cb) { return m_out_p2_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_out_p3_callback(Object &&cb) { return m_out_p3_cb.set_callback(std::forward<Object>(cb)); }
//template <class Object> devcb_base &set_serial_w_callback(Object &&cb) { return m_serial_w_cb.set_callback(std::forward<Object>(cb)); }
// external
void serial_in(uint8_t data);

4
src/devices/sound/rf5c68.h
View File

@ -20,7 +20,7 @@
MCFG_DEVICE_REPLACE(_tag, RF5C68, _clock)
#define MCFG_RF5C68_SAMPLE_END_CB(_class, _method) \
rf5c68_device::set_end_callback(*device, rf5c68_device::sample_end_cb_delegate(&_class::_method, #_class "::" #_method, this));
downcast<rf5c68_device &>(*device).set_end_callback(rf5c68_device::sample_end_cb_delegate(&_class::_method, #_class "::" #_method, this));
//**************************************************************************
// TYPE DEFINITIONS
@ -39,7 +39,7 @@ public:
rf5c68_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_end_callback(device_t &device, sample_end_cb_delegate &&cb) { downcast<rf5c68_device &>(device).m_sample_end_cb = std::move(cb); }
template <typename Object> void set_end_callback(Object &&cb) { m_sample_end_cb = std::forward<Object>(cb); }
DECLARE_READ8_MEMBER( rf5c68_r );
DECLARE_WRITE8_MEMBER( rf5c68_w );

10
src/devices/sound/s14001a.h
View File

@ -9,10 +9,10 @@
#define MAME_SOUND_S14001A_H
#define MCFG_S14001A_BSY_HANDLER(_devcb) \
devcb = &s14001a_device::set_bsy_handler(*device, DEVCB_##_devcb);
devcb = &downcast<s14001a_device &>(*device).set_bsy_handler(DEVCB_##_devcb);
#define MCFG_S14001A_EXT_READ_HANDLER(_devcb) \
devcb = &s14001a_device::set_ext_read_handler(*device, DEVCB_##_devcb);
devcb = &downcast<s14001a_device &>(*device).set_ext_read_handler(DEVCB_##_devcb);
class s14001a_device : public device_t, public device_sound_interface
@ -20,9 +20,9 @@ class s14001a_device : public device_t, public device_sound_interface
public:
s14001a_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_bsy_handler(device_t &device, Object &&cb) { return downcast<s14001a_device &>(device).m_bsy_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_ext_read_handler(device_t &device, Object &&cb) { return downcast<s14001a_device &>(device).m_ext_read_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_bsy_handler(Object &&cb) { return m_bsy_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_ext_read_handler(Object &&cb) { return m_ext_read_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ_LINE_MEMBER(busy_r); // /BUSY (pin 40)
DECLARE_READ_LINE_MEMBER(romen_r); // ROM /EN (pin 9)

14
src/devices/sound/samples.h
View File

@ -28,15 +28,15 @@ DECLARE_DEVICE_TYPE(SAMPLES, samples_device)
//**************************************************************************
#define MCFG_SAMPLES_CHANNELS(_channels) \
samples_device::static_set_channels(*device, _channels);
downcast<samples_device &>(*device).set_channels(_channels);
#define MCFG_SAMPLES_NAMES(_names) \
samples_device::static_set_samples_names(*device, _names);
downcast<samples_device &>(*device).set_samples_names(_names);
#define SAMPLES_START_CB_MEMBER(_name) void _name()
#define MCFG_SAMPLES_START_CB(_class, _method) \
samples_device::set_samples_start_callback(*device, samples_device::start_cb_delegate(&_class::_method, #_class "::" #_method, this));
downcast<samples_device &>(*device).set_samples_start_callback(samples_device::start_cb_delegate(&_class::_method, #_class "::" #_method, this));
//**************************************************************************
// TYPE DEFINITIONS
@ -53,10 +53,10 @@ public:
// construction/destruction
samples_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
static void static_set_channels(device_t &device, uint8_t channels) { downcast<samples_device &>(device).m_channels = channels; }
static void static_set_samples_names(device_t &device, const char *const *names) { downcast<samples_device &>(device).m_names = names; }
static void set_samples_start_callback(device_t &device, start_cb_delegate &&cb) { downcast<samples_device &>(device).m_samples_start_cb = std::move(cb); }
// configuration helpers
void set_channels(uint8_t channels) { m_channels = channels; }
void set_samples_names(const char *const *names) { m_names = names; }
template <typename Object> void set_samples_start_callback(Object &&cb) { m_samples_start_cb = std::forward<Object>(cb); }
// getters
bool playing(uint8_t channel) const;

16
src/devices/sound/scsp.h
View File

@ -16,16 +16,16 @@
#define MCFG_SCSP_ROFFSET(_offs) \
scsp_device::set_roffset(*device, _offs);
downcast<scsp_device &>(*device).set_roffset(_offs);
#define MCFG_SCSP_IRQ_CB(_devcb) \
devcb = &scsp_device::set_irq_callback(*device, DEVCB_##_devcb);
devcb = &downcast<scsp_device &>(*device).set_irq_callback(DEVCB_##_devcb);
#define MCFG_SCSP_MAIN_IRQ_CB(_devcb) \
devcb = &scsp_device::set_main_irq_callback(*device, DEVCB_##_devcb);
devcb = &downcast<scsp_device &>(*device).set_main_irq_callback(DEVCB_##_devcb);
#define MCFG_SCSP_EXTS_CB(_devcb) \
devcb = &scsp_device::set_exts_callback(*device, DEVCB_##_devcb);
devcb = &downcast<scsp_device &>(*device).set_exts_callback(DEVCB_##_devcb);
class scsp_device : public device_t,
@ -34,10 +34,10 @@ class scsp_device : public device_t,
public:
scsp_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_roffset(device_t &device, int roffset) { downcast<scsp_device &>(device).m_roffset = roffset; }
template <class Object> static devcb_base &set_irq_callback(device_t &device, Object &&cb) { return downcast<scsp_device &>(device).m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_main_irq_callback(device_t &device, Object &&cb) { return downcast<scsp_device &>(device).m_main_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_exts_callback(device_t &device, Object &&cb) { return downcast<scsp_device &>(device).m_exts_cb.set_callback(std::forward<Object>(cb)); }
void set_roffset(int roffset) { m_roffset = roffset; }
template <class Object> devcb_base &set_irq_callback(Object &&cb) { return m_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_main_irq_callback(Object &&cb) { return m_main_irq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_exts_callback(Object &&cb) { return m_exts_cb.set_callback(std::forward<Object>(cb)); }
// SCSP register access
DECLARE_READ16_MEMBER( read );

12
src/devices/sound/segapcm.h
View File

@ -15,16 +15,16 @@
//**************************************************************************
#define MCFG_SEGAPCM_ADD(tag, clock) \
MCFG_DEVICE_ADD((tag), SEGAPCM, (clock))
MCFG_DEVICE_ADD((tag), SEGAPCM, (clock))
#define MCFG_SEGAPCM_REPLACE(tag, clock) \
MCFG_DEVICE_REPLACE((tag), SEGAPCM, (clock))
MCFG_DEVICE_REPLACE((tag), SEGAPCM, (clock))
#define MCFG_SEGAPCM_BANK(bank) \
segapcm_device::set_bank(*device, (segapcm_device::bank));
downcast<segapcm_device &>(*device).set_bank((segapcm_device::bank));
#define MCFG_SEGAPCM_BANK_MASK(bank, mask) \
segapcm_device::set_bank(*device, (segapcm_device::bank) | (segapcm_device::mask));
downcast<segapcm_device &>(*device).set_bank((segapcm_device::bank) | (segapcm_device::mask));
//**************************************************************************
@ -45,8 +45,8 @@ public:
segapcm_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void set_bank(device_t &device, int bank) { downcast<segapcm_device &>(device).m_bank = bank; }
// configuration
void set_bank(int bank) { m_bank = bank; }
DECLARE_WRITE8_MEMBER( sega_pcm_w );
DECLARE_READ8_MEMBER( sega_pcm_r );

93
src/devices/sound/sn76477.h
View File

@ -51,43 +51,43 @@
#define MCFG_SN76477_NOISE_PARAMS(_clock_res, _filter_res, _filter_cap) \
sn76477_device::set_noise_params(*device, _clock_res, _filter_res, _filter_cap);
downcast<sn76477_device &>(*device).set_noise_params(_clock_res, _filter_res, _filter_cap);
#define MCFG_SN76477_DECAY_RES(_decay_res) \
sn76477_device::set_decay_res(*device, _decay_res);
downcast<sn76477_device &>(*device).set_decay_res(_decay_res);
#define MCFG_SN76477_ATTACK_PARAMS(_decay_cap, _res) \
sn76477_device::set_attack_params(*device, _decay_cap, _res);
downcast<sn76477_device &>(*device).set_attack_params(_decay_cap, _res);
#define MCFG_SN76477_AMP_RES(_amp_res) \
sn76477_device::set_amp_res(*device, _amp_res);
downcast<sn76477_device &>(*device).set_amp_res(_amp_res);
#define MCFG_SN76477_FEEDBACK_RES(_feedback_res) \
sn76477_device::set_feedback_res(*device, _feedback_res);
downcast<sn76477_device &>(*device).set_feedback_res(_feedback_res);
#define MCFG_SN76477_VCO_PARAMS(_volt, _cap, _res) \
sn76477_device::set_vco_params(*device, _volt, _cap, _res);
downcast<sn76477_device &>(*device).set_vco_params(_volt, _cap, _res);
#define MCFG_SN76477_PITCH_VOLTAGE(_volt) \
sn76477_device::set_pitch_voltage(*device, _volt);
downcast<sn76477_device &>(*device).set_pitch_voltage(_volt);
#define MCFG_SN76477_SLF_PARAMS(_cap, _res) \
sn76477_device::set_slf_params(*device, _cap, _res);
downcast<sn76477_device &>(*device).set_slf_params(_cap, _res);
#define MCFG_SN76477_ONESHOT_PARAMS(_cap, _res) \
sn76477_device::set_oneshot_params(*device, _cap, _res);
downcast<sn76477_device &>(*device).set_oneshot_params(_cap, _res);
#define MCFG_SN76477_VCO_MODE(_mode) \
sn76477_device::set_vco_mode(*device, _mode);
downcast<sn76477_device &>(*device).set_vco_mode(_mode);
#define MCFG_SN76477_MIXER_PARAMS(_a, _b, _c) \
sn76477_device::set_mixer_params(*device, _a, _b, _c);
downcast<sn76477_device &>(*device).set_mixer_params(_a, _b, _c);
#define MCFG_SN76477_ENVELOPE_PARAMS(_env1, _env2) \
sn76477_device::set_envelope_params(*device, _env1, _env2);
downcast<sn76477_device &>(*device).set_envelope_params(_env1, _env2);
#define MCFG_SN76477_ENABLE(_enable) \
sn76477_device::set_enable(*device, _enable);
downcast<sn76477_device &>(*device).set_enable(_enable);
class sn76477_device : public device_t,
public device_sound_interface
@ -95,57 +95,50 @@ class sn76477_device : public device_t,
public:
sn76477_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_noise_params(device_t &device, double clock_res, double filter_res, double filter_cap)
void set_noise_params(double clock_res, double filter_res, double filter_cap)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_noise_clock_res = clock_res;
dev.m_noise_filter_res = filter_res;
dev.m_noise_filter_cap = filter_cap;
m_noise_clock_res = clock_res;
m_noise_filter_res = filter_res;
m_noise_filter_cap = filter_cap;
}
static void set_decay_res(device_t &device, double decay_res) { downcast<sn76477_device &>(device).m_decay_res = decay_res; }
static void set_attack_params(device_t &device, double decay_cap, double res)
void set_decay_res(double decay_res) { m_decay_res = decay_res; }
void set_attack_params(double decay_cap, double res)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_attack_decay_cap = decay_cap;
dev.m_attack_res = res;
m_attack_decay_cap = decay_cap;
m_attack_res = res;
}
static void set_amp_res(device_t &device, double amp_res) { downcast<sn76477_device &>(device).m_amplitude_res = amp_res; }
static void set_feedback_res(device_t &device, double feedback_res) { downcast<sn76477_device &>(device).m_feedback_res = feedback_res; }
static void set_vco_params(device_t &device, double volt, double cap, double res)
void set_amp_res(double amp_res) { m_amplitude_res = amp_res; }
void set_feedback_res(double feedback_res) { m_feedback_res = feedback_res; }
void set_vco_params(double volt, double cap, double res)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_vco_voltage = volt;
dev.m_vco_cap = cap;
dev.m_vco_res = res;
m_vco_voltage = volt;
m_vco_cap = cap;
m_vco_res = res;
}
static void set_pitch_voltage(device_t &device, double volt) { downcast<sn76477_device &>(device).m_pitch_voltage = volt; }
static void set_slf_params(device_t &device, double cap, double res)
void set_pitch_voltage(double volt) { m_pitch_voltage = volt; }
void set_slf_params(double cap, double res)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_slf_cap = cap;
dev.m_slf_res = res;
m_slf_cap = cap;
m_slf_res = res;
}
static void set_oneshot_params(device_t &device, double cap, double res)
void set_oneshot_params(double cap, double res)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_one_shot_cap = cap;
dev.m_one_shot_res = res;
m_one_shot_cap = cap;
m_one_shot_res = res;
}
static void set_vco_mode(device_t &device, uint32_t mode) { downcast<sn76477_device &>(device).m_vco_mode = mode; }
static void set_mixer_params(device_t &device, uint32_t a, uint32_t b, uint32_t c)
void set_vco_mode(uint32_t mode) { m_vco_mode = mode; }
void set_mixer_params(uint32_t a, uint32_t b, uint32_t c)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_mixer_a = a;
dev.m_mixer_b = b;
dev.m_mixer_c = c;
m_mixer_a = a;
m_mixer_b = b;
m_mixer_c = c;
}
static void set_envelope_params(device_t &device, uint32_t env1, uint32_t env2)
void set_envelope_params(uint32_t env1, uint32_t env2)
{
sn76477_device &dev = downcast<sn76477_device &>(device);
dev.m_envelope_1 = env1;
dev.m_envelope_2 = env2;
m_envelope_1 = env1;
m_envelope_2 = env2;
}
static void set_enable(device_t &device, uint32_t enable) { downcast<sn76477_device &>(device).m_enable = enable; }
void set_enable(uint32_t enable) { m_enable = enable; }
/* these functions take 0 or 1 as a logic input */

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

@ -19,13 +19,13 @@ DECLARE_DEVICE_TYPE(SEGAPSG, segapsg_device)
#define MCFG_SN76496_READY_HANDLER(cb) \
devcb = &sn76496_base_device::set_ready_handler(*device, (DEVCB_##cb));
devcb = &downcast<sn76496_base_device &>(*device).set_ready_handler((DEVCB_##cb));
class sn76496_base_device : public device_t, public device_sound_interface
{
public:
// static configuration helpers
template <class Object> static devcb_base &set_ready_handler(device_t &device, Object &&cb) { return downcast<sn76496_base_device &>(device).m_ready_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_ready_handler(Object &&cb) { return m_ready_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER( stereo_w );
void write(uint8_t data);

4
src/devices/sound/sp0250.h
View File

@ -10,7 +10,7 @@ class sp0250_device : public device_t, public device_sound_interface
public:
sp0250_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_drq_callback(device_t &device, Object &&cb) { return downcast<sp0250_device &>(device).m_drq.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_drq_callback(Object &&cb) { return m_drq.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER( write );
uint8_t drq_r();
@ -50,6 +50,6 @@ private:
DECLARE_DEVICE_TYPE(SP0250, sp0250_device)
#define MCFG_SP0250_DRQ_CALLBACK(_write) \
devcb = &sp0250_device::set_drq_callback(*device, DEVCB_##_write);
devcb = &downcast<sp0250_device &>(*device).set_drq_callback(DEVCB_##_write);
#endif // MAME_SOUND_SP0250_H

8
src/devices/sound/sp0256.h
View File

@ -36,10 +36,10 @@
#pragma once
#define MCFG_SP0256_DATA_REQUEST_CB(_devcb) \
devcb = &sp0256_device::set_data_request_callback(*device, DEVCB_##_devcb);
devcb = &downcast<sp0256_device &>(*device).set_data_request_callback(DEVCB_##_devcb);
#define MCFG_SP0256_STANDBY_CB(_devcb) \
devcb = &sp0256_device::set_standby_callback(*device, DEVCB_##_devcb);
devcb = &downcast<sp0256_device &>(*device).set_standby_callback(DEVCB_##_devcb);
class sp0256_device : public device_t,
@ -48,8 +48,8 @@ class sp0256_device : public device_t,
public:
sp0256_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_data_request_callback(device_t &device, Object &&cb) { return downcast<sp0256_device &>(device).m_drq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_standby_callback(device_t &device, Object &&cb) { return downcast<sp0256_device &>(device).m_sby_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_data_request_callback(Object &&cb) { return m_drq_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_standby_callback(Object &&cb) { return m_sby_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER(ald_w);
DECLARE_READ_LINE_MEMBER(lrq_r);

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

@ -14,7 +14,7 @@
#define MCFG_SPEAKER_LEVELS(_num, _levels) \
speaker_sound_device::static_set_levels(*device, _num, _levels);
downcast<speaker_sound_device &>(*device).set_levels(_num, _levels);
class speaker_sound_device : public device_t,
public device_sound_interface
@ -23,8 +23,8 @@ public:
speaker_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
~speaker_sound_device() {}
// static configuration
static void static_set_levels(device_t &device, int num_levels, const int16_t *levels) { downcast<speaker_sound_device &>(device).m_num_levels = num_levels; downcast<speaker_sound_device &>(device).m_levels = levels;}
// configuration
void set_levels(int num_levels, const int16_t *levels) { m_num_levels = num_levels; m_levels = levels;}
void level_w(int new_level);

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

@ -10,7 +10,7 @@
//**************************************************************************
#define MCFG_SPU_IRQ_HANDLER(_devcb) \
devcb = &spu_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<spu_device &>(*device).set_irq_handler(DEVCB_##_devcb);
#define MCFG_SPU_ADD(_tag, _clock) \
MCFG_DEVICE_MODIFY( "maincpu" ) \
@ -230,8 +230,8 @@ protected:
public:
spu_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<spu_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
void dma_read( uint32_t *ram, uint32_t n_address, int32_t n_size );
void dma_write( uint32_t *ram, uint32_t n_address, int32_t n_size );

4
src/devices/sound/st0016.h
View File

@ -11,7 +11,7 @@
//**************************************************************************
#define MCFG_ST0016_SOUNDRAM_READ_CB(_devcb) \
devcb = &st0016_device::set_soundram_callback(*device, DEVCB_##_devcb);
devcb = &downcast<st0016_device &>(*device).set_soundram_callback(DEVCB_##_devcb);
//**************************************************************************
// TYPE DEFINITIONS
@ -24,7 +24,7 @@ class st0016_device : public device_t, public device_sound_interface
public:
st0016_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_soundram_callback(device_t &device, Object &&cb) { return downcast<st0016_device &>(device).m_ram_read_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_soundram_callback(Object &&cb) { return m_ram_read_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( st0016_snd_r );
DECLARE_WRITE8_MEMBER( st0016_snd_w );

39
src/devices/sound/tms36xx.h
View File

@ -10,19 +10,19 @@
//**************************************************************************
#define MCFG_TMS36XX_ADD(tag, clock) \
MCFG_DEVICE_ADD((tag), TMS36XX, (clock))
MCFG_DEVICE_ADD((tag), TMS36XX, (clock))
#define MCFG_TMS36XX_REPLACE(tag, clock) \
MCFG_DEVICE_REPLACE((tag), TMS36XX, (clock))
MCFG_DEVICE_REPLACE((tag), TMS36XX, (clock))
#define MCFG_TMS36XX_TYPE(type) \
tms36xx_device::set_subtype(*device, (tms36xx_device::subtype::type));
downcast<tms36xx_device &>(*device).set_subtype((tms36xx_device::subtype::type));
#define MCFG_TMS36XX_DECAY_TIMES(_dec0, _dec1, _dec2, _dec3, _dec4, _dec5) \
tms36xx_device::set_decays(*device, _dec0, _dec1, _dec2, _dec3, _dec4, _dec5);
downcast<tms36xx_device &>(*device).set_decays(_dec0, _dec1, _dec2, _dec3, _dec4, _dec5);
#define MCFG_TMS36XX_TUNE_SPEED(_speed) \
tms36xx_device::set_tune_speed(*device, _speed);
downcast<tms36xx_device &>(*device).set_tune_speed(_speed);
//**************************************************************************
@ -46,38 +46,33 @@ public:
tms36xx_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_subtype(device_t &device, subtype type)
void set_subtype(subtype type)
{
tms36xx_device &dev = downcast<tms36xx_device &>(device);
switch (type)
{
case subtype::MM6221AA:
dev.m_subtype = "MM6221AA";
m_subtype = "MM6221AA";
break;
case subtype::TMS3615:
dev.m_subtype = "TMS3615";
m_subtype = "TMS3615";
break;
case subtype::TMS3617:
dev.m_subtype = "TMS3617";
m_subtype = "TMS3617";
break;
default:
fatalerror("Invalid TMS36XX type: %d\n", int(type));
break;
}
}
static void set_tune_speed(device_t &device, double speed)
void set_tune_speed(double speed) { m_speed = (speed > 0) ? TMS36XX_VMAX / speed : TMS36XX_VMAX; }
void set_decays(double decay_0, double decay_1, double decay_2, double decay_3, double decay_4, double decay_5)
{
downcast<tms36xx_device &>(device).m_speed = (speed > 0) ? TMS36XX_VMAX / speed : TMS36XX_VMAX;
}
static void set_decays(device_t &device, double decay_0, double decay_1, double decay_2, double decay_3, double decay_4, double decay_5)
{
tms36xx_device &dev = downcast<tms36xx_device &>(device);
dev.m_decay_time[0] = decay_0;
dev.m_decay_time[1] = decay_1;
dev.m_decay_time[2] = decay_2;
dev.m_decay_time[3] = decay_3;
dev.m_decay_time[4] = decay_4;
dev.m_decay_time[5] = decay_5;
m_decay_time[0] = decay_0;
m_decay_time[1] = decay_1;
m_decay_time[2] = decay_2;
m_decay_time[3] = decay_3;
m_decay_time[4] = decay_4;
m_decay_time[5] = decay_5;
}
protected:

64
src/devices/sound/tms5110.h
View File

@ -14,19 +14,19 @@
/* usually 800000 for 10000 Hz sample rate. */
#define MCFG_TMS5110_M0_CB(_devcb) \
devcb = &tms5110_device::set_m0_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5110_device &>(*device).set_m0_callback(DEVCB_##_devcb);
#define MCFG_TMS5110_M1_CB(_devcb) \
devcb = &tms5110_device::set_m1_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5110_device &>(*device).set_m1_callback(DEVCB_##_devcb);
#define MCFG_TMS5110_ADDR_CB(_devcb) \
devcb = &tms5110_device::set_addr_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5110_device &>(*device).set_addr_callback(DEVCB_##_devcb);
#define MCFG_TMS5110_DATA_CB(_devcb) \
devcb = &tms5110_device::set_data_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5110_device &>(*device).set_data_callback(DEVCB_##_devcb);
#define MCFG_TMS5110_ROMCLK_CB(_devcb) \
devcb = &tms5110_device::set_romclk_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5110_device &>(*device).set_romclk_callback(DEVCB_##_devcb);
class tms5110_device : public device_t, public device_sound_interface
@ -51,11 +51,11 @@ public:
tms5110_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_m0_callback(device_t &device, Object &&cb) { return downcast<tms5110_device &>(device).m_m0_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_m1_callback(device_t &device, Object &&cb) { return downcast<tms5110_device &>(device).m_m1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_addr_callback(device_t &device, Object &&cb) { return downcast<tms5110_device &>(device).m_addr_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_data_callback(device_t &device, Object &&cb) { return downcast<tms5110_device &>(device).m_data_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_romclk_callback(device_t &device, Object &&cb) { return downcast<tms5110_device &>(device).m_romclk_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_m0_callback(Object &&cb) { return m_m0_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_m1_callback(Object &&cb) { return m_m1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_addr_callback(Object &&cb) { return m_addr_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_data_callback(Object &&cb) { return m_data_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_romclk_callback(Object &&cb) { return m_romclk_cb.set_callback(std::forward<Object>(cb)); }
DECLARE_WRITE8_MEMBER( ctl_w );
DECLARE_READ8_MEMBER( ctl_r );
@ -277,17 +277,17 @@ class tmsprom_device : public device_t
public:
tmsprom_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void set_region(device_t &device, const char *region) { downcast<tmsprom_device &>(device).m_prom.set_tag(region); }
static void set_rom_size(device_t &device, uint32_t rom_size) { downcast<tmsprom_device &>(device).m_rom_size = rom_size; }
static void set_pdc_bit(device_t &device, uint8_t pdc_bit) { downcast<tmsprom_device &>(device).m_pdc_bit = pdc_bit; }
static void set_ctl1_bit(device_t &device, uint8_t ctl1_bit) { downcast<tmsprom_device &>(device).m_ctl1_bit = ctl1_bit; }
static void set_ctl2_bit(device_t &device, uint8_t ctl2_bit) { downcast<tmsprom_device &>(device).m_ctl2_bit = ctl2_bit; }
static void set_ctl4_bit(device_t &device, uint8_t ctl4_bit) { downcast<tmsprom_device &>(device).m_ctl4_bit = ctl4_bit; }
static void set_ctl8_bit(device_t &device, uint8_t ctl8_bit) { downcast<tmsprom_device &>(device).m_ctl8_bit = ctl8_bit; }
static void set_reset_bit(device_t &device, uint8_t reset_bit) { downcast<tmsprom_device &>(device).m_reset_bit = reset_bit; }
static void set_stop_bit(device_t &device, uint8_t stop_bit) { downcast<tmsprom_device &>(device).m_stop_bit = stop_bit; }
template<class _Object> static devcb_base &set_pdc_callback(device_t &device, _Object object) { return downcast<tmsprom_device &>(device).m_pdc_cb.set_callback(object); }
template<class _Object> static devcb_base &set_ctl_callback(device_t &device, _Object object) { return downcast<tmsprom_device &>(device).m_ctl_cb.set_callback(object); }
void set_region(const char *region) { m_prom.set_tag(region); }
void set_rom_size(uint32_t rom_size) { m_rom_size = rom_size; }
void set_pdc_bit(uint8_t pdc_bit) { m_pdc_bit = pdc_bit; }
void set_ctl1_bit(uint8_t ctl1_bit) { m_ctl1_bit = ctl1_bit; }
void set_ctl2_bit(uint8_t ctl2_bit) { m_ctl2_bit = ctl2_bit; }
void set_ctl4_bit(uint8_t ctl4_bit) { m_ctl4_bit = ctl4_bit; }
void set_ctl8_bit(uint8_t ctl8_bit) { m_ctl8_bit = ctl8_bit; }
void set_reset_bit(uint8_t reset_bit) { m_reset_bit = reset_bit; }
void set_stop_bit(uint8_t stop_bit) { m_stop_bit = stop_bit; }
template<class Object> devcb_base &set_pdc_callback(Object object) { return m_pdc_cb.set_callback(std::forward<Object>(object)); }
template<class Object> devcb_base &set_ctl_callback(Object object) { return m_ctl_cb.set_callback(std::forward<Object>(object)); }
DECLARE_WRITE_LINE_MEMBER( m0_w );
DECLARE_READ_LINE_MEMBER( data_r );
@ -338,36 +338,36 @@ private:
DECLARE_DEVICE_TYPE(TMSPROM, tmsprom_device)
#define MCFG_TMSPROM_REGION(_region) \
tmsprom_device::set_region(*device, "^" _region);
downcast<tmsprom_device &>(*device).set_region("^" _region);
#define MCFG_TMSPROM_ROM_SIZE(_size) \
tmsprom_device::set_rom_size(*device, _size);
downcast<tmsprom_device &>(*device).set_rom_size(_size);
#define MCFG_TMSPROM_PDC_BIT(_bit) \
tmsprom_device::set_pdc_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_pdc_bit(_bit);
#define MCFG_TMSPROM_CTL1_BIT(_bit) \
tmsprom_device::set_ctl1_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_ctl1_bit(_bit);
#define MCFG_TMSPROM_CTL2_BIT(_bit) \
tmsprom_device::set_ctl2_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_ctl2_bit(_bit);
#define MCFG_TMSPROM_CTL4_BIT(_bit) \
tmsprom_device::set_ctl4_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_ctl4_bit(_bit);
#define MCFG_TMSPROM_CTL8_BIT(_bit) \
tmsprom_device::set_ctl8_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_ctl8_bit(_bit);
#define MCFG_TMSPROM_RESET_BIT(_bit) \
tmsprom_device::set_reset_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_reset_bit(_bit);
#define MCFG_TMSPROM_STOP_BIT(_bit) \
tmsprom_device::set_stop_bit(*device, _bit);
downcast<tmsprom_device &>(*device).set_stop_bit(_bit);
#define MCFG_TMSPROM_PDC_CB(_devcb) \
devcb = &tmsprom_device::set_pdc_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tmsprom_device &>(*device).set_pdc_callback(DEVCB_##_devcb);
#define MCFG_TMSPROM_CTL_CB(_devcb) \
devcb = &tmsprom_device::set_ctl_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tmsprom_device &>(*device).set_ctl_callback(DEVCB_##_devcb);
#endif // MAME_SOUND_TMS5110_H

34
src/devices/sound/tms5220.h
View File

@ -16,31 +16,31 @@
/* IRQ callback function, active low, i.e. state=0 */
#define MCFG_TMS52XX_IRQ_HANDLER(_devcb) \
devcb = &tms5220_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_irq_handler(DEVCB_##_devcb);
/* Ready callback function, active low, i.e. state=0 */
#define MCFG_TMS52XX_READYQ_HANDLER(_devcb) \
devcb = &tms5220_device::set_readyq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_readyq_handler(DEVCB_##_devcb);
/* old VSM handler, remove me! */
#define MCFG_TMS52XX_SPEECHROM(_tag) \
tms5220_device::set_speechrom_tag(*device, _tag);
downcast<tms5220_device &>(*device).set_speechrom_tag(_tag);
/* new VSM handler */
#define MCFG_TMS52XX_M0_CB(_devcb) \
devcb = &tms5220_device::set_m0_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_m0_callback(DEVCB_##_devcb);
#define MCFG_TMS52XX_M1_CB(_devcb) \
devcb = &tms5220_device::set_m1_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_m1_callback(DEVCB_##_devcb);
#define MCFG_TMS52XX_ADDR_CB(_devcb) \
devcb = &tms5220_device::set_addr_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_addr_callback(DEVCB_##_devcb);
#define MCFG_TMS52XX_DATA_CB(_devcb) \
devcb = &tms5220_device::set_data_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(*device).set_data_callback(DEVCB_##_devcb);
#define MCFG_TMS52XX_ROMCLK_CB(_devcb) \
devcb = &tms5220_device::set_romclk_callback(*device, DEVCB_##_devcb);
devcb = &downcast<tms5220_device &>(device).set_romclk_callback(DEVCB_##_devcb);
class tms5220_device : public device_t, public device_sound_interface
{
@ -53,17 +53,17 @@ public:
tms5220_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_readyq_handler(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_readyq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_readyq_handler(Object &&cb) { return m_readyq_handler.set_callback(std::forward<Object>(cb)); }
// old VSM support, remove me!
static void set_speechrom_tag(device_t &device, const char *_tag) { downcast<tms5220_device &>(device).m_speechrom_tag = _tag; }
void set_speechrom_tag(const char *_tag) { m_speechrom_tag = _tag; }
// new VSM support
template <class Object> static devcb_base &set_m0_callback(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_m0_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_m1_callback(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_m1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_addr_callback(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_addr_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_data_callback(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_data_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_romclk_callback(device_t &device, Object &&cb) { return downcast<tms5220_device &>(device).m_romclk_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_m0_callback(Object &&cb) { return m_m0_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_m1_callback(Object &&cb) { return m_m1_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_addr_callback(Object &&cb) { return m_addr_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_data_callback(Object &&cb) { return m_data_cb.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_romclk_callback(Object &&cb) { return m_romclk_cb.set_callback(std::forward<Object>(cb)); }
// Control lines - once written to will switch interface into * "true" timing behaviour.

4
src/devices/sound/upd1771.h
View File

@ -11,7 +11,7 @@
#define MCFG_UPD1771_ACK_HANDLER(_devcb) \
devcb = &upd1771c_device::set_ack_handler(*device, DEVCB_##_devcb);
devcb = &downcast<upd1771c_device &>(*device).set_ack_handler(DEVCB_##_devcb);
/***************************************************************************
@ -24,7 +24,7 @@ class upd1771c_device : public device_t,
public:
upd1771c_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
template <class Object> static devcb_base &set_ack_handler(device_t &device, Object &&cb) { return downcast<upd1771c_device &>(device).m_ack_handler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_ack_handler(Object &&cb) { return m_ack_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

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

@ -18,7 +18,7 @@
class upd775x_device : public device_t, public device_sound_interface
{
public:
template <class Object> static devcb_base &set_drq_callback(device_t &device, Object &&cb) { return downcast<upd775x_device &>(device).m_drqcallback.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_drq_callback(Object &&cb) { return m_drqcallback.set_callback(std::forward<Object>(cb)); }
void set_bank_base(offs_t base);
@ -144,9 +144,9 @@ DECLARE_DEVICE_TYPE(UPD7759, upd7759_device)
DECLARE_DEVICE_TYPE(UPD7756, upd7756_device)
#define MCFG_UPD7759_DRQ_CALLBACK(_write) \
devcb = &upd7759_device::set_drq_callback(*device, DEVCB_##_write);
devcb = &downcast<upd7759_device &>(*device).set_drq_callback(DEVCB_##_write);
#define MCFG_UPD7756_DRQ_CALLBACK(_write) \
devcb = &upd7756_device::set_drq_callback(*device, DEVCB_##_write);
devcb = &downcast<upd7756_device &>(*device).set_drq_callback(DEVCB_##_write);
#endif // MAME_SOUND_UPD7759_H

4
src/devices/sound/volt_reg.h
View File

@ -15,12 +15,12 @@
#define MCFG_VOLTAGE_REGULATOR_OUTPUT(_output) \
voltage_regulator_device::set_output(*device, _output);
downcast<voltage_regulator_device &>(*device).set_output(_output);
class voltage_regulator_device : public device_t, public device_sound_interface
{
public:
static void set_output(device_t &device, double analogue_dc) { downcast<voltage_regulator_device &>(device).m_output = (analogue_dc * 32768) / 5.0f; }
void set_output(double analogue_dc) { m_output = (analogue_dc * 32768) / 5.0f; }
voltage_regulator_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);

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

@ -16,7 +16,7 @@
MCFG_DEVICE_REPLACE(_tag, VRENDER0, _clock)
#define MCFG_VR0_REGBASE(_base) \
vrender0_device::set_reg_base(*device, _base);
downcast<vrender0_device &>(*device).set_reg_base(_base);
//**************************************************************************
// TYPE DEFINITIONS
@ -31,8 +31,8 @@ class vrender0_device : public device_t,
public:
vrender0_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void set_reg_base(device_t &device, int base) { downcast<vrender0_device &>(device).m_reg_base = base; }
// configuration
void set_reg_base(int base) { m_reg_base = base; }
DECLARE_READ32_MEMBER( vr0_snd_read );
DECLARE_WRITE32_MEMBER( vr0_snd_write );

6
src/devices/sound/wave.cpp
View File

@ -25,12 +25,6 @@
void wave_device::static_set_cassette_tag(device_t &device, const char *cassette_tag)
{
wave_device &wave = downcast<wave_device &>(device);
wave.m_cassette_tag = cassette_tag;
}
DEFINE_DEVICE_TYPE(WAVE, wave_device, "wave", "Wave")
wave_device::wave_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)

4
src/devices/sound/wave.h
View File

@ -17,7 +17,7 @@ class wave_device : public device_t, public device_sound_interface
public:
wave_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
static void static_set_cassette_tag(device_t &device, const char *cassette_tag);
void set_cassette_tag(const char *cassette_tag) { m_cassette_tag = cassette_tag; }
protected:
// device-level overrides
@ -40,6 +40,6 @@ DECLARE_DEVICE_TYPE(WAVE, wave_device)
#define MCFG_SOUND_WAVE_ADD(_tag, _cass_tag) \
MCFG_SOUND_ADD( _tag, WAVE, 0 ) \
wave_device::static_set_cassette_tag(*device, _cass_tag);
downcast<wave_device &>(*device).set_cassette_tag(_cass_tag);
#endif // MAME_SOUND_WAVE_H

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

@ -10,8 +10,8 @@ class x1_010_device : public device_t, public device_sound_interface
public:
x1_010_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration
static void set_address_xor(device_t &device, int addr) { downcast<x1_010_device &>(device).m_xor = addr; }
// configuration
void set_address_xor(int addr) { m_xor = addr; }
DECLARE_READ8_MEMBER ( read );
DECLARE_WRITE8_MEMBER( write );
@ -50,6 +50,6 @@ private:
DECLARE_DEVICE_TYPE(X1_010, x1_010_device)
#define MCFG_X1_010_ADDRESS_XOR(_addr) \
x1_010_device::set_address_xor(*device, _addr);
downcast<x1_010_device &>(*device).set_address_xor(_addr);
#endif // MAME_SOUND_X1_010_H

10
src/devices/sound/ym2151.h
View File

@ -44,9 +44,9 @@
MCFG_DEVICE_ADD(_tag, YM2151, _clock)
#define MCFG_YM2151_IRQ_HANDLER(_devcb) \
devcb = &ym2151_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<ym2151_device &>(*device).set_irq_handler(DEVCB_##_devcb);
#define MCFG_YM2151_PORT_WRITE_HANDLER(_devcb) \
devcb = &ym2151_device::set_port_write_handler(*device, DEVCB_##_devcb);
devcb = &downcast<ym2151_device &>(*device).set_port_write_handler(DEVCB_##_devcb);
//**************************************************************************
@ -63,9 +63,9 @@ public:
// construction/destruction
ym2151_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ym2151_device &>(device).m_irqhandler.set_callback(std::forward<Object>(cb)); }
template <class Object> static devcb_base &set_port_write_handler(device_t &device, Object &&cb) { return downcast<ym2151_device &>(device).m_portwritehandler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irqhandler.set_callback(std::forward<Object>(cb)); }
template <class Object> devcb_base &set_port_write_handler(Object &&cb) { return m_portwritehandler.set_callback(std::forward<Object>(cb)); }
// read/write
DECLARE_READ8_MEMBER(read);

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

@ -7,7 +7,7 @@
#define MCFG_YMF271_IRQ_HANDLER(_devcb) \
devcb = &ymf271_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<ymf271_device &>(*device).set_irq_handler(DEVCB_##_devcb);
class ymf271_device : public device_t, public device_sound_interface, public device_rom_interface
{
@ -16,8 +16,8 @@ public:
ymf271_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ymf271_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

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

@ -9,15 +9,15 @@
#define YMF278B_STD_CLOCK (33868800) /* standard clock for OPL4 */
#define MCFG_YMF278B_IRQ_HANDLER(_devcb) \
devcb = &ymf278b_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<ymf278b_device &>(*device).set_irq_handler(DEVCB_##_devcb);
class ymf278b_device : public device_t, public device_sound_interface, public device_rom_interface
{
public:
ymf278b_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ymf278b_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

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

@ -16,15 +16,15 @@
#define YMZ280B_MAKE_WAVS 0
#define MCFG_YMZ280B_IRQ_HANDLER(_devcb) \
devcb = &ymz280b_device::set_irq_handler(*device, DEVCB_##_devcb);
devcb = &downcast<ymz280b_device &>(*device).set_irq_handler(DEVCB_##_devcb);
class ymz280b_device : public device_t, public device_sound_interface, public device_rom_interface
{
public:
ymz280b_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_irq_handler(device_t &device, Object &&cb) { return downcast<ymz280b_device &>(device).m_irq_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_irq_handler(Object &&cb) { return m_irq_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ8_MEMBER( read );
DECLARE_WRITE8_MEMBER( write );

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

@ -20,7 +20,7 @@
MCFG_DEVICE_REPLACE(_tag, ZSG2, _clock)
#define MCFG_ZSG2_EXT_READ_HANDLER(_devcb) \
devcb = &zsg2_device::set_ext_read_handler(*device, DEVCB_##_devcb);
devcb = &downcast<zsg2_device &>(*device).set_ext_read_handler(DEVCB_##_devcb);
// ======================> zsg2_device
@ -31,8 +31,8 @@ class zsg2_device : public device_t,
public:
zsg2_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock);
// static configuration helpers
template <class Object> static devcb_base &set_ext_read_handler(device_t &device, Object &&cb) { return downcast<zsg2_device &>(device).m_ext_read_handler.set_callback(std::forward<Object>(cb)); }
// configuration helpers
template <class Object> devcb_base &set_ext_read_handler(Object &&cb) { return m_ext_read_handler.set_callback(std::forward<Object>(cb)); }
DECLARE_READ16_MEMBER(read);
DECLARE_WRITE16_MEMBER(write);

2
src/mame/drivers/inder.cpp
View File

@ -1301,7 +1301,7 @@ WRITE8_MEMBER( inder_state::ppic_w )
{
// pc4 - READY line back to cpu board, but not used
if (BIT(data, 5) != BIT(m_portc, 5))
m_msm->set_prescaler_selector(*m_msm, BIT(data, 5) ? msm5205_device::S48_4B : msm5205_device::S96_4B); // S1 pin
m_msm->set_prescaler_selector(BIT(data, 5) ? msm5205_device::S48_4B : msm5205_device::S96_4B); // S1 pin
m_7a->clock_w(BIT(data, 6));
m_7a->preset_w(!BIT(data, 7));
m_9a->preset_w(!BIT(data, 7));

20
src/mame/drivers/vgmplay.cpp
View File

@ -1248,8 +1248,8 @@ void vgmplay_state::machine_start()
uint8_t type = r8(0x78);
if (type & 0x10)
{
ay8910_device::set_psg_type(*m_ay8910[0], ay8910_device::PSG_TYPE_YM);
ay8910_device::set_psg_type(*m_ay8910[1], ay8910_device::PSG_TYPE_YM);
m_ay8910[0]->set_psg_type(ay8910_device::PSG_TYPE_YM);
m_ay8910[1]->set_psg_type(ay8910_device::PSG_TYPE_YM);
}
}
if(version >= 0x151 && r8(0x79)) {
@ -1261,8 +1261,8 @@ void vgmplay_state::machine_start()
to_set |= AY8910_SINGLE_OUTPUT;
if (flags & 4)
to_set |= AY8910_DISCRETE_OUTPUT;
ay8910_device::set_flags(*m_ay8910[0], to_set);
ay8910_device::set_flags(*m_ay8910[1], to_set);
m_ay8910[0]->set_flags(to_set);
m_ay8910[1]->set_flags(to_set);
}
if(version >= 0x151 && r8(0x7a)) {
uint8_t flags = r8(0x7a);
@ -1273,8 +1273,8 @@ void vgmplay_state::machine_start()
to_set |= AY8910_SINGLE_OUTPUT;
if (flags & 4)
to_set |= AY8910_DISCRETE_OUTPUT;
ay8910_device::set_flags(*m_ym2203[0], to_set);
ay8910_device::set_flags(*m_ym2203[1], to_set);
m_ym2203[0]->set_flags(to_set);
m_ym2203[1]->set_flags(to_set);
}
}
@ -1306,13 +1306,13 @@ void vgmplay_state::machine_start()
m_okim6295_clock[0] &= ~0x80000000;
m_okim6295_pin7[0] = 1;
}
okim6295_device::static_set_pin7(*m_okim6295[0], m_okim6295_pin7[0]);
m_okim6295[0]->config_pin7(m_okim6295_pin7[0]);
m_okim6295[0]->set_unscaled_clock(m_okim6295_clock[0] & ~0xc0000000);
if (m_okim6295_clock[0] & 0x40000000) {
m_okim6295_clock[0] &= ~0x40000000;
m_okim6295_clock[1] = m_okim6295_clock[0];
m_okim6295_pin7[1] = m_okim6295_pin7[0];
okim6295_device::static_set_pin7(*m_okim6295[1], m_okim6295_pin7[1]);
m_okim6295[1]->config_pin7(m_okim6295_pin7[1]);
m_okim6295[1]->set_unscaled_clock(m_okim6295_clock[1]);
}
}
@ -1349,7 +1349,7 @@ void vgmplay_state::machine_start()
if (data_start > 0xc0)
{
if(version >= 0x171 && r8(0xd6)) {
c352_device::static_set_divider(*m_c352, r8(0xd6) * 4);
m_c352->set_divider(r8(0xd6) * 4);
}
if(version >= 0x171 && r32(0xdc)) {
m_c352->set_unscaled_clock(r32(0xdc));
@ -1408,7 +1408,7 @@ WRITE8_MEMBER(vgmplay_state::okim6295_pin7_w)
if ((data & mem_mask) != (m_okim6295_pin7[Chip] & mem_mask))
{
COMBINE_DATA(&m_okim6295_pin7[Chip]);
okim6295_device::static_set_pin7(*m_okim6295[Chip], m_okim6295_pin7[Chip]);
m_okim6295[Chip]->config_pin7(m_okim6295_pin7[Chip]);
}
}

2
src/mame/machine/trs80.cpp
View File

@ -613,7 +613,7 @@ WRITE8_MEMBER( trs80_state::trs80_ff_w )
{
init = 1;
static int16_t speaker_levels[4] = { 0, -32768, 0, 32767 };
m_speaker->static_set_levels(*m_speaker, 4, speaker_levels);
m_speaker->set_levels(4, speaker_levels);
}
/* Speaker for System-80 MK II - only sounds if relay is off */