void c64_cpm_cartridge_device::device_reset()
{
m_enabled = 0;
m_reset = 1;
update_signals();
}
static zx_status_t usb_midi_sink_write(void* ctx, const void* data, size_t length,
zx_off_t offset, size_t* actual) {
usb_midi_sink_t* sink = ctx;
if (sink->dead) {
return ZX_ERR_IO_NOT_PRESENT;
}
zx_status_t status = ZX_OK;
size_t out_actual = length;
const uint8_t* src = (uint8_t *)data;
while (length > 0) {
sync_completion_wait(&sink->free_write_completion, ZX_TIME_INFINITE);
if (sink->dead) {
return ZX_ERR_IO_NOT_PRESENT;
}
mtx_lock(&sink->mutex);
list_node_t* node = list_remove_head(&sink->free_write_reqs);
if (list_is_empty(&sink->free_write_reqs)) {
sync_completion_reset(&sink->free_write_completion);
}
mtx_unlock(&sink->mutex);
if (!node) {
// shouldn't happen!
status = ZX_ERR_INTERNAL;
goto out;
}
usb_req_internal_t* req_int = containerof(node, usb_req_internal_t, node);
usb_request_t* req = REQ_INTERNAL_TO_USB_REQ(req_int, sink->parent_req_size);
size_t message_length = get_midi_message_length(*src);
if (message_length < 1 || message_length > length) return ZX_ERR_INVALID_ARGS;
uint8_t buffer[4];
buffer[0] = (src[0] & 0xF0) >> 4;
buffer[1] = src[0];
buffer[2] = (message_length > 1 ? src[1] : 0);
buffer[3] = (message_length > 2 ? src[2] : 0);
usb_request_copy_to(req, buffer, 4, 0);
req->header.length = 4;
usb_request_complete_t complete = {
.callback = usb_midi_sink_write_complete,
.ctx = sink,
};
usb_request_queue(&sink->usb, req, &complete);
src += message_length;
length -= message_length;
}
out:
update_signals(sink);
if (status == ZX_OK) {
*actual = out_actual;
}
return status;
}
static void usb_midi_sink_unbind(void* ctx) {
usb_midi_sink_t* sink = ctx;
sink->dead = true;
update_signals(sink);
sync_completion_signal(&sink->free_write_completion);
device_remove(sink->mxdev);
}
void c64_cpm_cartridge_device::c64_cd_w(address_space &space, offs_t offset, UINT8 data, int sphi2, int ba, int roml, int romh, int io1, int io2)
{
if (!io1)
{
m_enabled = !BIT(data, 0);
update_signals();
}
}
void hp82937_io_card_device::device_reset()
{
hp80_io_card_device::device_reset();
m_latch = 0;
m_updating = false;
update_signals();
update_data_out();
}
void run_vm() {
graph = create_graph();
ip = (WORD*) code;
run_thread();
while (1) {
read_inputs();
update_signals();
write_outputs();
}
}
int c64_cpm_cartridge_device::c64_game_r(offs_t offset, int sphi2, int ba, int rw)
{
if (m_ba != ba)
{
m_ba = ba;
update_signals();
}
return 1;
}
static void usb_midi_sink_write_complete(void* ctx, usb_request_t* req) {
usb_midi_sink_t* sink = (usb_midi_sink_t*)ctx;
if (req->response.status == ZX_ERR_IO_NOT_PRESENT) {
usb_request_release(req);
return;
}
// FIXME what to do with error here?
mtx_lock(&sink->mutex);
zx_status_t status = usb_req_list_add_tail(&sink->free_write_reqs, req, sink->parent_req_size);
ZX_DEBUG_ASSERT(status == ZX_OK);
sync_completion_signal(&sink->free_write_completion);
update_signals(sink);
mtx_unlock(&sink->mutex);
}
void SignalSource::update()
{
update_signals(&m_sigs, m_manage_proc_mask);
}
void output_run(void* args)
{
FPSmanager fps_manager;
unsigned char frame[4096];
SDL_initFramerate(&fps_manager);
SDL_setFramerate(&fps_manager, 100);
stat_ops = 100;
output_running = 1;
unsigned int last_tick = SDL_GetTicks();
while(output_running)
{
mbeat_t tb = timebase_get();
update_patterns(tb);
update_signals(tb);
for(int i=0; i<n_output_strips; i++)
{
if(!output_strips[i].bus)
continue;
output_to_buffer(&output_strips[i], output_buffers[i]);
float energy = 0.;
float scalar = 1.0;
for(int k = 0; k < output_strips[i].length; k++){
energy += output_buffers[i][k].r;
energy += output_buffers[i][k].g;
energy += output_buffers[i][k].b;
}
scalar = output_strips[i].length * config.output.max_energy / energy * 255.;
if(scalar > 255.)
scalar = 255.;
int j = 0;
for(int k = 0; k < output_strips[i].length; k++){
frame[j++] = output_buffers[i][k].r * scalar;
frame[j++] = output_buffers[i][k].g * scalar;
frame[j++] = output_buffers[i][k].b * scalar;
}
if(output_on_flux && (output_strips[i].bus & OUTPUT_FLUX))
output_flux_push(&output_strips[i], frame, j);
}
SDL_framerateDelay(&fps_manager);
//stat_ops = SDL_getFramerate(&fps_manager);
stat_ops = 0.8 * stat_ops + 0.2 * (1000. / (SDL_GetTicks() - last_tick));
last_tick = SDL_GetTicks();
}
for(int i=0; i<n_output_strips; i++)
{
free(output_buffers[i]);
}
free(output_buffers);
if(output_on_flux)
output_flux_del();
}
