diff options
author | 2019-03-25 22:44:58 +0100 | |
---|---|---|
committer | 2019-03-25 22:44:58 +0100 | |
commit | c24473ddff715ecec2e258a6eb38960cf8c8e98e (patch) | |
tree | 8ea44b6396a6129913c0aac13859b5de9965e972 /src/devices/machine/netlist.cpp | |
parent | 009cba4fb8102102168ef32870892438327f3705 (diff) | |
parent | 598cd5227223c3b04ca31f0dbc1981256d9ea3ff (diff) |
conflict resolution (nw)
Diffstat (limited to 'src/devices/machine/netlist.cpp')
-rw-r--r-- | src/devices/machine/netlist.cpp | 375 |
1 files changed, 201 insertions, 174 deletions
diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp index 648d435ace8..3e7580be5b9 100644 --- a/src/devices/machine/netlist.cpp +++ b/src/devices/machine/netlist.cpp @@ -49,21 +49,16 @@ DEFINE_DEVICE_TYPE(NETLIST_STREAM_OUTPUT, netlist_mame_stream_output_device, "nl // Special netlist extension devices .... // ---------------------------------------------------------------------------------------- -class netlist_mame_device::netlist_mame_t : public netlist::netlist_t +class netlist_mame_device::netlist_mame_callbacks_t : public netlist::callbacks_t { public: - netlist_mame_t(netlist_mame_device &parent, const pstring &aname) - : netlist::netlist_t(aname) + netlist_mame_callbacks_t(netlist_mame_device &parent) + : netlist::callbacks_t() , m_parent(parent) { } - running_machine &machine() { return m_parent.machine(); } - - - netlist_mame_device &parent() { return m_parent; } - protected: void vlog(const plib::plog_level &l, const pstring &ls) const override { @@ -95,6 +90,24 @@ private: }; +class netlist_mame_device::netlist_mame_t : public netlist::netlist_t +{ +public: + + netlist_mame_t(netlist_mame_device &parent, const pstring &aname) + : netlist::netlist_t(aname, plib::make_unique<netlist_mame_device::netlist_mame_callbacks_t>(parent)) + , m_parent(parent) + { + } + + running_machine &machine() { return m_parent.machine(); } + netlist_mame_device &parent() { return m_parent; } + +private: + netlist_mame_device &m_parent; +}; + + namespace { // ---------------------------------------------------------------------------------------- @@ -104,13 +117,13 @@ namespace { class NETLIB_NAME(analog_callback) : public netlist::device_t { public: - NETLIB_NAME(analog_callback)(netlist::netlist_t &anetlist, const pstring &name) + NETLIB_NAME(analog_callback)(netlist::netlist_state_t &anetlist, const pstring &name) : device_t(anetlist, name) , m_in(*this, "IN") , m_cpu_device(nullptr) , m_last(*this, "m_last", 0) { - m_cpu_device = downcast<netlist_mame_cpu_device *>(&downcast<netlist_mame_device::netlist_mame_t &>(netlist()).parent()); + m_cpu_device = downcast<netlist_mame_cpu_device *>(&static_cast<netlist_mame_device::netlist_mame_t &>(exec()).parent()); } ATTR_COLD void reset() override @@ -131,7 +144,7 @@ public: // avoid calls due to noise if (std::fabs(cur - m_last) > 1e-6) { - m_cpu_device->update_time_x(); + m_cpu_device->update_icount(exec().time()); m_callback(cur, m_cpu_device->local_time()); m_cpu_device->check_mame_abort_slice(); m_last = cur; @@ -152,13 +165,13 @@ private: class NETLIB_NAME(logic_callback) : public netlist::device_t { public: - NETLIB_NAME(logic_callback)(netlist::netlist_t &anetlist, const pstring &name) + NETLIB_NAME(logic_callback)(netlist::netlist_state_t &anetlist, const pstring &name) : device_t(anetlist, name) , m_in(*this, "IN") , m_cpu_device(nullptr) , m_last(*this, "m_last", 0) { - m_cpu_device = downcast<netlist_mame_cpu_device *>(&downcast<netlist_mame_device::netlist_mame_t &>(netlist()).parent()); + m_cpu_device = downcast<netlist_mame_cpu_device *>(&static_cast<netlist_mame_device::netlist_mame_t &>(exec()).parent()); } ATTR_COLD void reset() override @@ -173,13 +186,13 @@ public: NETLIB_UPDATEI() { - netlist_sig_t cur = m_in(); + netlist::netlist_sig_t cur = m_in(); // FIXME: make this a parameter // avoid calls due to noise if (cur != m_last) { - m_cpu_device->update_time_x(); + m_cpu_device->update_icount(exec().time()); m_callback(cur, m_cpu_device->local_time()); m_cpu_device->check_mame_abort_slice(); m_last = cur; @@ -190,9 +203,10 @@ private: netlist::logic_input_t m_in; netlist_mame_logic_output_device::output_delegate m_callback; netlist_mame_cpu_device *m_cpu_device; - netlist::state_var<netlist_sig_t> m_last; + netlist::state_var<netlist::netlist_sig_t> m_last; }; + // ---------------------------------------------------------------------------------------- // Extensions to interface netlist with MAME code .... // ---------------------------------------------------------------------------------------- @@ -200,22 +214,26 @@ private: class netlist_source_memregion_t : public netlist::source_t { public: - netlist_source_memregion_t(netlist::setup_t &setup, pstring name) - : netlist::source_t(setup), m_name(name) + netlist_source_memregion_t(device_t &dev, pstring name) + : netlist::source_t(), m_dev(dev), m_name(name) { } - virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override; + virtual plib::unique_ptr<plib::pistream> stream(const pstring &name) override; private: + device_t &m_dev; pstring m_name; }; class netlist_data_memregions_t : public netlist::source_t { public: - netlist_data_memregions_t(netlist::setup_t &setup); + netlist_data_memregions_t(device_t &dev); - virtual std::unique_ptr<plib::pistream> stream(const pstring &name) override; + virtual plib::unique_ptr<plib::pistream> stream(const pstring &name) override; + +private: + device_t &m_dev; }; @@ -223,30 +241,31 @@ public: // memregion source support // ---------------------------------------------------------------------------------------- -std::unique_ptr<plib::pistream> netlist_source_memregion_t::stream(const pstring &name) +plib::unique_ptr<plib::pistream> netlist_source_memregion_t::stream(const pstring &name) { - memory_region *mem = downcast<netlist_mame_device::netlist_mame_t &>(setup().netlist()).machine().root_device().memregion(m_name.c_str()); - return plib::make_unique_base<plib::pistream, plib::pimemstream>(mem->base(), mem->bytes()); + //memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).machine().root_device().memregion(m_name.c_str()); + memory_region *mem = m_dev.machine().root_device().memregion(m_name.c_str()); + return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes()); } -netlist_data_memregions_t::netlist_data_memregions_t(netlist::setup_t &setup) - : netlist::source_t(setup, netlist::source_t::DATA) +netlist_data_memregions_t::netlist_data_memregions_t(device_t &dev) + : netlist::source_t(netlist::source_t::DATA), m_dev(dev) { } -std::unique_ptr<plib::pistream> netlist_data_memregions_t::stream(const pstring &name) +plib::unique_ptr<plib::pistream> netlist_data_memregions_t::stream(const pstring &name) { - memory_region *mem = downcast<netlist_mame_device::netlist_mame_t &>(setup().netlist()).parent().memregion(name.c_str()); - //memory_region *mem = downcast<netlist_mame_t &>(setup().netlist()).machine().root_device().memregion(name.c_str()); + //memory_region *mem = static_cast<netlist_mame_device::netlist_mame_t &>(setup().setup().exec()).parent().memregion(name.c_str()); + memory_region *mem = m_dev.memregion(name.c_str()); if (mem != nullptr) { - return plib::make_unique_base<plib::pistream, plib::pimemstream>(mem->base(), mem->bytes()); + return plib::make_unique<plib::pimemstream>(mem->base(), mem->bytes()); } else { // This should be the last data provider being called - last resort fatalerror("data named %s not found in device rom regions\n", name.c_str()); - return std::unique_ptr<plib::pistream>(nullptr); + return plib::unique_ptr<plib::pistream>(nullptr); } } @@ -261,44 +280,55 @@ std::unique_ptr<plib::pistream> netlist_data_memregions_t::stream(const pstring class NETLIB_NAME(sound_out) : public netlist::device_t { public: - NETLIB_NAME(sound_out)(netlist::netlist_t &anetlist, const pstring &name) + NETLIB_NAME(sound_out)(netlist::netlist_state_t &anetlist, const pstring &name) : netlist::device_t(anetlist, name) , m_channel(*this, "CHAN", 0) , m_mult(*this, "MULT", 1000.0) , m_offset(*this, "OFFSET", 0.0) , m_buffer(nullptr) - , m_sample(netlist::netlist_time::from_hz(1)) //sufficiently big enough + , m_bufsize(0) + , m_sample_time(netlist::netlist_time::from_hz(1)) //sufficiently big enough , m_in(*this, "IN") , m_cur(0.0) , m_last_pos(0) - , m_last_buffer(*this, "m_last_buffer", netlist::netlist_time::zero()) + , m_last_buffer_time(*this, "m_last_buffer", netlist::netlist_time::zero()) { } - static const int BUFSIZE = 2048; + //static const int BUFSIZE = 2048; ATTR_COLD void reset() override { m_cur = 0.0; m_last_pos = 0; - m_last_buffer = netlist::netlist_time::zero(); + m_last_buffer_time = netlist::netlist_time::zero(); } ATTR_HOT void sound_update(const netlist::netlist_time &upto) { - int pos = (upto - m_last_buffer) / m_sample; - if (pos >= BUFSIZE) - netlist().log().fatal("sound {1}: exceeded BUFSIZE\n", name().c_str()); + int pos = (upto - m_last_buffer_time) / m_sample_time; + if (pos > m_bufsize) + throw emu_fatalerror("sound %s: pos %d exceeded bufsize %d\n", name().c_str(), pos, m_bufsize); while (m_last_pos < pos ) { m_buffer[m_last_pos++] = (stream_sample_t) m_cur; } } + ATTR_HOT void sound_update_fill(int samples) + { + if (samples > m_bufsize) + throw emu_fatalerror("sound %s: pos %d exceeded bufsize %d\n", name().c_str(), samples, m_bufsize); + while (m_last_pos < samples ) + { + m_buffer[m_last_pos++] = (stream_sample_t) m_cur; + } + } + NETLIB_UPDATEI() { nl_double val = m_in() * m_mult() + m_offset(); - sound_update(netlist().time()); + sound_update(exec().time()); /* ignore spikes */ if (std::abs(val) < 32767.0) m_cur = val; @@ -313,21 +343,22 @@ public: ATTR_HOT void buffer_reset(const netlist::netlist_time &upto) { m_last_pos = 0; - m_last_buffer = upto; - m_cur = 0.0; + m_last_buffer_time = upto; } netlist::param_int_t m_channel; netlist::param_double_t m_mult; netlist::param_double_t m_offset; stream_sample_t *m_buffer; - netlist::netlist_time m_sample; + int m_bufsize; + + netlist::netlist_time m_sample_time; private: netlist::analog_input_t m_in; double m_cur; int m_last_pos; - netlist::state_var<netlist::netlist_time> m_last_buffer; + netlist::state_var<netlist::netlist_time> m_last_buffer_time; }; // ---------------------------------------------------------------------------------------- @@ -337,58 +368,57 @@ private: class NETLIB_NAME(sound_in) : public netlist::device_t { public: - NETLIB_NAME(sound_in)(netlist::netlist_t &anetlist, const pstring &name) + + static const int MAX_INPUT_CHANNELS = 16; + + NETLIB_NAME(sound_in)(netlist::netlist_state_t &anetlist, const pstring &name) : netlist::device_t(anetlist, name) + , m_inc(netlist::netlist_time::from_nsec(1)) , m_feedback(*this, "FB") // clock part , m_Q(*this, "Q") , m_pos(0) - , m_num_channel(0) + , m_num_channels(0) { connect(m_feedback, m_Q); - m_inc = netlist::netlist_time::from_nsec(1); - for (int i = 0; i < MAX_INPUT_CHANNELS; i++) { - m_param_name[i] = std::make_unique<netlist::param_str_t>(*this, plib::pfmt("CHAN{1}")(i), ""); - m_param_mult[i] = std::make_unique<netlist::param_double_t>(*this, plib::pfmt("MULT{1}")(i), 1.0); - m_param_offset[i] = std::make_unique<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.0); + m_channels[i].m_param_name = netlist::pool().make_poolptr<netlist::param_str_t>(*this, plib::pfmt("CHAN{1}")(i), ""); + m_channels[i].m_param_mult = netlist::pool().make_poolptr<netlist::param_double_t>(*this, plib::pfmt("MULT{1}")(i), 1.0); + m_channels[i].m_param_offset = netlist::pool().make_poolptr<netlist::param_double_t>(*this, plib::pfmt("OFFSET{1}")(i), 0.0); } } - static const int MAX_INPUT_CHANNELS = 10; - ATTR_COLD void reset() override { m_pos = 0; - for (auto & elem : m_buffer) - elem = nullptr; + for (auto & elem : m_channels) + elem.m_buffer = nullptr; } - ATTR_COLD int resolve() + ATTR_COLD void resolve() { m_pos = 0; for (int i = 0; i < MAX_INPUT_CHANNELS; i++) { - if ((*m_param_name[i])() != pstring("")) + if ((*m_channels[i].m_param_name)() != pstring("")) { - if (i != m_num_channel) - netlist().log().fatal("sound input numbering has to be sequential!"); - m_num_channel++; - m_param[i] = dynamic_cast<netlist::param_double_t *>(setup().find_param((*m_param_name[i])(), true)); + if (i != m_num_channels) + state().log().fatal("sound input numbering has to be sequential!"); + m_num_channels++; + m_channels[i].m_param = dynamic_cast<netlist::param_double_t *>(setup().find_param((*m_channels[i].m_param_name)(), true)); } } - return m_num_channel; } NETLIB_UPDATEI() { - for (int i=0; i<m_num_channel; i++) + for (int i=0; i<m_num_channels; i++) { - if (m_buffer[i] == nullptr) + if (m_channels[i].m_buffer == nullptr) break; // stop, called outside of stream_update - const nl_double v = m_buffer[i][m_pos]; - m_param[i]->setTo(v * (*m_param_mult[i])() + (*m_param_offset[i])()); + const nl_double v = m_channels[i].m_buffer[m_pos]; + m_channels[i].m_param->setTo(v * (*m_channels[i].m_param_mult)() + (*m_channels[i].m_param_offset)()); } m_pos++; m_Q.net().toggle_and_push_to_queue(m_inc); @@ -400,19 +430,25 @@ public: m_pos = 0; } - std::unique_ptr<netlist::param_str_t> m_param_name[MAX_INPUT_CHANNELS]; - netlist::param_double_t *m_param[MAX_INPUT_CHANNELS]; - stream_sample_t *m_buffer[MAX_INPUT_CHANNELS]; - std::unique_ptr<netlist::param_double_t> m_param_mult[MAX_INPUT_CHANNELS]; - std::unique_ptr<netlist::param_double_t> m_param_offset[MAX_INPUT_CHANNELS]; + struct channel + { + netlist::pool_owned_ptr<netlist::param_str_t> m_param_name; + netlist::param_double_t *m_param; + stream_sample_t *m_buffer; + netlist::pool_owned_ptr<netlist::param_double_t> m_param_mult; + netlist::pool_owned_ptr<netlist::param_double_t> m_param_offset; + }; + channel m_channels[MAX_INPUT_CHANNELS]; netlist::netlist_time m_inc; + int num_channels() { return m_num_channels; } + private: netlist::logic_input_t m_feedback; netlist::logic_output_t m_Q; int m_pos; - int m_num_channel; + int m_num_channels; }; @@ -431,26 +467,25 @@ private: netlist::setup_t &netlist_mame_device::setup() { - return m_netlist->setup(); + return m_netlist->nlstate().setup(); } -void netlist_mame_device::register_memregion_source(netlist::setup_t &setup, const char *name) +void netlist_mame_device::register_memregion_source(netlist::nlparse_t &setup, device_t &dev, const char *name) { - setup.register_source(plib::make_unique_base<netlist::source_t, netlist_source_memregion_t>(setup, pstring(name, pstring::UTF8))); + setup.register_source(plib::make_unique<netlist_source_memregion_t>(dev, pstring(name))); } void netlist_mame_analog_input_device::write(const double val) { - if (is_sound_device()) - { - update_to_current_time(); - m_param->setTo(val * m_mult + m_offset); - } - else - { - // FIXME: use device timer .... - m_param->setTo(val * m_mult + m_offset); - } + m_value_for_device_timer = val * m_mult + m_offset; + if (m_value_for_device_timer != (*m_param)()) + synchronize(0, 0, &m_value_for_device_timer); +} + +void netlist_mame_analog_input_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) +{ + update_to_current_time(); + m_param->setTo(*((double *) ptr)); } void netlist_mame_int_input_device::write(const uint32_t val) @@ -469,15 +504,13 @@ void netlist_mame_logic_input_device::write(const uint32_t val) void netlist_mame_int_input_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) { - if (is_sound_device()) - update_to_current_time(); + update_to_current_time(); m_param->setTo(param); } void netlist_mame_logic_input_device::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) { - if (is_sound_device()) - update_to_current_time(); + update_to_current_time(); m_param->setTo(param); } @@ -500,7 +533,7 @@ void netlist_mame_cpu_device::state_string_export(const device_state_entry &entr if (entry.index() & 1) str = string_format("%10.6f", *((double *)entry.dataptr())); else - str = string_format("%d", *((netlist_sig_t *)entry.dataptr())); + str = string_format("%d", *((netlist::netlist_sig_t *)entry.dataptr())); } } @@ -528,7 +561,7 @@ netlist_mame_analog_input_device::netlist_mame_analog_input_device(const machine void netlist_mame_analog_input_device::device_start() { LOGDEVCALLS("start\n"); - netlist::param_t *p = this->nl_owner().setup().find_param(pstring(m_param_name, pstring::UTF8)); + netlist::param_t *p = this->nl_owner().setup().find_param(pstring(m_param_name)); m_param = dynamic_cast<netlist::param_double_t *>(p); if (m_param == nullptr) { @@ -560,16 +593,17 @@ void netlist_mame_analog_output_device::set_params(const char *in_name, output_d m_delegate = std::move(adelegate); } -void netlist_mame_analog_output_device::custom_netlist_additions(netlist::setup_t &setup) +void netlist_mame_analog_output_device::custom_netlist_additions(netlist::netlist_state_t &nlstate) { - const pstring pin(m_in, pstring::UTF8); + const pstring pin(m_in); pstring dname = pstring("OUT_") + pin; + pstring dfqn = nlstate.setup().build_fqn(dname); m_delegate.bind_relative_to(owner()->machine().root_device()); - plib::owned_ptr<netlist::device_t> dev = plib::owned_ptr<netlist::device_t>::Create<NETLIB_NAME(analog_callback)>(setup.netlist(), setup.build_fqn(dname)); + auto dev = netlist::pool().make_poolptr<NETLIB_NAME(analog_callback)>(nlstate, dfqn); static_cast<NETLIB_NAME(analog_callback) *>(dev.get())->register_callback(std::move(m_delegate)); - setup.netlist().register_dev(std::move(dev)); - setup.register_link(dname + ".IN", pin); + nlstate.add_dev(dfqn, std::move(dev)); + nlstate.setup().register_link(dname + ".IN", pin); } void netlist_mame_analog_output_device::device_start() @@ -595,16 +629,18 @@ void netlist_mame_logic_output_device::set_params(const char *in_name, output_de m_delegate = std::move(adelegate); } -void netlist_mame_logic_output_device::custom_netlist_additions(netlist::setup_t &setup) +void netlist_mame_logic_output_device::custom_netlist_additions(netlist::netlist_state_t &nlstate) { - pstring pin(m_in, pstring::UTF8); + pstring pin(m_in); pstring dname = "OUT_" + pin; + pstring dfqn = nlstate.setup().build_fqn(dname); + m_delegate.bind_relative_to(owner()->machine().root_device()); - plib::owned_ptr<netlist::device_t> dev = plib::owned_ptr<netlist::device_t>::Create<NETLIB_NAME(logic_callback)>(setup.netlist(), setup.build_fqn(dname)); + auto dev = netlist::pool().make_poolptr<NETLIB_NAME(logic_callback)>(nlstate, dfqn); static_cast<NETLIB_NAME(logic_callback) *>(dev.get())->register_callback(std::move(m_delegate)); - setup.netlist().register_dev(std::move(dev)); - setup.register_link(dname + ".IN", pin); + nlstate.add_dev(dfqn, std::move(dev)); + nlstate.setup().register_link(dname + ".IN", pin); } void netlist_mame_logic_output_device::device_start() @@ -638,7 +674,7 @@ void netlist_mame_int_input_device::set_params(const char *param_name, const uin void netlist_mame_int_input_device::device_start() { LOGDEVCALLS("start\n"); - netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name, pstring::UTF8)); + netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name)); m_param = dynamic_cast<netlist::param_int_t *>(p); if (m_param == nullptr) { @@ -669,7 +705,7 @@ void netlist_mame_logic_input_device::set_params(const char *param_name, const u void netlist_mame_logic_input_device::device_start() { LOGDEVCALLS("start\n"); - netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name, pstring::UTF8)); + netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name)); m_param = dynamic_cast<netlist::param_logic_t *>(p); if (m_param == nullptr) { @@ -700,7 +736,7 @@ void netlist_mame_ram_pointer_device::set_params(const char *param_name) void netlist_mame_ram_pointer_device::device_start() { LOGDEVCALLS("start\n"); - netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name, pstring::UTF8)); + netlist::param_t *p = downcast<netlist_mame_device *>(this->owner())->setup().find_param(pstring(m_param_name)); m_param = dynamic_cast<netlist::param_ptr_t *>(p); if (m_param == nullptr) { @@ -733,17 +769,17 @@ void netlist_mame_stream_input_device::device_start() LOGDEVCALLS("start\n"); } -void netlist_mame_stream_input_device::custom_netlist_additions(netlist::setup_t &setup) +void netlist_mame_stream_input_device::custom_netlist_additions(netlist::netlist_state_t &nlstate) { - if (!setup.device_exists("STREAM_INPUT")) - setup.register_dev("NETDEV_SOUND_IN", "STREAM_INPUT"); + if (!nlstate.setup().device_exists("STREAM_INPUT")) + nlstate.setup().register_dev("NETDEV_SOUND_IN", "STREAM_INPUT"); pstring sparam = plib::pfmt("STREAM_INPUT.CHAN{1}")(m_channel); - setup.register_param(sparam, pstring(m_param_name, pstring::UTF8)); + nlstate.setup().register_param(sparam, pstring(m_param_name)); sparam = plib::pfmt("STREAM_INPUT.MULT{1}")(m_channel); - setup.register_param(sparam, m_mult); + nlstate.setup().register_param(sparam, m_mult); sparam = plib::pfmt("STREAM_INPUT.OFFSET{1}")(m_channel); - setup.register_param(sparam, m_offset); + nlstate.setup().register_param(sparam, m_offset); } // ---------------------------------------------------------------------------------------- @@ -769,18 +805,18 @@ void netlist_mame_stream_output_device::device_start() LOGDEVCALLS("start\n"); } -void netlist_mame_stream_output_device::custom_netlist_additions(netlist::setup_t &setup) +void netlist_mame_stream_output_device::custom_netlist_additions(netlist::netlist_state_t &nlstate) { //NETLIB_NAME(sound_out) *snd_out; pstring sname = plib::pfmt("STREAM_OUT_{1}")(m_channel); //snd_out = dynamic_cast<NETLIB_NAME(sound_out) *>(setup.register_dev("nld_sound_out", sname)); - setup.register_dev("NETDEV_SOUND_OUT", sname); + nlstate.setup().register_dev("NETDEV_SOUND_OUT", sname); - setup.register_param(sname + ".CHAN" , m_channel); - setup.register_param(sname + ".MULT", m_mult); - setup.register_param(sname + ".OFFSET", m_offset); - setup.register_link(sname + ".IN", pstring(m_out_name, pstring::UTF8)); + nlstate.setup().register_param(sname + ".CHAN" , m_channel); + nlstate.setup().register_param(sname + ".MULT", m_mult); + nlstate.setup().register_param(sname + ".OFFSET", m_offset); + nlstate.setup().register_link(sname + ".IN", pstring(m_out_name)); } @@ -797,7 +833,6 @@ netlist_mame_device::netlist_mame_device(const machine_config &mconfig, device_t : device_t(mconfig, type, tag, owner, clock) , m_icount(0) , m_old(netlist::netlist_time::zero()) - , m_netlist(nullptr) , m_setup_func(nullptr) { } @@ -807,12 +842,6 @@ netlist_mame_device::~netlist_mame_device() LOGDEVCALLS("~netlist_mame_device\n"); } -void netlist_mame_device::set_constructor(void (*setup_func)(netlist::setup_t &)) -{ - if (LOG_DEV_CALLS) logerror("set_constructor\n"); - m_setup_func = setup_func; -} - void netlist_mame_device::device_config_complete() { LOGDEVCALLS("device_config_complete %s\n", this->mconfig().gamedrv().name); @@ -830,7 +859,7 @@ void netlist_mame_device::device_start() //printf("clock is %d\n", clock()); - m_netlist = global_alloc(netlist_mame_t(*this, "netlist")); + m_netlist = netlist::pool().make_poolptr<netlist_mame_t>(*this, "netlist"); // register additional devices @@ -843,12 +872,12 @@ void netlist_mame_device::device_start() if( sdev != nullptr ) { LOGDEVCALLS("Preparse subdevice %s/%s\n", d.name(), d.shortname()); - sdev->pre_parse_action(setup()); + sdev->pre_parse_action(m_netlist->nlstate()); } } /* add default data provider for roms */ - setup().register_source(plib::make_unique_base<netlist::source_t, netlist_data_memregions_t>(setup())); + setup().register_source(plib::make_unique<netlist_data_memregions_t>(*this)); m_setup_func(setup()); @@ -859,15 +888,15 @@ void netlist_mame_device::device_start() if( sdev != nullptr ) { LOGDEVCALLS("Found subdevice %s/%s\n", d.name(), d.shortname()); - sdev->custom_netlist_additions(setup()); + sdev->custom_netlist_additions(m_netlist->nlstate()); } } - netlist().start(); + setup().prepare_to_run(); - netlist().save(*this, m_rem, "m_rem"); - netlist().save(*this, m_div, "m_div"); - netlist().save(*this, m_old, "m_old"); + netlist().nlstate().save(*this, m_rem, this->name(), "m_rem"); + netlist().nlstate().save(*this, m_div, this->name(), "m_div"); + netlist().nlstate().save(*this, m_old, this->name(), "m_old"); save_state(); @@ -896,29 +925,26 @@ void netlist_mame_device::device_stop() { LOGDEVCALLS("device_stop\n"); netlist().stop(); - - global_free(m_netlist); - m_netlist = nullptr; } ATTR_COLD void netlist_mame_device::device_post_load() { LOGDEVCALLS("device_post_load\n"); - netlist().state().post_load(); - netlist().rebuild_lists(); + netlist().run_state_manager().post_load(); + netlist().nlstate().rebuild_lists(); } ATTR_COLD void netlist_mame_device::device_pre_save() { LOGDEVCALLS("device_pre_save\n"); - netlist().state().pre_save(); + netlist().run_state_manager().pre_save(); } -void netlist_mame_device::update_time_x() +void netlist_mame_device::update_icount(netlist::netlist_time time) { - const netlist::netlist_time newt(netlist().time()); + const netlist::netlist_time newt(time); const netlist::netlist_time delta(newt - m_old + m_rem); const uint64_t d = delta / m_div; m_old = newt; @@ -934,7 +960,7 @@ void netlist_mame_device::check_mame_abort_slice() ATTR_COLD void netlist_mame_device::save_state() { - for (auto const & s : netlist().state().save_list()) + for (auto const & s : netlist().run_state_manager().save_list()) { netlist().log().debug("saving state for {1}\n", s->m_name.c_str()); if (s->m_dt.is_float) @@ -997,17 +1023,18 @@ void netlist_mame_cpu_device::device_start() state_add(STATE_GENPC, "GENPC", m_genPC).noshow(); state_add(STATE_GENPCBASE, "CURPC", m_genPC).noshow(); - for (int i=0; i < netlist().m_nets.size(); i++) + int index = 0; + for (auto &n : netlist().nlstate().nets()) { - netlist::detail::net_t *n = netlist().m_nets[i].get(); if (n->is_logic()) { - state_add(i*2, n->name().c_str(), *downcast<netlist::logic_net_t *>(n)->Q_state_ptr()); + state_add(index, n->name().c_str(), *(downcast<netlist::logic_net_t &>(*n).Q_state_ptr())); } else { - state_add(i*2+1, n->name().c_str(), *downcast<netlist::analog_net_t *>(n)->Q_Analog_state_ptr()); + state_add(index, n->name().c_str(), *(downcast<netlist::analog_net_t &>(*n).Q_Analog_state_ptr())); } + index++; } // set our instruction counter @@ -1032,10 +1059,8 @@ ATTR_COLD uint64_t netlist_mame_cpu_device::execute_cycles_to_clocks(uint64_t cy ATTR_HOT void netlist_mame_cpu_device::execute_run() { - bool check_debugger = ((device_t::machine().debug_flags & DEBUG_FLAG_ENABLED) != 0); - // debugging //m_ppc = m_pc; // copy PC to previous PC - if (check_debugger) + if (debugger_enabled()) { while (m_icount > 0) { @@ -1043,13 +1068,13 @@ ATTR_HOT void netlist_mame_cpu_device::execute_run() m_genPC &= 255; debugger_instruction_hook(m_genPC); netlist().process_queue(m_div); - update_time_x(); + update_icount(netlist().time()); } } else { netlist().process_queue(m_div * m_icount); - update_time_x(); + update_icount(netlist().time()); } } @@ -1089,11 +1114,8 @@ offs_t netlist_disassembler::disassemble(std::ostream &stream, offs_t pc, const netlist_mame_sound_device::netlist_mame_sound_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock) : netlist_mame_device(mconfig, NETLIST_SOUND, tag, owner, clock) , device_sound_interface(mconfig, *this) - , m_out{nullptr} , m_in(nullptr) , m_stream(nullptr) - , m_num_inputs(0) - , m_num_outputs(0) { } @@ -1105,44 +1127,45 @@ void netlist_mame_sound_device::device_start() // Configure outputs - std::vector<nld_sound_out *> outdevs = netlist().get_device_list<nld_sound_out>(); + std::vector<nld_sound_out *> outdevs = netlist().nlstate().get_device_list<nld_sound_out>(); if (outdevs.size() == 0) fatalerror("No output devices"); - m_num_outputs = outdevs.size(); + //m_num_outputs = outdevs.size(); /* resort channels */ - for (int i=0; i < MAX_OUT; i++) m_out[i] = nullptr; - for (int i=0; i < m_num_outputs; i++) + for (auto &outdev : outdevs) { - int chan = outdevs[i]->m_channel(); + int chan = outdev->m_channel(); - netlist().log().verbose("Output %d on channel %d", i, chan); + netlist().log().verbose("Output %s on channel %d", outdev->name(), chan); - if (chan < 0 || chan >= MAX_OUT || chan >= outdevs.size()) + if (chan < 0 || chan >= outdevs.size()) fatalerror("illegal channel number"); - m_out[chan] = outdevs[i]; - m_out[chan]->m_sample = netlist::netlist_time::from_hz(clock()); + m_out[chan] = outdev; + m_out[chan]->m_sample_time = netlist::netlist_time::from_hz(clock()); m_out[chan]->m_buffer = nullptr; + m_out[chan]->m_bufsize = 0; } // Configure inputs + // FIXME: The limitation to one input device seems artificial. + // We should allow multiple devices with one channel each. - m_num_inputs = 0; m_in = nullptr; - std::vector<nld_sound_in *> indevs = netlist().get_device_list<nld_sound_in>(); + std::vector<nld_sound_in *> indevs = netlist().nlstate().get_device_list<nld_sound_in>(); if (indevs.size() > 1) fatalerror("A maximum of one input device is allowed!"); if (indevs.size() == 1) { m_in = indevs[0]; - m_num_inputs = m_in->resolve(); + m_in->resolve(); m_in->m_inc = netlist::netlist_time::from_hz(clock()); } /* initialize the stream(s) */ - m_stream = machine().sound().stream_alloc(*this, m_num_inputs, m_num_outputs, clock()); + m_stream = machine().sound().stream_alloc(*this, m_in ? m_in->num_channels() : 0, m_out.size(), clock()); } @@ -1155,17 +1178,21 @@ void netlist_mame_sound_device::nl_register_devices() void netlist_mame_sound_device::sound_stream_update(sound_stream &stream, stream_sample_t **inputs, stream_sample_t **outputs, int samples) { - for (int i=0; i < m_num_outputs; i++) + + for (auto &e : m_out) { - m_out[i]->m_buffer = outputs[i]; + e.second->m_buffer = outputs[e.first]; + e.second->m_bufsize = samples; } - if (m_num_inputs) - m_in->buffer_reset(); - for (int i=0; i < m_num_inputs; i++) + if (m_in) { - m_in->m_buffer[i] = inputs[i]; + m_in->buffer_reset(); + for (int i=0; i < m_in->num_channels(); i++) + { + m_in->m_channels[i].m_buffer = inputs[i]; + } } netlist::netlist_time cur(netlist().time()); @@ -1174,9 +1201,9 @@ void netlist_mame_sound_device::sound_stream_update(sound_stream &stream, stream cur += (m_div * samples); - for (int i=0; i < m_num_outputs; i++) + for (auto &e : m_out) { - m_out[i]->sound_update(cur); - m_out[i]->buffer_reset(cur); + e.second->sound_update_fill(samples); + e.second->buffer_reset(cur); } } |