void reconstruct() {
holger_time_start(1, "Reconstruction");
memset(volume, 0, sizeof(unsigned char)*volume_w*volume_h*volume_n);
printf("bscan_w/h: %d %d\n", bscan_w, bscan_h);
printf("volume_w/h/n: %d %d %d\n", volume_w, volume_h, volume_n);
printf("volume_spacing: %f\n", volume_spacing);
printf("volume_origo: %f %f %f\n", volume_origo.x, volume_origo.y, volume_origo.z);
printf("\n");
holger_time(1, "Initialization");
// Fill up queue
for (int i = 0; i < BSCAN_WINDOW; i++) {
shift_queues();
wait_for_input();
if (end_of_data()) break;
}
int counter = BSCAN_WINDOW;
while(true) {
// Retrieve ultrasound data and perform ye olde switcheroo
shift_queues();
wait_for_input();
if (end_of_data()) break;
holger_time(1, "Retrieve ultrasound data");
printf("Reconstructing %d ...\n", counter);
calibrate_pos_matrix(pos_matrices_queue[BSCAN_WINDOW-1], cal_matrix);
holger_time(1, "Calibrate");
printf("Calibrate\n");
insert_plane_points(pos_matrices_queue[BSCAN_WINDOW-1]);
holger_time(1, "Fill, transform and translate plane_points");
printf("plane_points\n");
insert_plane_eq();
holger_time(1, "Fill bscan_plane_equation");
printf("bscan_plane_equation\n");
//int axis = find_orthogonal_axis(bscan_plane_equation); // TODO: Function that finds axis most orthogonal to bscan plane
int axis = 0; // Actually, turns out that the output is pretty much equal for any axis,
// but the computation time varies (1X - 2X)
int intersection_counter = find_intersections(axis);
holger_time(1, "Find ray-plane intersections");
printf("intersections\n");
fill_voxels(intersection_counter);
holger_time(1, "Fill voxels");
printf("voxels\n");
counter++;
}
holger_time_print(1);
}
int
QLuaConsole::Private::getchar()
{
// --- This runs from the console thread,
// mutex is unlocked.
// is data available already?
int fd = fileno(stdin);
if (wait_for_input(1, &fd, false) >= 0)
return fgetc(stdin);
// we must wait
QMutexLocker lock(&mutex);
while (! killConsole)
{
int fds[3];
int nfd = 0;
if (! throttleActive)
fds[nfd++] = stdoutPipe[0];
fds[nfd++] = commandPipe[0];
fds[nfd++] = fileno(stdin);
lock.unlock();
int fd = wait_for_input(nfd, fds);
lock.relock();
if (! throttleActive)
copyout();
if (fd == commandPipe[0])
{
char c = (char)NoCmd;
if (::read(commandPipe[0], &c, 1) > 0)
switch( (enum Command)c )
{
case HandlerCmd:
sethandler();
break;
case DrainCmd:
msleep(10);
copyout(throttleActive = false);
drain.wakeAll();
break;
case BreakCmd:
if (lua && breakStopsLua)
lua->stop();
emit q->ttyBreak();
break;
case KillCmd:
killConsole = true;
case AbortCmd:
rtty_status = RttyAbort;
default:
break;
}
}
if (rtty_status == RttyAbort)
break;
if (fd == fileno(stdin))
return fgetc(stdin);
}
return EOF;
}
int msgbox(char *message)
{
int len = strlen(message);
int x;
attrset(COLOR_PAIR(COLOR_WHITE) | A_BOLD);
for(x = -5; x < len + 5; x++) {
mvaddch(MAP_YSIZE / 2 - 2, (MAP_XSIZE / 2) - (len / 2) + x, '+');
mvaddch(MAP_YSIZE / 2 - 1, (MAP_XSIZE / 2) - (len / 2) + x, '+');
mvaddch(MAP_YSIZE / 2 + 0, (MAP_XSIZE / 2) - (len / 2) + x, '+');
mvaddch(MAP_YSIZE / 2 + 1, (MAP_XSIZE / 2) - (len / 2) + x, '+');
mvaddch(MAP_YSIZE / 2 + 2, (MAP_XSIZE / 2) - (len / 2) + x, '+');
}
for(x = -3; x < len + 3; x++) {
mvaddch(MAP_YSIZE / 2 - 1, (MAP_XSIZE / 2) - (len / 2) + x, ' ');
mvaddch(MAP_YSIZE / 2 + 0, (MAP_XSIZE / 2) - (len / 2) + x, ' ');
mvaddch(MAP_YSIZE / 2 + 1, (MAP_XSIZE / 2) - (len / 2) + x, ' ');
}
attrset(COLOR_PAIR(COLOR_WHITE) | A_NORMAL);
mvprintw(MAP_YSIZE / 2 + 0, (MAP_XSIZE / 2) - (len / 2), "%s", message);
attrset(A_NORMAL);
return wait_for_input();
}
int main() {
mu::PlayerRt player_rt;
mu::Transport transport;
Metronome *metronome = new Metronome();
RoomTone *room_tone = new RoomTone();
Plucks2 *plucks2 = new Plucks2();
Plucks3 *plucks3 = new Plucks3();
mu::SumStream *mix = new mu::SumStream();
printf("1 beat = %ld ticks\n", beat_to_tick(1));
mix->add_source(room_tone->stream());
mix->add_source(plucks2->setup());
mix->add_source(plucks3->setup());
mix->add_source(metronome->stream());
printf("mix:\n%s\n", mix->inspect().c_str());
transport.set_player(&player_rt);
transport.set_source(mix);
transport.run();
wait_for_input();
transport.stop();
return 0;
}
void
QLuaConsole::Private::readline()
{
// --- This runs from the console thread,
// mutex is locked.
int status = 0;
QByteArray prompt = this->prompt;
QByteArray ba;
mutex.unlock();
ba = rtty_readline(prompt.constData());
mutex.lock();
switch (rtty_status)
{
case RttyOk:
emit q->ttyInput(ba);
break;
case RttyEof:
emit q->ttyEndOfFile();
case RttyAbort:
// drain output
clearerr(stdin);
int fd = fileno(stdin);
if (wait_for_input(1, &fd, false) >= 0)
fgetc(stdin);
break;
}
}
static void maybe_read(struct thread *thread)
{
obj_t *fp = thread->fp;
int fd = fixnum_value(fp[-9]);
int nfound, res;
obj_t *old_sp;
nfound = input_available(fd);
if (nfound < 0) {
old_sp = pop_linkage(thread);
thread->sp = old_sp + 2;
old_sp[0] = obj_False;
old_sp[1] = make_fixnum(errno);
do_return(thread, old_sp, old_sp);
}
else if (nfound == 0)
wait_for_input(thread, fd, maybe_read);
else {
res = mindy_read(fd,
(char *)(buffer_data(fp[-8]) + fixnum_value(fp[-7])),
fixnum_value(fp[-6]));
results(thread, pop_linkage(thread), res, make_fixnum(res));
}
}
static void frontend_ctr_deinit(void *data)
{
(void)data;
#ifndef IS_SALAMANDER
global_t *global = global_get_ptr();
global->verbosity = true;
#ifdef HAVE_FILE_LOGGER
if (global->log_file)
fclose(global->log_file);
global->log_file = NULL;
#endif
wait_for_input();
csndExit();
gfxExit();
#if 0
sdmcExit();
fsExit();
hidExit();
aptExit();
srvExit();
#endif
#endif
}
int getline(t_input *input, const int interactive, const int mode,
size_t *state)
{
t_term *term;
int ret;
term = &get_shell_data()->term;
ret = 0;
if (interactive == 1)
{
apply_termcaps("ks");
set_shell_sigmode(e_shell_sigmode_line_editing);
restore_custom_attr(term);
if ((ret = wait_for_input(input, mode)) == MALLOC_FAIL)
return (ret);
apply_termcaps("ke");
set_shell_sigmode(e_shell_sigmode_shell);
restore_initial_attr(term);
}
else
{
if ((ret = get_line_from_file(input, state)) == MALLOC_FAIL)
return (MALLOC_FAIL);
}
(ret == RETURN) ? ret = 0 : 0;
return (ret);
}
static void wait_report(int fd, int timeout)
{
struct hiddev_usage_ref uref;
if (wait_for_input(fd, timeout) > 0)
while (read(fd, &uref, sizeof(uref)) > 0)
;
}
/**
* Presents information about the game to the player.
*/
Code info(SDL_Renderer *renderer, CommandTable *table) {
char buffer[ABOUT_PAGE_BUFFER_SIZE];
Code code = read_characters(ABOUT_PAGE_PATH, buffer, ABOUT_PAGE_BUFFER_SIZE);
if (code != CODE_OK) {
log_message("Failed to read the text.");
return code;
}
print_long_text(buffer, renderer);
return wait_for_input(table);
}
static int FILE_recv_binary(FILE *in, FILE *out)
{
size_t n;
char *buf;
time_t then = time(0) - 1;
time_t now;
ftp_set_close_handler();
if(foo_hookf)
foo_hookf(&ftp->ti);
ftp->ti.begin = false;
clearerr(in);
clearerr(out);
buf = (char *)xmalloc(FTP_BUFSIZ);
while(!feof(in)) {
if(wait_for_input() != 0) {
ftp_trace("wait_for_input() returned non-zero\n");
break;
}
#ifdef SECFTP
n = sec_read(fileno(in), buf, FTP_BUFSIZ);
#else
n = fread(buf, sizeof(char), FTP_BUFSIZ, in);
#endif
if(n <= 0)
break;
if(ftp_sigints() > 0) {
ftp_trace("break due to sigint\n");
break;
}
if(fwrite(buf, sizeof(char), n, out) != n)
break;
ftp->ti.size += n;
if(foo_hookf) {
now = time(0);
if(now > then) {
foo_hookf(&ftp->ti);
then = now;
}
}
}
free(buf);
ftp_set_close_handler();
return maybe_abort(in, out);
}
int main() {
mu::RenderStream *kick_rs = make_perc_kick_rs();
mu::Transport transport;
mu::PlayerRt player_rt;
transport.set_source(kick_rs);
transport.set_player(&player_rt);
transport.run();
wait_for_input();
return 0;
}
void
QLuaConsole::Private::run()
{
// --- This runs from the console thread.
// accept signals in this thread.
set_sigint_handler(SIG_DFL);
release_signals(&savedSigSet);
// loop
while (! killConsole)
{
int fds[2];
int nfd = 0;
if (! throttleActive)
fds[nfd++] = stdoutPipe[0];
fds[nfd++] = commandPipe[0];
int fd = wait_for_input(nfd, fds);
mutex.lock();
if (! throttleActive)
copyout();
if (fd == commandPipe[0])
{
char c = (char)NoCmd;
if (::read(commandPipe[0], &c, 1) > 0)
switch( (enum Command)c )
{
case HandlerCmd:
sethandler();
break;
case DrainCmd:
msleep(10);
copyout(throttleActive = false);
drain.wakeAll();
break;
case BreakCmd:
if (lua && breakStopsLua)
lua->stop();
emit q->ttyBreak();
break;
case ReadlineCmd:
readline();
break;
case KillCmd:
killConsole = true;
default:
break;
}
}
pulse.wakeAll();
mutex.unlock();
}
// reset signals
set_sigint_handler(SIG_DFL);
}
int main()
{
init_array();
init_matrix();
init_rc_arr();
iniz(w, b);
wait_for_input();
}
static int FILE_recv_ascii(FILE *in, FILE *out)
{
char *buf = (char *)xmalloc(FTP_BUFSIZ);
int c;
time_t then = time(0) - 1;
time_t now;
ftp_set_close_handler();
if(foo_hookf)
foo_hookf(&ftp->ti);
ftp->ti.begin = false;
clearerr(in);
clearerr(out);
while((c = krb_getc(in)) != EOF) {
if(ftp_sigints() > 0)
break;
if(wait_for_input() != 0)
break;
if(c == '\n')
ftp->ti.barelfs++;
else if(c == '\r') {
c = krb_getc(in);
if(c == EOF)
break;
if(c != '\n') {
ungetc(c, in);
c = '\r';
}
}
if(fputc(c, out) == EOF)
break;
ftp->ti.size++;
if(foo_hookf) {
now = time(0);
if(now > then) {
foo_hookf(&ftp->ti);
then = now;
}
}
}
free(buf);
return maybe_abort(in, out);
}
MINDY_NORETURN
static void getc_or_wait(struct thread *thread)
{
// if (FBUFEMPTYP(stdin) && !feof(stdin)) {
if (!feof(stdin)) {
int fd = fileno(stdin);
int nfound = input_available(fd);
if (nfound < 0) {
switch (errno) {
case EBADF:
error("Tried to getc with stdin broken.");
case EINTR:
wait_for_input(thread, fd, getc_or_wait);
case EINVAL:
lose("select failed with EINVAL?");
}
}
else if (nfound == 0)
wait_for_input(thread, fd, getc_or_wait);
}
{
obj_t *old_sp;
int c = mindy_getchar();
old_sp = pop_linkage(thread);
if (c != EOF)
*old_sp = int_char(c);
else
*old_sp = obj_False;
thread->sp = old_sp + 1;
do_return(thread, old_sp, old_sp);
}
}
int main(void)
{
void *addr;
size_t map_len = NUM_PAGES * getpagesize();
size_t i;
int rc;
struct rlimit r;
rc = getrlimit(RLIMIT_MEMLOCK, &r);
if (rc < 0) {
perror("getrlimit");
exit(EXIT_FAILURE);
}
printf("memlock limit: %zu (current), %zu (maximum)\n",
r.rlim_cur, r.rlim_max);
printf("map_len: %zu\n", NUM_PAGES * map_len);
wait_for_input("Call mmap()");
addr = mmap(NULL, NUM_PAGES * map_len, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (addr == MAP_FAILED) {
perror("mmap");
exit(EXIT_FAILURE);
}
wait_for_input("Access mapped page");
for (i = 0; i < NUM_PAGES; i++)
memcpy(addr + i*getpagesize(), "anaaremere", 10);
wait_for_input("Call mlock()");
rc = mlock(addr, NUM_PAGES * map_len);
if (rc < 0) {
perror("mlock");
exit(EXIT_FAILURE);
}
wait_for_input("mlock() has been called");
return 0;
}
static int FILE_recv_binary(Socket* in, FILE *out)
{
time_t then = time(0) - 1;
time_t now;
ftp_set_close_handler();
if(foo_hookf)
foo_hookf(&ftp->ti);
ftp->ti.begin = false;
sock_clearerr_in(in);
clearerr(out);
char* buf = xmalloc(FTP_BUFSIZ);
while (!sock_eof(in)) {
if(wait_for_input() != 0) {
ftp_trace("wait_for_input() returned non-zero\n");
break;
}
const ssize_t n = sock_read(in, buf, FTP_BUFSIZ);
if (n <= 0)
break;
if(ftp_sigints() > 0) {
ftp_trace("break due to sigint\n");
break;
}
if(fwrite(buf, sizeof(char), n, out) != n)
break;
ftp->ti.size += n;
if(foo_hookf) {
now = time(0);
if(now > then) {
foo_hookf(&ftp->ti);
then = now;
}
}
}
free(buf);
ftp_set_close_handler();
return maybe_abort_in(in, out);
}
int main() {
mu::Transport transport;
mu::PlayerRt player_rt;
mu::FileReadStream *file_read_stream = new mu::FileReadStream();
mu::CropStream *crop_stream = new mu::CropStream();
mu::LoopStream *loop_stream = new mu::LoopStream();
mu::SequenceStream *sequence_stream = new mu::SequenceStream();
file_read_stream->set_file_name(EXAMPLE_DIRECTORY "thump.wav");
mu::MuTick n_frames = file_read_stream->duration();
crop_stream->set_source(file_read_stream);
crop_stream->set_source_start(0);
crop_stream->set_source_end(n_frames);
mu::MuTick ticks_per_beat = 44100 / 16;
std::cout << "================" << std::endl;
std::cout << crop_stream->inspect() << std::endl << std::endl;
std::cout << "================" << std::endl;
for (int i=0; i<12; i++) {
double relative_frequency = pow(2.0, (i - 12.0)/12.0);
PitchShifter *pitch_shifter = new PitchShifter();
pitch_shifter->set_shift(relative_frequency);
mu::CropStream *c2 = crop_stream->clone();
printf("=== crop_stream_copy = %p, crop_stream_copy->source() = %p\n", c2, c2->source());
pitch_shifter->set_source(c2);
sequence_stream->add_source(pitch_shifter->stream(),
i * ticks_per_beat,
1.0);
}
loop_stream->set_source_start(0);
loop_stream->set_source_end(12 * ticks_per_beat);
loop_stream->set_interval(12 * ticks_per_beat);
loop_stream->set_source(sequence_stream);
std::cout << loop_stream->inspect() << std::endl;
transport.set_source(loop_stream);
transport.set_player(&player_rt);
transport.run();
wait_for_input();
transport.stop();
return 0;
}
int PollGuard::wait_for_input_in_loop(int wait_time, bool forceSend)
{
int ret_val;
m_clnt->do_forceSend(forceSend ? 1 : 0);
NDB_TICKS curr_time = NdbTick_CurrentNanosecond();
/* Use nanosecond wait_time for max_time calculation */
NDB_TICKS max_time = curr_time + ((NDB_TICKS)wait_time * 1000000);
const int maxsleep = (wait_time == -1 || wait_time > 10) ? 10 : wait_time;
do
{
wait_for_input(maxsleep);
NDB_TICKS start_time_nanos = curr_time;
curr_time = NdbTick_CurrentNanosecond();
m_clnt->recordWaitTimeNanos(curr_time - start_time_nanos);
Uint32 state= m_waiter->get_state();
if (state == NO_WAIT)
{
return 0;
}
else if (state == WAIT_NODE_FAILURE)
{
ret_val= -2;
break;
}
if (wait_time == -1)
{
#ifdef NOT_USED
ndbout << "Waited WAITFOR_RESPONSE_TIMEOUT, continuing wait" << endl;
#endif
continue;
}
if (curr_time >= max_time)
{
#ifdef VM_TRACE
ndbout << "Time-out state is " << m_waiter->get_state() << endl;
#endif
m_waiter->set_state(WST_WAIT_TIMEOUT);
ret_val= -1;
break;
}
} while (1);
#ifdef VM_TRACE
ndbout << "ERR: receiveResponse - theImpl->theWaiter.m_state = ";
ndbout << m_waiter->get_state() << endl;
#endif
m_waiter->set_state(NO_WAIT);
return ret_val;
}
int ctr_request_update(void)
{
gfxInit(GSP_BGR8_OES,GSP_RGB565_OES,false);
gfxSet3D(false);
consoleInit(GFX_BOTTOM, NULL);
printf("\n\nunsupported version\n\n");
printf("Please update your playload\n");
wait_for_input();
gfxExit();
return 0;
}
int core::run() {
// writes the config and process id to file
write_state();
quit_mainloop=0;
while (!quit_mainloop && term_signal==0 && quit_signal==0) {
// wait for a job to run...
job * this_job=NULL;
result* this_result=NULL;
try {
this_job=wait_for_input();
}
catch (job_exception je) {
this_result=new error_result(job_counter,je);
}
if (quit_mainloop!=0 || term_signal!=0) {
if (this_job!=NULL) delete this_job;
break;
}
// do the work ...
if (this_job!=NULL) {
this_result=do_the_job(*this_job);
if (term_signal!=0) {
delete this_job;
if (this_result!=NULL) delete this_result;
break;
}
}
else
this_job=new job(job_counter);
if (this_result==NULL) {
this_result=new error_result(job_counter,"unexpected: did not get any result");
}
// tell them...
write_to_output(*this_job,*this_result);
delete this_result;
delete this_job;
job_counter++;
}
// deletes config file
remove_state();
return 0;
}
void factoroids_level_message(int wave)
{
SDL_Rect rect;
SDL_Surface *bgsurf=NULL;
int nwave;
char objs_str[PRIME_MAX_LIMIT][MAX_CHAR_MSG] =
{
N_("Powers of 2"),
N_("Products of 2 and 3"),
N_("Products of 2, 3 and 5"),
N_("Products of 2, 3, 5 and 7"),
N_("Products of 2, 3, 5, 7, and 11"),
N_("Products of 2, 3, 5, 7, 11 and 13")
};
char hints_str[PRIME_MAX_LIMIT][MAX_CHAR_MSG] =
{
N_("All multiples of 2 end in 2, 4, 6, 8, or 0"),
N_("The digits of a multiple of 3 add up to a multiple of 3"),
N_("All multiples of 5 end in 0 or 5"),
N_("Sorry - there is no simple rule to identify multiples of 7."),
N_("Under 100, multiples of 11 have equal digits, such as 55 or 88."),
N_("Sorry - there is no simple rule to identify multiples of 13."),
};
rect.x = (screen->w/2)-(LVL_WIDTH_MSG/2);
rect.y = (screen->h/2)-(LVL_HEIGHT_MSG/2);
bgsurf = T4K_CreateButton(LVL_WIDTH_MSG,LVL_HEIGHT_MSG,12,19,19,96,96);
if(bgsurf)
{
SDL_BlitSurface(bgsurf, NULL, screen, &rect );
SDL_FreeSurface(bgsurf);
}
nwave = (wave > PRIME_MAX_LIMIT) ? PRIME_MAX_LIMIT : wave;
factoroids_level_objs_hints(_("Objectives:"), _(objs_str[nwave-1]), rect.x+LVL_OBJ_X_OFFSET, rect.y+LVL_OBJ_Y_OFFSET);
factoroids_level_objs_hints(_("Hints:"), _(hints_str[nwave-1]), rect.x+LVL_HINT_X_OFFSET, rect.y+LVL_HINT_Y_OFFSET);
SDL_Flip(screen);
wait_for_input();
}
int main(void)
{
int fd1, fd2, rc;
wait_for_input("beginning");
/* opening files */
fd1 = open("tmp1.txt", O_CREAT | O_RDWR, 0644);
DIE(fd1 < 0, "open tmp1.txt");
wait_for_input("created tmp1.txt");
fd2 = open("Makefile", O_RDONLY);
DIE(fd2 < 0, "open Makefile");
wait_for_input("opened Makefile");
/* redirect sterr to fd1 */
rc = close(STDERR_FILENO);
DIE(rc < 0, "close stderr");
wait_for_input("closed stderr");
rc = dup(fd1);
DIE(rc < 0, "dup fd1");
wait_for_input("dup - redirected stderr to fd1");
rc = close(fd1);
DIE(rc < 0, "close fd1");
wait_for_input("closed fd1");
/* redirect stderr to fd2 */
rc = dup2(fd2, STDERR_FILENO);
DIE(rc < 0, "dup2 fd2");
wait_for_input("dup2 - redirected stderr to fd2");
rc = close(fd2);
DIE(rc < 0, "close fd2");
wait_for_input("closed fd2");
return 0;
}
static void frontend_ctr_deinit(void *data)
{
extern PrintConsole* currentConsole;
Handle lcd_handle;
u8 not_2DS;
(void)data;
#ifndef IS_SALAMANDER
global_t *global = global_get_ptr();
global->verbosity = true;
#ifdef HAVE_FILE_LOGGER
if (global->log_file)
fclose(global->log_file);
global->log_file = NULL;
#endif
if(gfxBottomFramebuffers[0] == (u8*)currentConsole->frameBuffer)
wait_for_input();
CFGU_GetModelNintendo2DS(¬_2DS);
if(not_2DS && srvGetServiceHandle(&lcd_handle, "gsp::Lcd") >= 0)
{
u32 *cmdbuf = getThreadCommandBuffer();
cmdbuf[0] = 0x00110040;
cmdbuf[1] = 2;
svcSendSyncRequest(lcd_handle);
svcCloseHandle(lcd_handle);
}
exitCfgu();
csndExit();
gfxExit();
#if 0
sdmcExit();
fsExit();
hidExit();
aptExit();
srvExit();
#endif
#endif
}
void
QLuaConsole::Private::copyout(bool throttle)
{
// --- This runs from the console thread,
// mutex is locked.
char buffer[1024];
int fd = stdoutPipe[0];
while (!throttleActive && wait_for_input(1, &fd, false) >= 0)
{
int sz = ::read(fd, buffer, sizeof(buffer));
if (sz < 0)
return;
QByteArray ba(buffer, sz);
emit sigConsoleOutput(ba);
if (++throttleCount > 16)
throttleActive = throttle;
if (printCapturedOutput)
fwrite(buffer, 1, sz, trueStdout);
}
}
int main() {
mu::Transport transport;
mu::PlayerRt player_rt;
mu::FileReadStream *file_read_stream = new mu::FileReadStream();
mu::LoopStream *loop_stream = new mu::LoopStream();
file_read_stream->set_file_name(EXAMPLE_DIRECTORY "purple.wav");
mu::MuTick n_frames = file_read_stream->duration();
loop_stream->set_source_start(0);
loop_stream->set_source_end(n_frames);
loop_stream->set_interval(n_frames);
loop_stream->set_source(file_read_stream);
transport.set_source(loop_stream);
transport.set_player(&player_rt);
transport.run();
wait_for_input();
transport.stop();
return 0;
}
int main() {
mu::Transport transport;
mu::PlayerRt player_rt;
mu::LoopStream *loop_stream = new mu::LoopStream();
Boop boop;
boop.add_boop(beat_to_tick(0), beat_to_tick(1), mu::MuUtils::midi_pitch_to_frequency(69));
boop.add_boop(beat_to_tick(4), beat_to_tick(1.75), mu::MuUtils::midi_pitch_to_frequency(69+4));
boop.add_boop(beat_to_tick(8), beat_to_tick(2.5), mu::MuUtils::midi_pitch_to_frequency(69+7));
boop.add_boop(beat_to_tick(12), beat_to_tick(3.25), mu::MuUtils::midi_pitch_to_frequency(69+12));
loop_stream->set_source(boop.sink());
loop_stream->set_interval(beat_to_tick(12));
loop_stream->set_source_end(beat_to_tick(16));
transport.set_source(loop_stream);
transport.set_player(&player_rt);
transport.run();
wait_for_input();
transport.stop();
return 0;
}
/**
* @brief Main function logic
*
* Parse command line options and start running threads
*/
int
main(int argc, char* argv[])
{
int opt, idx, limit, only_calls, no_incomplete, i;
const char *device, *outfile;
char bpf[512];
const char *keyfile;
const char *match_expr;
int match_insensitive = 0, match_invert = 0;
int no_interface = 0, quiet = 0, rtp_capture = 0;
vector_t *infiles = vector_create(0, 1);
// Program otptions
static struct option long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "version", no_argument, 0, 'V' },
{ "device", required_argument, 0, 'd' },
{ "input", required_argument, 0, 'I' },
{ "output", required_argument, 0, 'O' },
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
{ "keyfile", required_argument, 0, 'k' },
#endif
{ "calls", no_argument, 0, 'c' },
{ "rtp", no_argument, 0, 'r' },
{ "limit", no_argument, 0, 'l' },
{ "icase", no_argument, 0, 'i' },
{ "invert", no_argument, 0, 'v' },
{ "no-interface", no_argument, 0, 'N' },
{ "dump-config", no_argument, 0, 'D' },
#ifdef USE_EEP
{ "eep-listen", required_argument, 0, 'L' },
{ "eep-send", required_argument, 0, 'H' },
#endif
{ "quiet", no_argument, 0, 'q' },
};
// Initialize configuration options
init_options();
// Get initial values for configurable arguments
device = setting_get_value(SETTING_CAPTURE_DEVICE);
outfile = setting_get_value(SETTING_CAPTURE_OUTFILE);
keyfile = setting_get_value(SETTING_CAPTURE_KEYFILE);
limit = setting_get_intvalue(SETTING_CAPTURE_LIMIT);
only_calls = setting_enabled(SETTING_SIP_CALLS);
no_incomplete = setting_enabled(SETTING_SIP_NOINCOMPLETE);
rtp_capture = setting_enabled(SETTING_CAPTURE_RTP);
// Parse command line arguments
opterr = 0;
char *options = "hVd:I:O:pqtW:k:crl:ivNqDL:H:";
while ((opt = getopt_long(argc, argv, options, long_options, &idx)) != -1) {
switch (opt) {
case 'h':
usage();
return 0;
case 'V':
version();
return 0;
case 'd':
device = optarg;
break;
case 'I':
vector_append(infiles, optarg);
break;
case 'O':
outfile = optarg;
break;
case 'l':
if(!(limit = atoi(optarg))) {
fprintf(stderr, "Invalid limit value.\n");
return 0;
}
break;
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
case 'k':
keyfile = optarg;
break;
#endif
case 'c':
only_calls = 1;
setting_set_value(SETTING_SIP_CALLS, SETTING_ON);
break;
case 'r':
rtp_capture = 1;
setting_set_value(SETTING_CAPTURE_RTP, SETTING_ON);
break;
case 'i':
match_insensitive++;
break;
case 'v':
match_invert++;
break;
case 'N':
no_interface = 1;
setting_set_value(SETTING_CAPTURE_STORAGE, "none");
break;
case 'q':
quiet = 1;
break;
case 'D':
key_bindings_dump();
settings_dump();
return 0;
// Dark options for dummy ones
case 'p':
case 't':
case 'W':
break;
#ifdef USE_EEP
case 'L':
capture_eep_set_server_url(optarg);
break;
case 'H':
capture_eep_set_client_url(optarg);
break;
#endif
case '?':
if (strchr(options, optopt)) {
fprintf(stderr, "-%c option requires an argument.\n", optopt);
} else if (isprint(optopt)) {
fprintf(stderr, "Unknown option -%c.\n", optopt);
} else {
fprintf(stderr, "Unknown option character '\\x%x'.\n", optopt);
}
return 1;
default:
break;
}
}
#if defined(WITH_GNUTLS) || defined(WITH_OPENSSL)
// Set capture decrypt key file
capture_set_keyfile(keyfile);
// Check if we have a keyfile and is valid
if (keyfile && !tls_check_keyfile(keyfile)) {
fprintf(stderr, "%s does not contain a valid RSA private key.\n", keyfile);
return 1;
}
#endif
// Check if given argument is a file
if (argc == 2 && (access(argv[1], F_OK) == 0)) {
// Old legacy option to open pcaps without other arguments
printf("%s seems to be a file: You forgot -I flag?\n", argv[1]);
return 0;
}
// Initialize SIP Messages Storage
sip_init(limit, only_calls, no_incomplete);
// Set capture options
capture_init(limit, rtp_capture);
#ifdef USE_EEP
// Initialize EEP if enabled
capture_eep_init();
#endif
// If we have an input file, load it
if (vector_count(infiles)) {
for (i = 0; i < vector_count(infiles); i++) {
// Try to load file
if (capture_offline(vector_item(infiles, i), outfile) != 0)
return 1;
}
} else {
// Check if all capture data is valid
if (capture_online(device, outfile) != 0)
return 1;
}
// Remove Input files vector
vector_destroy(infiles);
// More arguments pending!
if (argv[optind]) {
// Assume first pending argument is match expression
match_expr = argv[optind++];
// Try to build the bpf filter string with the rest
memset(bpf, 0, sizeof(bpf));
for (i = optind; i < argc; i++)
sprintf(bpf + strlen(bpf), "%s ", argv[i]);
// Check if this BPF filter is valid
if (capture_set_bpf_filter(bpf) != 0) {
// BPF Filter invalid, check incluiding match_expr
match_expr = 0; // There is no need to parse all payload at this point
// Build the bpf filter string
memset(bpf, 0, sizeof(bpf));
for (i = optind - 1; i < argc; i++)
sprintf(bpf + strlen(bpf), "%s ", argv[i]);
// Check bpf filter is valid again
if (capture_set_bpf_filter(bpf) != 0) {
fprintf(stderr, "Couldn't install filter %s: %s\n", bpf, capture_last_error());
return 1;
}
}
// Set the capture filter
if (match_expr)
if (sip_set_match_expression(match_expr, match_insensitive, match_invert)) {
fprintf(stderr, "Unable to parse expression %s\n", match_expr);
return 1;
}
}
// Start a capture thread
if (capture_launch_thread() != 0) {
ncurses_deinit();
fprintf(stderr, "Failed to launch capture thread.\n");
return 1;
}
if (!no_interface) {
// Initialize interface
ncurses_init();
// This is a blocking call.
// Create the first panel and wait for user input
ui_create_panel(PANEL_CALL_LIST);
wait_for_input();
} else {
setbuf(stdout, NULL);
while(capture_get_status() != CAPTURE_OFFLINE) {
if (!quiet)
printf("\rDialog count: %d", sip_calls_count());
usleep(500 * 1000);
}
if (!quiet)
printf("\rDialog count: %d\n", sip_calls_count());
}
// Capture deinit
capture_deinit();
// Deinitialize interface
ncurses_deinit();
// Deinitialize configuration options
deinit_options();
// Deallocate sip stored messages
sip_deinit();
// Leaving!
return 0;
}
static void configure(int handle, int argc, char **argv)
{
int i, arg1, arg2;
for (i = 1; i < argc; ++i)
{
int perm = 0x80;
char *cmd = argv[i];
if (strneq(cmd, "temp-", 5))
perm = 0, cmd += 5;
if (streq(cmd, "free"))
{
mx_cmd(handle, perm + 1, 0, 0);
}
else if (streq(cmd, "click"))
{
mx_cmd(handle, perm + 2, 0, 0);
}
else if (strneq(cmd, "manual", 6))
{
twoargs(cmd + 6, &arg1, &arg2, 0, 0, 15);
if (arg1 != arg2)
mx_cmd(handle, perm + 7, arg1 * 16 + arg2, 0);
else
mx_cmd(handle, perm + 8, arg1, 0);
}
else if (strneq(cmd, "auto", 4))
{
twoargs(cmd + 4, &arg1, &arg2, 0, 0, 50);
mx_cmd(handle, perm + 5, arg1, arg2);
}
else if (strneq(argv[i], "soft-free", 9))
{
twoargs(argv[i] + 9, &arg1, &arg2, 0, 0, 255);
mx_cmd(handle, 3, arg1, arg2);
}
else if (strneq(argv[i], "soft-click", 10))
{
twoargs(argv[i] + 10, &arg1, &arg2, 0, 0, 255);
mx_cmd(handle, 4, arg1, arg2);
}
else if (strneq(argv[i], "reconnect", 9))
{
static const int cmd[] = { 0xff, 0x80, 0xb2, 1, 0, 0 };
twoargs(argv[i] + 9, &arg1, &arg2, 0, 0, 255);
send_report(handle, 0x10, cmd, 6);
printf("Reconnection initiated\n");
printf(" - Turn off the mouse\n");
printf(" - Press and hold the left mouse button\n");
printf(" - Turn on the mouse\n");
printf(" - Press the right button 5 times\n");
printf(" - Release the left mouse button\n");
wait_report(handle, 60000);
}
else if (strneq(argv[i], "mode", 4))
{
int buf[6];
if (mx_query(handle, 0x08, buf))
{
if (buf[5] & 1)
printf("click-by-click\n");
else
printf("free spinning\n");
}
}
else if (strneq(argv[i], "battery", 7))
{
int buf[6];
if (mx_query(handle, 0x0d, buf))
{
char str[32], *st;
switch (buf[5])
{
case 0x30: st = "running on battery"; break;
case 0x50: st = "charging"; break;
case 0x90: st = "fully charged"; break;
default: sprintf(st = str, "status %02x", buf[5]);
}
printf("battery level %d%%, %s\n", buf[3], st);
}
}
/*** debug commands ***/
else if (strneq(argv[i], "raw", 3))
{
int buf[256], n;
n = nargs(argv[i] + 3, buf, 256, 0, 0, 255);
send_report(handle, buf[0], buf+1, n-1);
}
else if (strneq(argv[i], "query", 5))
{
int buf[256], j;
twoargs(argv[i] + 5, &arg1, &arg2, -1, 0, 255);
if (arg1 == -1)
arg1 = 0x10, arg2 = 6;
query_report(handle, arg1, buf, arg2);
printf("report %02x:", arg1);
for (j = 0; j < arg2; ++j)
printf(" %02x", buf[j]);
printf("\n");
}
else if (strneq(argv[i], "dump", 4))
{
twoargs(cmd + 4, &arg1, &arg2, 3, -1, 24*60*60);
if (arg1 > 0)
arg1 *= 1000;
while (wait_for_input(handle, arg1) > 0)
{
struct hiddev_usage_ref uref;
if (read(handle, &uref, sizeof(uref)) == sizeof(uref))
printf("read: type=%u, id=%u, field=%08x, usage=%08x,"
" code=%08x, value=%u\n",
uref.report_type, uref.report_id, uref.field_index,
uref.usage_index, uref.usage_code, uref.value);
}
}
else if (strneq(argv[i], "sleep", 5))
{
twoargs(argv[i] + 5, &arg1, &arg2, 1, 0, 255);
sleep(arg1);
}
else
fatal("unknown option `%s'", argv[i]);
}
}
