int select_from_queues (delay_queue * priority, delay_queue* left, delay_queue * right) { int id = 0; /* This leads to the obvious note that no real ID should be 0. */ if (peek_head_key (priority)) { id = pop_head_key (priority); } else if (peek_head_key (left)) { if (peek_head_key (right)) { if (get_delay (left) >= get_delay (right)) { id = pop_head_key (left); increment_delay (right); } else { id = pop_head_key (right); increment_delay (left); } } else { id = pop_head_key (left); } } else { if (peek_head_key (right)) { id = pop_head_key (right); } } /* Note two things: this neither updates wait times nor really tracks other * state changes. However, it doesn't need an extra final case as no left, no * right is already accounted for. */ return id; }
void t_move_missile::on_idle() { t_uint32 new_time = get_time(); // update animation (if any) if (elapsed_time( new_time, m_last_update_time ) >= m_delay ) { int frame = m_missile.get_current_frame_num(); frame++; if (frame >= m_missile.get_frame_count()) frame = 0; m_battlefield.set_current_frame_num( m_missile, frame ); m_last_update_time = new_time; } t_map_point_3d position; t_uint32 next_time = get_next_time() - get_delay(); int skip_limit = 1; // move missile forward one space while (elapsed_time( new_time, next_time ) >= 0 && skip_limit-- > 0 ) { next_time += get_delay(); if (m_distance_left <= 0) { t_idle_ptr reference = this; suspend_idle_processing(); m_battlefield.remove_object( &m_missile ); animation_ended(); m_end_handler( m_attacker, m_target_position ); return; } t_map_point_3d delta; int distance; // limit distance moved to distance left position = m_missile.get_position(); distance = m_move_distance; if (distance > m_distance_left) distance = m_distance_left; m_distance_left -= distance; // add distance to accumulator m_sum += m_delta * distance; // find integer portion of moved distance delta = m_sum / m_distance; position += delta; m_sum -= delta * m_distance; // calculate parabolic arc if (m_is_parabolic) { position.height += m_vertical_velocity - k_gravity; m_vertical_velocity -= k_gravity << 1; } } set_next_time( next_time ); m_battlefield.move_object( m_missile, position ); }
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data) { struct af_resample *s = af->priv; struct mp_audio *in = data; struct mp_audio *out = af->data; out->samples = avresample_available(s->avrctx) + av_rescale_rnd(get_delay(s) + in->samples, s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP); mp_audio_realloc_min(out, out->samples); af->delay = get_delay(s) / (double)s->ctx.in_rate; #if !USE_SET_CHANNEL_MAPPING do_reorder(in, s->reorder_in); #endif if (out->samples) { out->samples = avresample_convert(s->avrctx, (uint8_t **) out->planes, out->samples * out->sstride, out->samples, (uint8_t **) in->planes, in->samples * in->sstride, in->samples); if (out->samples < 0) return NULL; // error } *data = *out; #if USE_SET_CHANNEL_MAPPING if (needs_reorder(s->reorder_out, out->nch)) { if (af_fmt_is_planar(out->format)) { reorder_planes(data, s->reorder_out); } else { int out_size = out->samples * out->sstride; if (talloc_get_size(s->reorder_buffer) < out_size) s->reorder_buffer = talloc_realloc_size(s, s->reorder_buffer, out_size); data->planes[0] = s->reorder_buffer; int out_samples = avresample_convert(s->avrctx_out, (uint8_t **) data->planes, out_size, out->samples, (uint8_t **) out->planes, out_size, out->samples); assert(out_samples == data->samples); } } #else do_reorder(data, s->reorder_out); #endif return data; }
// close audio device static void uninit(int immed){ mp_msg(MSGT_AO,MSGL_V,"SDL: Audio Subsystem shutting down!\n"); if (!immed) usec_sleep(get_delay() * 1000 * 1000); SDL_CloseAudio(); SDL_QuitSubSystem(SDL_INIT_AUDIO); }
static int request_frame(AVFilterLink *link) { AVFilterContext *ctx = link->src; ASyncContext *s = ctx->priv; int ret = 0; int nb_samples; s->got_output = 0; while (ret >= 0 && !s->got_output) ret = ff_request_frame(ctx->inputs[0]); /* flush the fifo */ if (ret == AVERROR_EOF) { if (s->first_pts != AV_NOPTS_VALUE) handle_trimming(ctx); if (nb_samples = get_delay(s)) { AVFrame *buf = ff_get_audio_buffer(link, nb_samples); if (!buf) return AVERROR(ENOMEM); ret = avresample_convert(s->avr, buf->extended_data, buf->linesize[0], nb_samples, NULL, 0, 0); if (ret <= 0) { av_frame_free(&buf); return (ret < 0) ? ret : AVERROR_EOF; } buf->pts = s->pts; return ff_filter_frame(link, buf); } } return ret; }
static struct mp_audio *play(struct af_instance *af, struct mp_audio *data) { struct af_resample *s = af->priv; struct mp_audio *in = data; struct mp_audio *out = af->data; int in_size = data->len; int in_samples = in_size / (data->bps * data->nch); int out_samples = avresample_available(s->avrctx) + av_rescale_rnd(get_delay(s) + in_samples, s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP); int out_size = out->bps * out_samples * out->nch; if (talloc_get_size(out->audio) < out_size) out->audio = talloc_realloc_size(out, out->audio, out_size); af->delay = out->bps * av_rescale_rnd(get_delay(s), s->ctx.out_rate, s->ctx.in_rate, AV_ROUND_UP); #if !USE_SET_CHANNEL_MAPPING reorder_channels(data->audio, s->reorder_in, data->bps, data->nch, in_samples); #endif out_samples = avresample_convert(s->avrctx, (uint8_t **) &out->audio, out_size, out_samples, (uint8_t **) &in->audio, in_size, in_samples); *data = *out; #if USE_SET_CHANNEL_MAPPING if (needs_reorder(s->reorder_out, out->nch)) { if (talloc_get_size(s->reorder_buffer) < out_size) s->reorder_buffer = talloc_realloc_size(s, s->reorder_buffer, out_size); data->audio = s->reorder_buffer; out_samples = avresample_convert(s->avrctx_out, (uint8_t **) &data->audio, out_size, out_samples, (uint8_t **) &out->audio, out_size, out_samples); } #else reorder_channels(data->audio, s->reorder_out, out->bps, out->nch, out_samples); #endif data->len = out->bps * out_samples * out->nch; return data; }
scpi_result_t scpi_source_VoltageProtectionDelayQ(scpi_t * context) { Channel *channel = set_channel_from_command_number(context); if (!channel) { return SCPI_RES_ERR; } return get_delay(context, channel->prot_conf.u_delay); }
static void update_player(t_player *player, double *tdt) { fds c; double dt; (void)tdt; if (!player) return ; c = player->client; dt = time_d(player->foodlt); player->foodlt = time_(); player->foodt -= (dt / (((double)delay_life / get_delay()) * get_time())); player->food = (uint)abs(player->foodt); if (player->foodt <= 0) c ? (void)net_close_msg(c, "mort") : (void)player_destroy(player); else if (player->foodt > 0) timer_helper(((player->foodt * delay_life) * (get_time() / get_delay()))); }
/** \brief close audio device \param immed stop playback immediately */ static void uninit(struct ao *ao, bool immed) { if (!immed) mp_sleep_us(get_delay(ao) * 1000000); reset(ao); DestroyBuffer(ao); UninitDirectSound(ao); }
// close audio device static void uninit(struct ao *ao, bool immed) { struct priv *p = ao->priv; if (!immed) mp_sleep_us(get_delay(ao) * 1000 * 1000); // HACK, make sure jack doesn't loop-output dirty buffers reset(ao); mp_sleep_us(100 * 1000); jack_client_close(p->client); }
// close audio device static void uninit(int immed) { if (!immed) usec_sleep(get_delay() * 1000 * 1000); // HACK, make sure jack doesn't loop-output dirty buffers reset(); usec_sleep(100 * 1000); jack_client_close(client); av_fifo_free(buffer); buffer = NULL; }
int main(int argc, char** argv) { init(HOST, PORT); if (argc < 2) { printf("Usage %s filename\n", argv[0]); return -1; } tabel = tabelcrc(CRCCCITT); printf("Speed: %d\n", get_speed(argv[1])); printf("Delay: %d\n", get_delay(argv[2])); printf("Loss: %lf\n", get_loss(argv[3])); printf("Corrupt: %lf\n", get_corrupt(argv[4])); transmit(argv[5], get_speed(argv[1]), get_delay(argv[2]), get_loss(argv[3]), get_corrupt(argv[4]) ); free(tabel); return 0; }
// close audio device static void uninit(int immed){ mp_msg(MSGT_AO,MSGL_V,"SDL: Audio Subsystem shutting down!\n"); if (!immed) usec_sleep(get_delay() * 1000 * 1000); #ifdef _WIN32 if (!hSDL) return; #endif SDL_CloseAudio(); SDL_QuitSubSystem(SDL_INIT_AUDIO); av_fifo_free(buffer); #ifdef _WIN32 FreeLibrary(hSDL); #endif }
bool scheduler_relative(fds c, _time dt, bool (*cb)(fds, void*), void *data) { t_client *info; t_scheduler *schedule; if (!scheduler_a(c, dt, cb, data)) return (false); if (!c || !(info = c->trick)) return (false); schedule = &info->schedule; schedule->relative = (char)true; scheduler_update(dt * (get_time() / get_delay())); return (true); }
void sim_disk_file::serve(void* buffer, offset_type offset, size_type bytes, request::request_type type) { scoped_mutex_lock fd_lock(fd_mutex); double op_start = timestamp(); stats::scoped_read_write_timer read_write_timer(bytes, type == request::WRITE); void* mem = mmap(NULL, bytes, PROT_READ | PROT_WRITE, MAP_SHARED, file_des, offset); if (mem == MAP_FAILED) { STXXL_THROW_ERRNO (io_error, " mmap() failed." << " Page size: " << sysconf(_SC_PAGESIZE) << " offset modulo page size " << (offset % sysconf(_SC_PAGESIZE))); } else if (mem == 0) { STXXL_THROW_ERRNO(io_error, "mmap() returned NULL"); } else { if (type == request::READ) { memcpy(buffer, mem, bytes); } else { memcpy(mem, buffer, bytes); } STXXL_THROW_ERRNO_NE_0(munmap(mem, bytes), io_error, "munmap() failed"); } double delay = get_delay(offset, bytes); delay = delay - timestamp() + op_start; assert(delay > 0.0); int seconds_to_wait = static_cast<int>(floor(delay)); if (seconds_to_wait) sleep(seconds_to_wait); usleep((useconds_t)((delay - seconds_to_wait) * 1000000.)); }
static double do_delay(double delay, double i) { int variable; /* ram - this was a little weird, since i is a double... except I think it's * secretely an integer */ variable = ((int)i) % MAXTYPE; if (del_stab_flag > 0) { if (DelayFlag && delay > 0.0) { /* printf("do_delay for var #%d, delay %f\n", variable-1, delay); */ return (get_delay(variable - 1, delay)); } return (variables.elems[variable]); } return (delay_stab_eval(delay, (int)variable)); }
uint16_t CharLook::get_attackdelay(size_t no, uint8_t first_frame) const { if (action) { return drawinfo.get_attackdelay(actionstr, no); } else { uint16_t delay = 0; for (uint8_t frame = 0; frame < first_frame; frame++) { delay += get_delay(stance.get(), frame); } return delay; } }
// ------------------------------------------------------------------------ // do movement that's hidden // ------------------------------------------------------------------------ void t_army_mover::do_hidden_move() { if (m_is_visible) return; if (m_path.size() == 0) { finish_path(); return; } t_adventure_map const& map = *m_army->get_map(); t_player& player = map.get_player(); int team = player.get_team(); declare_timer( timer_1, "do_hidden_movement" ); while (!m_is_visible && !m_halted) { t_adventure_path_point& point = m_path[m_step]; m_army->move( point ); expend_movement( point.move_cost ); mark_eluded_armies(); if (m_step == m_path.size() - 1) { finish_path(); return; } trigger_event(); if (m_halted) return; m_is_visible = !m_army->hidden_by_fog_of_war( team ) && show_enemy_moves(); if (m_is_visible) break; // break here, because start_new_square will increment step. ++m_step; declare_timer( timer_2, "on_starting_new_square: hidden" ); on_starting_new_square(); } if (m_halted) return; m_army->set_action( k_adv_actor_action_walk ); m_distance = compute_overall_distance( m_path, m_step + 1 ); start_new_square(); prepare_move( 0 ); set_next_time( get_time() + get_delay() ); }
static double do_delay_shift(double delay, double shift, double variable) { int in; int i = (int)(variable), ish = (int)shift; if (i < 0) return (0.0); in = (i % MAXTYPE) + ish; if (in > MAXODE) return 0.0; if (del_stab_flag > 0) { if (DelayFlag && delay > 0.0) return (get_delay(in - 1, delay)); return (variables.elems[in]); } return (delay_stab_eval(delay, in)); }
/* * return: how many bytes can be played without blocking */ static int get_space(void) { struct timeval tmout; fd_set wfds; float current_delay; int space; /* * Don't buffer too much data in the esd daemon. * * If we send too much, esd will block in write()s to the sound * device, and the consequence is a huge slow down for things like * esd_get_all_info(). */ if ((current_delay = get_delay()) >= ESD_MAX_DELAY) { dprintf("esd get_space: too much data buffered\n"); return 0; } FD_ZERO(&wfds); FD_SET(esd_play_fd, &wfds); tmout.tv_sec = 0; tmout.tv_usec = 0; if (select(esd_play_fd + 1, NULL, &wfds, NULL, &tmout) != 1) return 0; if (!FD_ISSET(esd_play_fd, &wfds)) return 0; /* try to fill 50% of the remaining "free" buffer space */ space = (ESD_MAX_DELAY - current_delay) * ao_data.bps * 0.5f; /* round up to next multiple of ESD_BUF_SIZE */ space = (space + ESD_BUF_SIZE-1) / ESD_BUF_SIZE * ESD_BUF_SIZE; dprintf("esd get_space: %d\n", space); return space; }
/* read a line of input string, giving prompt when appropriate */ static char *read_string(int echo, const char *prompt) { struct termios term_before, term_tmp; char line[INPUTSIZE]; struct sigaction old_sig; int delay, nc, have_term=0; D(("called with echo='%s', prompt='%s'.", echo ? "ON":"OFF" , prompt)); if (isatty(STDIN_FILENO)) { /* terminal state */ /* is a terminal so record settings and flush it */ if ( tcgetattr(STDIN_FILENO, &term_before) != 0 ) { D(("<error: failed to get terminal settings>")); return NULL; } memcpy(&term_tmp, &term_before, sizeof(term_tmp)); if (!echo) { term_tmp.c_lflag &= ~(ECHO); } have_term = 1; } else if (!echo) { D(("<warning: cannot turn echo off>")); } /* set up the signal handling */ delay = get_delay(); /* reading the line */ while (delay >= 0) { fprintf(stderr, "%s", prompt); /* this may, or may not set echo off -- drop pending input */ if (have_term) (void) tcsetattr(STDIN_FILENO, TCSAFLUSH, &term_tmp); if ( delay > 0 && set_alarm(delay, &old_sig) ) { D(("<failed to set alarm>")); break; } else { nc = read(STDIN_FILENO, line, INPUTSIZE-1); if (have_term) { (void) tcsetattr(STDIN_FILENO, TCSADRAIN, &term_before); if (!echo || expired) /* do we need a newline? */ fprintf(stderr,"\n"); } if ( delay > 0 ) { reset_alarm(&old_sig); } if (expired) { delay = get_delay(); } else if (nc > 0) { /* we got some user input */ char *input; if (nc > 0 && line[nc-1] == '\n') { /* <NUL> terminate */ line[--nc] = '\0'; } else { line[nc] = '\0'; } input = x_strdup(line); _pam_overwrite(line); return input; /* return malloc()ed string */ } else if (nc == 0) { /* Ctrl-D */ D(("user did not want to type anything")); fprintf(stderr, "\n"); break; } } } /* getting here implies that the timer expired */ if (have_term) (void) tcsetattr(STDIN_FILENO, TCSADRAIN, &term_before); memset(line, 0, INPUTSIZE); /* clean up */ return NULL; }
static int filter_frame(AVFilterLink *inlink, AVFrame *buf) { AVFilterContext *ctx = inlink->dst; ASyncContext *s = ctx->priv; AVFilterLink *outlink = ctx->outputs[0]; int nb_channels = av_get_channel_layout_nb_channels(buf->channel_layout); int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts : av_rescale_q(buf->pts, inlink->time_base, outlink->time_base); int out_size, ret; int64_t delta; int64_t new_pts; /* buffer data until we get the next timestamp */ if (s->pts == AV_NOPTS_VALUE || pts == AV_NOPTS_VALUE) { if (pts != AV_NOPTS_VALUE) { s->pts = pts - get_delay(s); } return write_to_fifo(s, buf); } if (s->first_pts != AV_NOPTS_VALUE) { handle_trimming(ctx); if (!avresample_available(s->avr)) return write_to_fifo(s, buf); } /* when we have two timestamps, compute how many samples would we have * to add/remove to get proper sync between data and timestamps */ delta = pts - s->pts - get_delay(s); out_size = avresample_available(s->avr); if (llabs(delta) > s->min_delta || (s->first_frame && delta && s->first_pts != AV_NOPTS_VALUE)) { av_log(ctx, AV_LOG_VERBOSE, "Discontinuity - %"PRId64" samples.\n", delta); out_size = av_clipl_int32((int64_t)out_size + delta); } else { if (s->resample) { // adjust the compensation if delta is non-zero int delay = get_delay(s); int comp = s->comp + av_clip(delta * inlink->sample_rate / delay, -s->max_comp, s->max_comp); if (comp != s->comp) { av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp); if (avresample_set_compensation(s->avr, comp, inlink->sample_rate) == 0) { s->comp = comp; } } } // adjust PTS to avoid monotonicity errors with input PTS jitter pts -= delta; delta = 0; } if (out_size > 0) { AVFrame *buf_out = ff_get_audio_buffer(outlink, out_size); if (!buf_out) { ret = AVERROR(ENOMEM); goto fail; } if (s->first_frame && delta > 0) { int planar = av_sample_fmt_is_planar(buf_out->format); int planes = planar ? nb_channels : 1; int block_size = av_get_bytes_per_sample(buf_out->format) * (planar ? 1 : nb_channels); int ch; av_samples_set_silence(buf_out->extended_data, 0, delta, nb_channels, buf->format); for (ch = 0; ch < planes; ch++) buf_out->extended_data[ch] += delta * block_size; avresample_read(s->avr, buf_out->extended_data, out_size); for (ch = 0; ch < planes; ch++) buf_out->extended_data[ch] -= delta * block_size; } else { avresample_read(s->avr, buf_out->extended_data, out_size); if (delta > 0) { av_samples_set_silence(buf_out->extended_data, out_size - delta, delta, nb_channels, buf->format); } } buf_out->pts = s->pts; ret = ff_filter_frame(outlink, buf_out); if (ret < 0) goto fail; s->got_output = 1; } else if (avresample_available(s->avr)) { av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping " "whole buffer.\n"); } /* drain any remaining buffered data */ avresample_read(s->avr, NULL, avresample_available(s->avr)); new_pts = pts - avresample_get_delay(s->avr); /* check for s->pts monotonicity */ if (new_pts > s->pts) { s->pts = new_pts; ret = avresample_convert(s->avr, NULL, 0, 0, buf->extended_data, buf->linesize[0], buf->nb_samples); } else { av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping " "whole buffer.\n"); ret = 0; } s->first_frame = 0; fail: av_frame_free(&buf); return ret; }
int main(int argc, char *argv[]) { enum APP_TYPE app_type = UNKNOWN_APP; int prog_argc = 0; uint32_t magic_options = 0; bool wait_term = true; unsigned int delay = DEFAULT_DELAY; unsigned int respawn_delay = RESPAWN_DELAY; char **prog_argv = NULL; char *prog_name = NULL; struct stat file_stat; // wait-term parameter by default magic_options |= INVOKER_MSG_MAGIC_OPTION_WAIT; // Called with a different name (old way of using invoker) ? if (!strstr(argv[0], PROG_NAME_INVOKER) ) { die(1, "Incorrect use of invoker, don't use symlinks. " "Run invoker explicitly from e.g. a D-Bus service file instead.\n"); } // Stops parsing args as soon as a non-option argument is encountered putenv("POSIXLY_CORRECT=1"); // Options recognized struct option longopts[] = { {"help", no_argument, NULL, 'h'}, {"creds", no_argument, NULL, 'c'}, {"wait-term", no_argument, NULL, 'w'}, {"no-wait", no_argument, NULL, 'n'}, {"global-syms", no_argument, NULL, 'G'}, {"deep-syms", no_argument, NULL, 'D'}, {"single-instance", no_argument, NULL, 's'}, {"type", required_argument, NULL, 't'}, {"delay", required_argument, NULL, 'd'}, {"respawn", required_argument, NULL, 'r'}, {0, 0, 0, 0} }; // Parse options // TODO: Move to a function int opt; while ((opt = getopt_long(argc, argv, "hcwnGDsd:t:r:", longopts, NULL)) != -1) { switch(opt) { case 'h': usage(0); break; case 'c': show_credentials(); break; case 'w': // nothing to do, it's by default now break; case 'n': wait_term = false; magic_options &= (~INVOKER_MSG_MAGIC_OPTION_WAIT); break; case 'G': magic_options |= INVOKER_MSG_MAGIC_OPTION_DLOPEN_GLOBAL; break; case 'D': magic_options |= INVOKER_MSG_MAGIC_OPTION_DLOPEN_DEEP; break; case 't': if (strcmp(optarg, "m") == 0) app_type = M_APP; else if (strcmp(optarg, "q") == 0 || strcmp(optarg, "qt") == 0) app_type = QT_APP; else if (strcmp(optarg, "d") == 0) app_type = QDECL_APP; else { report(report_error, "Unknown application type: %s \n", optarg); usage(1); } break; case 'd': delay = get_delay(optarg, "delay"); break; case 'r': respawn_delay = get_delay(optarg, "respawn delay"); if (respawn_delay > MAX_RESPAWN_DELAY) { report(report_error, "Booster respawn delay exceeds max possible time.\n"); usage(1); } break; case 's': magic_options |= INVOKER_MSG_MAGIC_OPTION_SINGLE_INSTANCE; break; case '?': usage(1); } } // Option processing stops as soon as application name is encountered if (optind < argc) { prog_name = search_program(argv[optind]); if (!prog_name) { report(report_error, "Can't find application to invoke.\n"); usage(0); } prog_argc = argc - optind; prog_argv = &argv[optind]; } // Check if application name isn't defined if (!prog_name) { report(report_error, "Application's name is not defined.\n"); usage(1); } // Check if application exists if (stat(prog_name, &file_stat)) { report(report_error, "%s: not found\n", prog_name); return EXIT_STATUS_APPLICATION_NOT_FOUND; } // Check that if (!S_ISREG(file_stat.st_mode) && !S_ISLNK(file_stat.st_mode)) { report(report_error, "%s: not a file\n", prog_name); return EXIT_STATUS_APPLICATION_NOT_FOUND; } // Check if application type is unknown if (app_type == UNKNOWN_APP) { report(report_error, "Application's type is unknown.\n"); usage(1); } // Send commands to the launcher daemon info("Invoking execution: '%s'\n", prog_name); int ret_val = invoke(prog_argc, prog_argv, prog_name, app_type, magic_options, wait_term, respawn_delay); // Sleep for delay before exiting if (delay) { // DBUS cannot cope some times if the invoker exits too early. debug("Delaying exit for %d seconds..\n", delay); sleep(delay); } return ret_val; }
/***************************************************************************** * process_bpm_change() * * Process a BPM change pseudo MIDI message. Currently used when syncing * JACK Transport, this adjust BPM, independent of controller assignment. * * TODO: Rework _all_ phasex BPM code, since this is almost identical to * update_bpm() in bpm.c. *****************************************************************************/ void process_bpm_change(MIDI_EVENT *event, unsigned int part_num) { PART *part = get_part(part_num); PATCH_STATE *state = get_active_state(part_num); PARAM *param = get_param(part_num, PARAM_BPM); DELAY *delay = get_delay(part_num); CHORUS *chorus = get_chorus(part_num); VOICE *voice; int int_val = (int)(event->float_value); int cc_val = int_val - 64; int voice_num; int lfo; int osc; PHASEX_DEBUG(DEBUG_CLASS_MIDI_TIMING, "+++ Processing BPM change. New BPM = %lf +++\n", event->float_value); param->value.cc_val = cc_val; param->value.int_val = int_val; /* For now, this is handled much like the normal param callback for BPM, execpt that here we use floating point values instead of integer. */ global.bpm = event->float_value; global.bps = event->float_value / 60.0; if (param->value.cc_val != cc_val) { param->value.cc_prev = param->value.cc_val; param->value.cc_val = cc_val; param->value.int_val = int_val; param->updated = 1; } /* initialize all variables based on bpm */ state->bpm = event->float_value; state->bpm_cc = (short)(param->value.cc_val & 0x7F); /* re-initialize delay size */ delay->size = state->delay_time * f_sample_rate / global.bps; delay->length = (int)(delay->size); /* re-initialize chorus lfos */ chorus->lfo_freq = global.bps * state->chorus_lfo_rate; chorus->lfo_adjust = chorus->lfo_freq * wave_period; chorus->phase_freq = global.bps * state->chorus_phase_rate; chorus->phase_adjust = chorus->phase_freq * wave_period; /* per-lfo setup */ for (lfo = 0; lfo < NUM_LFOS; lfo++) { /* re-calculate frequency and corresponding index adjustment */ if (state->lfo_freq_base[lfo] >= FREQ_BASE_TEMPO) { part->lfo_freq[lfo] = global.bps * state->lfo_rate[lfo]; part->lfo_adjust[lfo] = part->lfo_freq[lfo] * wave_period; } } /* per-oscillator setup */ for (osc = 0; osc < NUM_OSCS; osc++) { /* re-calculate tempo based osc freq */ if (state->osc_freq_base[osc] >= FREQ_BASE_TEMPO) { for (voice_num = 0; voice_num < setting_polyphony; voice_num++) { voice = get_voice(part_num, voice_num); voice->osc_freq[osc] = global.bps * state->osc_rate[osc]; } } } }
static size_t send_ping_ready_cb (void *cls, size_t size, void *buf) { struct BenchmarkPartner *p = cls; static char msgbuf[TEST_MESSAGE_SIZE]; struct GNUNET_MessageHeader *msg; struct GNUNET_TIME_Relative delay; if (NULL == buf) { GNUNET_break (0); return 0; } if (size < TEST_MESSAGE_SIZE) { GNUNET_break (0); return 0; } GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Master [%u]: Sending PING to [%u]\n", p->me->no, p->dest->no); if (top->test_core) { if (NULL == p->cth) { GNUNET_break (0); } p->cth = NULL; } else { if (NULL == p->tth) { GNUNET_break (0); } p->tth = NULL; } msg = (struct GNUNET_MessageHeader *) &msgbuf; memset (&msgbuf, 'a', TEST_MESSAGE_SIZE); msg->type = htons (TEST_MESSAGE_TYPE_PING); msg->size = htons (TEST_MESSAGE_SIZE); memcpy (buf, msg, TEST_MESSAGE_SIZE); p->messages_sent++; p->bytes_sent += TEST_MESSAGE_SIZE; p->me->total_messages_sent++; p->me->total_bytes_sent += TEST_MESSAGE_SIZE; if (NULL == p->tg) { GNUNET_break (0); return TEST_MESSAGE_SIZE; } delay = get_delay (p->tg); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Delay for next transmission %llu ms\n", (long long unsigned int) delay.rel_value_us / 1000); p->tg->next_ping_transmission = GNUNET_TIME_absolute_add(GNUNET_TIME_absolute_get(), delay); return TEST_MESSAGE_SIZE; }
/***************************************************************************** * process_phase_sync() * * Process a phase sync internal MIDI message. Currently used for syncing * JACK Transport, this function performs phase correction for a given voice. *****************************************************************************/ void process_phase_sync(MIDI_EVENT *event, unsigned int part_num) { PART *part = get_part(part_num); PATCH_STATE *state = get_active_state(part_num); DELAY *delay = get_delay(part_num); CHORUS *chorus = get_chorus(part_num); VOICE *voice; int voice_num; int osc; int lfo; int phase_correction = event->value; sample_t f_phase_correction = (sample_t) phase_correction; sample_t tmp_1; delay->write_index += phase_correction; while (delay->write_index < 0.0) { delay->write_index += delay->bufsize; } while (delay->write_index >= delay->bufsize) { delay->write_index -= delay->bufsize; } chorus->lfo_index_a += f_phase_correction * chorus->lfo_adjust; while (chorus->lfo_index_a < 0.0) { chorus->lfo_index_a += F_WAVEFORM_SIZE; } while (chorus->lfo_index_a >= F_WAVEFORM_SIZE) { chorus->lfo_index_a -= F_WAVEFORM_SIZE; } chorus->lfo_index_b = chorus->lfo_index_a + (F_WAVEFORM_SIZE * 0.25); while (chorus->lfo_index_b < 0.0) { chorus->lfo_index_b += F_WAVEFORM_SIZE; } while (chorus->lfo_index_b >= F_WAVEFORM_SIZE) { chorus->lfo_index_b -= F_WAVEFORM_SIZE; } chorus->lfo_index_c = chorus->lfo_index_a + (F_WAVEFORM_SIZE * 0.5); while (chorus->lfo_index_c < 0.0) { chorus->lfo_index_c += F_WAVEFORM_SIZE; } while (chorus->lfo_index_c >= F_WAVEFORM_SIZE) { chorus->lfo_index_c -= F_WAVEFORM_SIZE; } chorus->lfo_index_d = chorus->lfo_index_a + (F_WAVEFORM_SIZE * 0.75); while (chorus->lfo_index_d < 0.0) { chorus->lfo_index_d += F_WAVEFORM_SIZE; } while (chorus->lfo_index_d >= F_WAVEFORM_SIZE) { chorus->lfo_index_d -= F_WAVEFORM_SIZE; } for (voice_num = 0; voice_num < setting_polyphony; voice_num++) { voice = get_voice(part_num, voice_num); for (osc = 0; osc < NUM_OSCS; osc++) { if (state->osc_freq_base[osc] >= FREQ_BASE_TEMPO) { switch (state->freq_mod_type[osc]) { case MOD_TYPE_LFO: tmp_1 = part->lfo_out[state->freq_lfo[osc]]; break; case MOD_TYPE_OSC: tmp_1 = (voice->osc_out1[part->osc_freq_mod[osc]] + voice->osc_out2[part->osc_freq_mod[osc]]) * 0.5; break; case MOD_TYPE_VELOCITY: tmp_1 = voice->velocity_coef_linear; break; default: tmp_1 = 0.0; break; } voice->index[osc] += f_phase_correction * halfsteps_to_freq_mult((tmp_1 * state->freq_lfo_amount[osc]) + part->osc_pitch_bend[osc] + state->osc_transpose[osc] + state->voice_osc_tune[voice->id] ) * voice->osc_freq[osc] * wave_period; while (voice->index[osc] < 0.0) { voice->index[osc] += F_WAVEFORM_SIZE; } while (voice->index[osc] >= F_WAVEFORM_SIZE) { voice->index[osc] -= F_WAVEFORM_SIZE; } } } } for (lfo = 0; lfo < NUM_LFOS; lfo++) { if (state->lfo_freq_base[lfo] >= FREQ_BASE_TEMPO) { part->lfo_index[lfo] += f_phase_correction * part->lfo_freq[lfo] * halfsteps_to_freq_mult(state->lfo_transpose[lfo] + part->lfo_pitch_bend[lfo]) * wave_period; while (part->lfo_index[lfo] < 0.0) { part->lfo_index[lfo] += F_WAVEFORM_SIZE; } while (part->lfo_index[lfo] >= F_WAVEFORM_SIZE) { part->lfo_index[lfo] -= F_WAVEFORM_SIZE; } } } }
int main(int argc, char* argv[]){ char chosen_server[500]; int lowest_stratum = 1000; int j; for (j = 4; j >= 0; j--) { struct timespec t1_time, t4_time; double sec, ns; header_t header; memset(&header, 0, sizeof(header_t)); times_t timestamps; char* node = server_list[j]; printf("------------\n"); printf("Testing server %s\n", server_list[j]); char* service = "123"; int status; struct addrinfo hints; struct addrinfo *serverinfo, recmsg; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_DGRAM; if ((status = getaddrinfo(node, service, &hints, &serverinfo)) != 0){ fprintf(stderr, "Error resolving host name or IP address\n"); exit(1); } int sockfd = socket(serverinfo->ai_family, serverinfo->ai_socktype, serverinfo->ai_protocol); // Start time if( clock_gettime( CLOCK_REALTIME, &t1_time) == -1 ) { perror( "clock gettime" ); exit( EXIT_FAILURE ); } /* Version set to 4 and Mode to 3 (Client), rest to 0 */ header.control[0] = 35; header.control[1] = 0; header.control[2] = 0; header.control[3] = 0; int i; printf("Control: "); for (i = 0; i < 4; i++) printf("%x|", header.control[i]); header.origin_t = time_to_NTP(t1_time); printf("\nSending header...\n"); int send_res; send_res = sendto(sockfd, &header, sizeof(header_t), 0, serverinfo->ai_addr, serverinfo->ai_addrlen); printf("Sent\n"); // Prepare receive timestamps.t1 = header.origin_t; printf("Waiting to receive header...\n"); //header_t rec_header; int bytes_rec; bytes_rec = recvfrom(sockfd, &header, sizeof(header_t), 0, serverinfo->ai_addr, &recmsg.ai_addrlen); printf("Received, result: %d\n", bytes_rec); // End time if( clock_gettime( CLOCK_REALTIME, &t4_time) == -1 ) { perror( "clock gettime" ); exit( EXIT_FAILURE ); } // Use netohost() to convert from the network byte order to host byte order! close(sockfd); timestamps.t2 = net_to_host(header.receive_t) - ((long )(2208988800) << 32); timestamps.t3 = net_to_host(header.transmit_t) - ((long )(2208988800) << 32); timestamps.t4 = time_to_NTP(t4_time); /* printf("Timestamps:\n"); printf("t1: %u %u\n", (int)(timestamps.t1 >> 32), (int)(timestamps.t1)); printf("t2: %u %u\n", (int)(timestamps.t2 >> 32), (int)(timestamps.t2)); printf("t3: %u %u\n", (int)(timestamps.t3 >> 32), (int)(timestamps.t3)); printf("t4: %u %u\n[all ns above were ns_frac]\n", (int)(timestamps.t4 >> 32), (int)(timestamps.t4)); */ long delay = NTP_to_ns(get_delay(timestamps)); long offset = NTP_to_ns(get_offset(timestamps)); printf("Delay: %u s %u ns\n", (int)(delay >> 32), (int)(delay)); printf("Offset: %d s %d ns\n", (int)(offset >> 32), (int)(offset)); printf("Stratum: %d\n", header.control[1]); if (header.control[1] < lowest_stratum) { lowest_stratum = header.control[1]; strcpy(chosen_server, server_list[j]); } printf("------------\n"); } printf("Chosen server with Stratum = %d: %s\n", lowest_stratum, chosen_server); return 0; }
int main(int argc, char *argv[]) { const char *app_type = NULL; int prog_argc = 0; uint32_t magic_options = 0; bool wait_term = true; unsigned int delay = EXIT_DELAY; unsigned int respawn_delay = RESPAWN_DELAY; char **prog_argv = NULL; char *prog_name = NULL; char *splash_file = NULL; char *landscape_splash_file = NULL; struct stat file_stat; bool test_mode = false; // wait-term parameter by default magic_options |= INVOKER_MSG_MAGIC_OPTION_WAIT; // Called with a different name (old way of using invoker) ? if (!strstr(argv[0], PROG_NAME_INVOKER) ) { die(1, "Incorrect use of invoker, don't use symlinks. " "Run invoker explicitly from e.g. a D-Bus service file instead.\n"); } // Stops parsing args as soon as a non-option argument is encountered putenv("POSIXLY_CORRECT=1"); // Options recognized struct option longopts[] = { {"help", no_argument, NULL, 'h'}, {"wait-term", no_argument, NULL, 'w'}, {"no-wait", no_argument, NULL, 'n'}, {"global-syms", no_argument, NULL, 'G'}, {"deep-syms", no_argument, NULL, 'D'}, {"single-instance", no_argument, NULL, 's'}, {"daemon-mode", no_argument, NULL, 'o'}, {"test-mode", no_argument, NULL, 'T'}, {"type", required_argument, NULL, 't'}, {"delay", required_argument, NULL, 'd'}, {"respawn", required_argument, NULL, 'r'}, {"splash", required_argument, NULL, 'S'}, {"splash-landscape", required_argument, NULL, 'L'}, {0, 0, 0, 0} }; // Parse options // TODO: Move to a function int opt; while ((opt = getopt_long(argc, argv, "hcwnGDsoTd:t:r:S:L:", longopts, NULL)) != -1) { switch(opt) { case 'h': usage(0); break; case 'w': // nothing to do, it's by default now break; case 'o': magic_options |= INVOKER_MSG_MAGIC_OPTION_OOM_ADJ_DISABLE; break; case 'n': wait_term = false; magic_options &= (~INVOKER_MSG_MAGIC_OPTION_WAIT); break; case 'G': magic_options |= INVOKER_MSG_MAGIC_OPTION_DLOPEN_GLOBAL; break; case 'D': magic_options |= INVOKER_MSG_MAGIC_OPTION_DLOPEN_DEEP; break; case 'T': test_mode = true; break; case 't': app_type = optarg; break; case 'd': delay = get_delay(optarg, "delay", MIN_EXIT_DELAY, MAX_EXIT_DELAY); break; case 'r': respawn_delay = get_delay(optarg, "respawn delay", MIN_RESPAWN_DELAY, MAX_RESPAWN_DELAY); break; case 's': magic_options |= INVOKER_MSG_MAGIC_OPTION_SINGLE_INSTANCE; break; case 'S': magic_options |= INVOKER_MSG_MAGIC_OPTION_SPLASH_SCREEN; splash_file = optarg; break; case 'L': magic_options |= INVOKER_MSG_MAGIC_OPTION_LANDSCAPE_SPLASH_SCREEN; landscape_splash_file = optarg; break; case '?': usage(1); } } // Option processing stops as soon as application name is encountered if (optind < argc) { prog_name = search_program(argv[optind]); prog_argc = argc - optind; prog_argv = &argv[optind]; } // Check if application name isn't defined if (!prog_name) { report(report_error, "Application's name is not defined.\n"); usage(1); } // Check if application exists if (stat(prog_name, &file_stat)) { report(report_error, "%s: not found\n", prog_name); return EXIT_STATUS_APPLICATION_NOT_FOUND; } // Check that if (!S_ISREG(file_stat.st_mode) && !S_ISLNK(file_stat.st_mode)) { report(report_error, "%s: not a file\n", prog_name); return EXIT_STATUS_APPLICATION_NOT_FOUND; } if (!app_type) { report(report_error, "Application type must be specified with --type.\n"); usage(1); } // Translate 'qt' and 'm' types to 'q' for compatibility if (!strcmp(app_type, "qt") || !strcmp(app_type, "m")) app_type = "q"; // Check if application type is unknown. Only accept one character types. if (!app_type[0] || app_type[1]) { report(report_error, "Application's type is unknown.\n"); usage(1); } if (pipe(g_signal_pipe) == -1) { report(report_error, "Creating a pipe for Unix signals failed!\n"); exit(EXIT_FAILURE); } // Send commands to the launcher daemon info("Invoking execution: '%s'\n", prog_name); int ret_val = invoke(prog_argc, prog_argv, prog_name, *app_type, magic_options, wait_term, respawn_delay, splash_file, landscape_splash_file, test_mode); // Sleep for delay before exiting if (delay) { // DBUS cannot cope some times if the invoker exits too early. debug("Delaying exit for %d seconds..\n", delay); sleep(delay); } return ret_val; }
/* Brute force all possible WPS pins for a given access point */ void crack() { unsigned char *bssid = NULL; char *pin = NULL; int fail_count = 0, loop_count = 0, sleep_count = 0, assoc_fail_count = 0; float pin_count = 0; time_t start_time = 0; enum wps_result result = 0; /* MAC CHANGER VARIABLES */ int mac_changer_counter = 0; char mac[MAC_ADDR_LEN] = { 0 }; unsigned char mac_string [] = "ZZ:ZZ:ZZ:ZZ:ZZ:ZZ"; unsigned char* new_mac = &mac_string[0]; char last_digit = '0'; if(!get_iface()) { return; } if(get_max_pin_attempts() == -1) { cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n"); return; } /* Initialize network interface */ set_handle(capture_init(get_iface())); if(get_handle() != NULL) { generate_pins(); /* Restore any previously saved session */ if(get_static_p1() == NULL) { restore_session(); } /* Convert BSSID to a string */ bssid = mac2str(get_bssid(), ':'); /* * We need to get some basic info from the AP, and also want to make sure the target AP * actually exists, so wait for a beacon packet */ cprintf(INFO, "[+] Waiting for beacon from %s\n", bssid); read_ap_beacon(); process_auto_options(); /* I'm fairly certian there's a reason I put this in twice. Can't remember what it was now though... */ if(get_max_pin_attempts() == -1) { cprintf(CRITICAL, "[X] ERROR: This device has been blacklisted and is not supported.\n"); return; } /* This initial association is just to make sure we can successfully associate */ while(!reassociate()) { if(assoc_fail_count == MAX_ASSOC_FAILURES) { assoc_fail_count = 0; cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid()); } else { assoc_fail_count++; } } cprintf(INFO, "[+] Associated with %s (ESSID: %s)\n", bssid, get_ssid()); /* Used to calculate pin attempt rates */ start_time = time(NULL); /* If the key status hasn't been explicitly set by restore_session(), ensure that it is set to KEY1_WIP */ if(get_key_status() <= KEY1_WIP) { set_key_status(KEY1_WIP); } /* * If we're starting a session at KEY_DONE, that means we've already cracked the pin and the AP is being re-attacked. * Re-set the status to KEY2_WIP so that we properly enter the main cracking loop. */ else if(get_key_status() == KEY_DONE) { set_key_status(KEY2_WIP); } //copy the current mac to the new_mac variable for mac changer if (get_mac_changer() == 1) { strncpy(new_mac, mac2str(get_mac(), ':'), 16); } /* Main cracking loop */ for(loop_count=0, sleep_count=0; get_key_status() != KEY_DONE; loop_count++, sleep_count++) { //MAC Changer switch/case to define the last mac address digit if (get_mac_changer() == 1) { switch (mac_changer_counter) { case 0: last_digit = '0'; break; case 1: last_digit = '1'; break; case 2: last_digit = '2'; break; case 3: last_digit = '3'; break; case 4: last_digit = '4'; break; case 5: last_digit = '5'; break; case 6: last_digit = '6'; break; case 7: last_digit = '7'; break; case 8: last_digit = '8'; break; case 9: last_digit = '9'; break; case 10: last_digit = 'A'; break; case 11: last_digit = 'B'; break; case 12: last_digit = 'C'; break; case 13: last_digit = 'D'; break; case 14: last_digit = 'E'; break; case 15: last_digit = 'F'; mac_changer_counter = -1; break; } mac_changer_counter++; new_mac[16] = last_digit; //transform the string to a MAC and define the MAC str2mac((unsigned char *) new_mac, (unsigned char *) &mac); set_mac((unsigned char *) &mac); cprintf(WARNING, "[+] Using MAC %s \n", mac2str(get_mac(), ':')); } /* * Some APs may do brute force detection, or might not be able to handle an onslaught of WPS * registrar requests. Using a delay here can help prevent the AP from locking us out. */ pcap_sleep(get_delay()); /* Users may specify a delay after x number of attempts */ if((get_recurring_delay() > 0) && (sleep_count == get_recurring_delay_count())) { cprintf(VERBOSE, "[+] Entering recurring delay of %d seconds\n", get_recurring_delay()); pcap_sleep(get_recurring_delay()); sleep_count = 0; } /* * Some APs identify brute force attempts and lock themselves for a short period of time (typically 5 minutes). * Verify that the AP is not locked before attempting the next pin. */ while(get_ignore_locks() == 0 && is_wps_locked()) { cprintf(WARNING, "[!] WARNING: Detected AP rate limiting, waiting %d seconds before re-checking\n", get_lock_delay()); pcap_sleep(get_lock_delay()); } /* Initialize wps structure */ set_wps(initialize_wps_data()); if(!get_wps()) { cprintf(CRITICAL, "[-] Failed to initialize critical data structure\n"); break; } /* Try the next pin in the list */ pin = build_next_pin(); if(!pin) { cprintf(CRITICAL, "[-] Failed to generate the next payload\n"); break; } else { cprintf(WARNING, "[+] Trying pin %s\n", pin); } /* * Reassociate with the AP before each WPS exchange. This is necessary as some APs will * severely limit our pin attempt rate if we do not. */ assoc_fail_count = 0; while(!reassociate()) { if(assoc_fail_count == MAX_ASSOC_FAILURES) { assoc_fail_count = 0; cprintf(CRITICAL, "[!] WARNING: Failed to associate with %s (ESSID: %s)\n", bssid, get_ssid()); } else { assoc_fail_count++; } } /* * Enter receive loop. This will block until a receive timeout occurs or a * WPS transaction has completed or failed. */ result = do_wps_exchange(); switch(result) { /* * If the last pin attempt was rejected, increment * the pin counter, clear the fail counter and move * on to the next pin. */ case KEY_REJECTED: fail_count = 0; pin_count++; advance_pin_count(); break; /* Got it!! */ case KEY_ACCEPTED: break; /* Unexpected timeout or EAP failure...try this pin again */ default: cprintf(VERBOSE, "[!] WPS transaction failed (code: 0x%.2X), re-trying last pin\n", result); fail_count++; break; } /* If we've had an excessive number of message failures in a row, print a warning */ if(fail_count == WARN_FAILURE_COUNT) { cprintf(WARNING, "[!] WARNING: %d failed connections in a row\n", fail_count); fail_count = 0; pcap_sleep(get_fail_delay()); } /* Display status and save current session state every DISPLAY_PIN_COUNT loops */ if(loop_count == DISPLAY_PIN_COUNT) { save_session(); display_status(pin_count, start_time); loop_count = 0; } /* * The WPA key and other settings are stored in the globule->wps structure. If we've * recovered the WPS pin and parsed these settings, don't free this structure. It * will be freed by wpscrack_free() at the end of main(). */ if(get_key_status() != KEY_DONE) { wps_deinit(get_wps()); set_wps(NULL); } /* If we have cracked the pin, save a copy */ else { set_pin(pin); } free(pin); pin = NULL; /* If we've hit our max number of pin attempts, quit */ if((get_max_pin_attempts() > 0) && (pin_count == get_max_pin_attempts())) { cprintf(VERBOSE, "[+] Quitting after %d crack attempts\n", get_max_pin_attempts()); break; } } if(bssid) free(bssid); if(get_handle()) { pcap_close(get_handle()); set_handle(NULL); } } else { cprintf(CRITICAL, "[-] Failed to initialize interface '%s'\n", get_iface()); } }
TITANIUM_PROPERTY_GETTER(Animation, delay) { return get_context().CreateNumber(static_cast<double>(get_delay().count())); }