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(); }