void print_dr(struct track_info *info, int count)
{
int i;
const char *artist = collapse(info, count, sizeof(struct track_info), offsetof(struct track_info, artist), "Unknown", "Unknown");
const char *album = collapse(info, count, sizeof(struct track_info), offsetof(struct track_info, album), "Unknown", "Various Artists");
sample dr_sum = 0;
printf("dr_meter " VERSION "\n");
//printf("log date: \n");
printf("\n");
print_bar('-');
printf("Analyzed: %s / %s\n", artist, album);
print_bar('-');
printf("\n");
printf("DR Peak RMS Duration Track\n");
print_bar('-');
for (i = 0; i < count; i++) {
// XXX don't print tracks with errors
struct track_info *t = &info[i];
if (t->err) continue;
printf("DR%-4d %8.2f dB %8.2f dB %6d:%02d %s-%s\n",
(int)round(t->dr), to_db(t->peak), to_db(t->rms),
t->duration/60, t->duration%60,
t->tracknumber, t->title);
dr_sum += t->dr;
}
print_bar('-');
printf("\n");
printf("Number of tracks: %i\n", count);
printf("Official DR value: DR%i\n", (int)round(dr_sum / count));
print_bar('=');
printf("\n");
}
int print_opal_priv_hdr_scn(const struct opal_priv_hdr_scn *privhdr)
{
print_bar();
print_header("Private Header");
print_opal_v6_hdr(privhdr->v6hdr);
print_line("Created at", "%4u-%02u-%02u | %02u:%02u:%02u",
privhdr->create_datetime.year,
privhdr->create_datetime.month,
privhdr->create_datetime.day,
privhdr->create_datetime.hour,
privhdr->create_datetime.minutes,
privhdr->create_datetime.seconds);
print_line("Committed at", "%4u-%02u-%02u | %02u:%02u:%02u",
privhdr->commit_datetime.year,
privhdr->commit_datetime.month,
privhdr->commit_datetime.day,
privhdr->commit_datetime.hour,
privhdr->commit_datetime.minutes,
privhdr->commit_datetime.seconds);
print_line("Created by", "%s", get_creator_name(privhdr->creator_id));
print_line("Creator Sub Id", "0x%x (%u), 0x%x (%u)",
privhdr->creator_subid_hi,
privhdr->creator_subid_hi,
privhdr->creator_subid_lo,
privhdr->creator_subid_lo);
print_line("Platform Log Id", "0x%x", privhdr->plid);
print_line("Entry ID", "0x%x", privhdr->log_entry_id);
print_line("Section Count","%u",privhdr->scn_count);
print_bar();
return 0;
}
/**
* Print a list of audits, with their names, numbers, and current
* counters.
*/
void print_audit_list (const char *title, struct audit *aud)
{
U8 auditno = 1;
audit_t *aptr;
U8 format;
print_string (title);
print_nl ();
print_bar ();
while (far_read_pointer (&aud->name, TEST_PAGE) != NULL)
{
sprintf ("%02d", auditno);
print_string (sprintf_buffer);
printer_moveto (5);
print_from_page (TEST_PAGE);
print_string ((char *)far_read_pointer (&aud->name, TEST_PAGE));
print_from_this_page ();
aptr = far_read_pointer (&aud->nvram, TEST_PAGE);
if (aptr)
{
format = far_read8 (&aud->format, TEST_PAGE);
printer_moveto (30);
render_audit (*aptr, format);
print_string (sprintf_buffer);
}
print_nl ();
aud++;
auditno++;
}
}
t_list *enter_key(t_list *l)
{
t_list *tmp;
tmp = l;
while (tmp->highlighted != 1)
tmp = tmp->nxt;
tmp->selected = (tmp->selected == 1) ? 0 : 1;
tputs(tgetstr("cl", NULL), 1, ft_outc);
print_choices(l);
print_bar(l);
return (l);
}
/*ARGSUSED*/
static int
chewrec(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg)
{
dtrace_eprobedesc_t *epd = data->dtpda_edesc;
dtrace_aggvarid_t aggvars[2];
const void *buf;
int i, nagv;
/*
* A NULL rec indicates that we've processed the last record.
*/
if (rec == NULL)
return (DTRACE_CONSUME_NEXT);
buf = data->dtpda_data - rec->dtrd_offset;
switch (rec->dtrd_action) {
case DTRACEACT_DIFEXPR:
(void) printf("\n%s\n\n", (char *)buf + rec->dtrd_offset);
if (!g_opt_s) {
print_legend();
print_bar();
}
return (DTRACE_CONSUME_NEXT);
case DTRACEACT_PRINTA:
for (nagv = 0, i = 0; i < epd->dtepd_nrecs - 1; i++) {
const dtrace_recdesc_t *nrec = &rec[i];
if (nrec->dtrd_uarg != rec->dtrd_uarg)
break;
/*LINTED - alignment*/
aggvars[nagv++] = *(dtrace_aggvarid_t *)((caddr_t)buf +
nrec->dtrd_offset);
}
if (nagv == (g_opt_s ? 1 : 2)) {
uint_t nent = 0;
if (dtrace_aggregate_walk_joined(g_dtp, aggvars, nagv,
process_aggregate, &nent) != 0)
dfatal("failed to walk aggregate");
}
return (DTRACE_CONSUME_NEXT);
}
return (DTRACE_CONSUME_THIS);
}
void vga_setup( PCONFIGURATION_COMPONENT_DATA pcibus,
struct _pci_desc *desc, struct _vga_desc *vga_desc,
int bus, int dev, int fn ) {
struct _pci_bar bar_data;
int i;
for( i = 0; i < 6; i++ ) {
pci_read_bar( desc, bus, dev, fn, i, &bar_data );
print_bar( &bar_data );
if( (bar_data.data > 0x10000) || ((bar_data.data&1) == 1) ) {
vga_desc->addr = (char *)(0xc0000000 + (bar_data.data & ~0x7ff));
// BootInfo.dispDeviceBase = vga_desc->addr;
break;
}
}
}
int main(void)
{
int character,state,length,i;
int wordsize[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
state=OUT;
length=0;
while((character = getchar()) != EOF)
{
if(state==OUT)
{
if(character != ' ' && character != '\t' && character != '\n')
{
state=IN;
length++;
}
}
else if(state==IN)
{
if( character == ' ' || character == '\t' || character == '\n')
{
wordsize[length-1]++;
state=OUT;
length=0;
}
else
{
length++;
}
}
}
for(i=0; i<20; i++)
{
printf("%d: ", i+1);
if(i+1<10)
{
printf(" ");
}
print_bar(wordsize[i]);
printf("\n");
}
return 0;
}
t_bunny_response refresh_my_game(void *data)
{
t_lapin *lapin;
lapin = data;
bunny_set_key_response(&key);
bunny_set_click_response(&mouse);
mouse_position(lapin);
blit_to_window(lapin->window_1, lapin->pixelarray_1);
size_bar(lapin->window_1, lapin->font, 50, 0);
print_bar(lapin);
if (lapin->save == 1)
{
save_bitmap(lapin->str, lapin->pixelarray_2);
return (EXIT_SUCCESS);
}
else if (lapin->save == 2)
{
save_file_ftn(lapin->pixelarray_2, lapin->str);
return (EXIT_SUCCESS);
}
return (GO_ON);
}
void test_joystick(int joy_idx)
{
SDL_Joystick* joy = SDL_JoystickOpen(joy_idx);
if (!joy)
{
fprintf(stderr, "Unable to open joystick %d\n", joy_idx);
}
else
{
initscr();
//cbreak();
//noecho();
//nonl();
curs_set(0);
int num_axes = SDL_JoystickNumAxes(joy);
int num_buttons = SDL_JoystickNumButtons(joy);
int num_hats = SDL_JoystickNumHats(joy);
int num_balls = SDL_JoystickNumBalls(joy);
Sint16* axes = calloc(num_axes, sizeof(Sint16));
Uint8* buttons = calloc(num_buttons, sizeof(Uint8));
Uint8* hats = calloc(num_hats, sizeof(Uint8));
Uint8* balls = calloc(num_balls, 2*sizeof(Sint16));
int quit = 0;
SDL_Event event;
while(!quit)
{
SDL_Delay(10);
bool something_new = false;
while (SDL_PollEvent(&event)) {
something_new = true;
switch(event.type)
{
case SDL_JOYAXISMOTION:
assert(event.jaxis.axis < num_axes);
axes[event.jaxis.axis] = event.jaxis.value;
break;
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
assert(event.jbutton.button < num_buttons);
buttons[event.jbutton.button] = event.jbutton.state;
break;
case SDL_JOYHATMOTION:
assert(event.jhat.hat < num_hats);
hats[event.jhat.hat] = event.jhat.value;
break;
case SDL_JOYBALLMOTION:
assert(event.jball.ball < num_balls);
balls[2*event.jball.ball + 0] = event.jball.xrel;
balls[2*event.jball.ball + 1] = event.jball.yrel;
break;
case SDL_QUIT:
quit = 1;
printf("Recieved interrupt, exiting\n");
break;
default:
fprintf(stderr, "Error: Unhandled event type: %d\n", event.type);
}
}
if (something_new)
{
//clear();
move(0,0);
printw("Joystick Name: '%s'\n", SDL_JoystickName(joy));
printw("Joystick Number: %d\n", joy_idx);
printw("\n");
printw("Axes %2d:\n", num_axes);
for(int i = 0; i < num_axes; ++i)
{
int len = COLS - 20;
printw(" %2d: %6d ", i, axes[i]);
print_bar((axes[i] + 32767) * (len-1) / 65534, len);
addch('\n');
}
printw("\n");
printw("Buttons %2d:\n", num_buttons);
for(int i = 0; i < num_buttons; ++i)
{
printw(" %2d: %d %s\n", i, buttons[i], buttons[i] ? "[#]":"[ ]");
}
printw("\n");
printw("Hats %2d:\n", num_hats);
for(int i = 0; i < num_hats; ++i)
{
printw(" %2d: value: %d\n", i, hats[i]);
printw(" +-----+ up: %c\n"
" |%c %c %c| down: %c\n"
" |%c %c %c| left: %c\n"
" |%c %c %c| right: %c\n"
" +-----+\n",
(hats[i] & SDL_HAT_UP)?'1':'0',
((hats[i] & SDL_HAT_UP) && (hats[i] & SDL_HAT_LEFT)) ? 'O' : ' ',
((hats[i] & SDL_HAT_UP) && !(hats[i] & (SDL_HAT_LEFT | SDL_HAT_RIGHT))) ? 'O' : ' ',
((hats[i] & SDL_HAT_UP) && (hats[i] & SDL_HAT_RIGHT)) ? 'O' : ' ',
(hats[i] & SDL_HAT_DOWN)?'1':'0',
(!(hats[i] & (SDL_HAT_UP | SDL_HAT_DOWN)) && (hats[i] & SDL_HAT_LEFT)) ? 'O' : ' ',
(!(hats[i] & (SDL_HAT_UP | SDL_HAT_DOWN)) && !(hats[i] & (SDL_HAT_LEFT | SDL_HAT_RIGHT))) ? 'O' : ' ',
(!(hats[i] & (SDL_HAT_UP | SDL_HAT_DOWN)) && (hats[i] & SDL_HAT_RIGHT)) ? 'O' : ' ',
(hats[i] & SDL_HAT_LEFT)?'1':'0',
((hats[i] & SDL_HAT_DOWN) && (hats[i] & SDL_HAT_LEFT)) ? 'O' : ' ',
((hats[i] & SDL_HAT_DOWN) && !(hats[i] & (SDL_HAT_LEFT | SDL_HAT_RIGHT))) ? 'O' : ' ',
((hats[i] & SDL_HAT_DOWN) && (hats[i] & SDL_HAT_RIGHT)) ? 'O' : ' ',
(hats[i] & SDL_HAT_RIGHT)?'1':'0');
}
printw("\n");
printw("Balls %2d: ", num_balls);
for(int i = 0; i < num_balls; ++i)
{
printw(" %2d: %6d %6d\n", i, balls[2*i+0], balls[2*i+0]);
}
printw("\n");
printw("\n");
printw("Press Ctrl-c to exit\n");
refresh();
}
} // while
free(balls);
free(hats);
free(buttons);
free(axes);
endwin();
}
}
/*ARGSUSED*/
static int
process_aggregate(const dtrace_aggdata_t **aggsdata, int naggvars, void *arg)
{
const dtrace_recdesc_t *rec;
uintptr_t lock;
uint64_t *stack;
caddr_t data;
pid_t pid;
struct ps_prochandle *P;
char buf[256];
int i, j;
uint64_t sum, count, avg;
if ((*(uint_t *)arg)++ >= g_nent)
return (DTRACE_AGGWALK_NEXT);
rec = aggsdata[0]->dtada_desc->dtagd_rec;
data = aggsdata[0]->dtada_data;
/*LINTED - alignment*/
lock = (uintptr_t)*(uint64_t *)(data + rec[1].dtrd_offset);
/*LINTED - alignment*/
stack = (uint64_t *)(data + rec[2].dtrd_offset);
if (!g_opt_s) {
/*LINTED - alignment*/
sum = *(uint64_t *)(aggsdata[1]->dtada_data +
aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
/*LINTED - alignment*/
count = *(uint64_t *)(aggsdata[2]->dtada_data +
aggsdata[2]->dtada_desc->dtagd_rec[3].dtrd_offset);
} else {
uint64_t *a;
/*LINTED - alignment*/
a = (uint64_t *)(aggsdata[1]->dtada_data +
aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
print_bar();
print_legend();
for (count = sum = 0, i = DTRACE_QUANTIZE_ZEROBUCKET, j = 0;
i < DTRACE_QUANTIZE_NBUCKETS; i++, j++) {
count += a[i];
sum += a[i] << (j - 64);
}
}
avg = sum / count;
(void) printf("%5llu %8llu ", (u_longlong_t)count, (u_longlong_t)avg);
pid = stack[0];
P = dtrace_proc_grab(g_dtp, pid, PGRAB_RDONLY);
(void) getsym(P, lock, buf, sizeof (buf), 0);
(void) printf("%-28s ", buf);
for (i = 2; i <= 5; i++) {
if (getsym(P, stack[i], buf, sizeof (buf), 1) == 0)
break;
}
(void) printf("%s\n", buf);
if (g_opt_s) {
int stack_done = 0;
int quant_done = 0;
int first_bin, last_bin;
uint64_t bin_size, *a;
/*LINTED - alignment*/
a = (uint64_t *)(aggsdata[1]->dtada_data +
aggsdata[1]->dtada_desc->dtagd_rec[3].dtrd_offset);
print_histogram_header();
for (first_bin = DTRACE_QUANTIZE_ZEROBUCKET;
a[first_bin] == 0; first_bin++)
continue;
for (last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 63;
a[last_bin] == 0; last_bin--)
continue;
for (i = 0; !stack_done || !quant_done; i++) {
if (!stack_done) {
(void) getsym(P, stack[i + 2], buf,
sizeof (buf), 0);
} else {
buf[0] = '\0';
}
if (!quant_done) {
bin_size = a[first_bin];
(void) printf("%10llu |%-24.*s| %5llu %s\n",
1ULL <<
(first_bin - DTRACE_QUANTIZE_ZEROBUCKET),
(int)(24.0 * bin_size / count),
"@@@@@@@@@@@@@@@@@@@@@@@@@@",
(u_longlong_t)bin_size, buf);
} else {
(void) printf("%43s %s\n", "", buf);
}
if (i + 1 >= g_nframes || stack[i + 3] == 0)
stack_done = 1;
if (first_bin++ == last_bin)
quant_done = 1;
}
}
dtrace_proc_release(g_dtp, P);
return (DTRACE_AGGWALK_NEXT);
}
int
main(int argc, char** argv)
{
int err = 0;
long total; // Number of clock ticks per second
long num_cpus;
char cpu_field[MAX_CPU_FIELD_LEN + 1];
unsigned int _kern, _user, _nice, _idle;
unsigned int kern, user, nice, idle;
arguments config;
buffer* stat = NULL;
gmbar* bar = NULL;
stat = buffer_new();
if (!stat)
{
return -1;
}
bar = gmbar_new_with_defaults(100, 10, "red", "none");
if (!bar)
{
buffer_free(stat);
return -1;
}
err = gmbar_add_sections(bar, 4, "red", "orange", "yellow", "none");
if (err)
{
buffer_free(stat);
gmbar_free(bar);
return -1;
}
config.cpu_index = -1;
config.common_config.bar = bar;
config.common_config.interval = 15;
config.common_config.prefix = NULL;
config.common_config.suffix = NULL;
err = argp_parse(&argp, argc, argv, 0, NULL, &config);
if (err)
{
buffer_free(stat);
gmbar_free(bar);
return err;
}
/* Clock ticks per second (per CPU) */
total = sysconf(_SC_CLK_TCK);
/* Number of CPUs */
num_cpus = get_num_cpus();
if (num_cpus < 0)
{
buffer_free(stat);
gmbar_free(bar);
return num_cpus;
}
if (config.cpu_index >= 0
&& config.cpu_index <= CHAR_MAX
&& config.cpu_index < num_cpus)
{
snprintf(cpu_field, MAX_CPU_FIELD_LEN, "cpu%i ", config.cpu_index);
}
else
{
snprintf(cpu_field, MAX_CPU_FIELD_LEN, "cpu ");
}
/* Initialize history */
err = get_stat(stat, cpu_field, &_kern, &_user, &_nice, &_idle);
if (err)
{
buffer_free(stat);
gmbar_free(bar);
return err;
}
while (config.common_config.interval)
{
sleep(config.common_config.interval);
err = get_stat(stat, cpu_field, &kern, &user, &nice, &idle);
if (err)
{
buffer_free(stat);
gmbar_free(bar);
return err;
}
/* total is not accurate */
total = (kern - _kern) + (user - _user) + (nice - _nice) + (idle - _idle);
gmbar_set_section_width(bar->sections[0], total, kern - _kern);
gmbar_set_section_width(bar->sections[1], total, user - _user);
gmbar_set_section_width(bar->sections[2], total, nice - _nice);
gmbar_set_section_width(bar->sections[3], total, idle - _idle);
err = print_bar(&config.common_config);
if (err)
{
buffer_free(stat);
gmbar_free(bar);
return err;
}
_kern = kern;
_user = user;
_nice = nice;
_idle = idle;
}
return 0;
}
int
main (int argc, char *argv[])
{
struct stats s, s0;
int print = 0;
FILE *fp = fopen(STATS_FILE, "rb");
if (fp != NULL)
{
fread(&s0, sizeof(struct stats), 1, fp);
fclose(fp);
print = 1;
}
get_times(&s);
get_temp(&s);
get_mail(&s);
get_cputime(&s);
get_power(&s);
get_mem(&s);
get_txrx(&s);
if (print)
{
int i;
double temp = 1e-3*s.temp;
double charge = 100*s.charge_now/s.charge_full;
double tx = (s.tx-s0.tx)/(s.t-s0.t);
double rx = (s.rx-s0.rx)/(s.t-s0.t);
double mem = s.mem*9.5367431640625e-07;
double cpu_pct[MAX_CPUS];
for (i=0; i < s.n_cpus; i++)
{
double idle = s.cpu_idle[i] - s0.cpu_idle[i];
double total = s.cpu_total[i] - s0.cpu_total[i];
cpu_pct[i] = 1-idle/total;
}
fputs(" [", stdout);
begin_color(color_bar);
fputs(th_spc, stdout);
for (i=0; i < s.n_cpus; i++)
{
print_bar(cpu_pct[i]);
fputs(th_spc, stdout);
}
end_color();
fputc(']', stdout);
begin_color (color_div);
fputs(spc, stdout);
fputs(divider, stdout);
end_color();
begin_color_coded (temp, LO_TEMP, HI_TEMP);
num_print (temp, 3, degc);
end_color();
begin_color (color_div);
fputs(spc, stdout);
fputs(divider, stdout);
fputs(spc, stdout);
end_color();
begin_color_coded (mem, LO_MEM, HI_MEM);
num_print (mem, 4, "MB");
end_color();
begin_color (color_div);
fputs(spc, stdout);
fputs(divider, stdout);
fputs(spc, stdout);
end_color();
begin_color (s.ac_connected ? "cyan" : "red");
fputs(s.ac_connected ? acon : acoff, stdout);
fputc(' ', stdout);
end_color();
begin_color_coded (100-charge, LO_CHARGE, HI_CHARGE);
num_print (charge, 3, "%");
end_color();
begin_color (color_div);
fputs(spc, stdout);
fputs(divider, stdout);
end_color();
begin_color_coded (tx, LO_RATE, HI_RATE);
num_print (tx, 0, "B/s ");
end_color();
begin_color (color_up);
fputs(up, stdout);
end_color();
begin_color_coded (rx, LO_RATE, HI_RATE);
fputs(spc, stdout);
num_print (rx, 0, "B/s ");
end_color();
begin_color (color_down);
fputs(down, stdout);
end_color();
fputs(spc, stdout);
begin_color (color_div);
fputs(divider, stdout);
fputs(spc, stdout);
end_color();
if (s.gmail)
{
begin_color (color_mail);
printf ("%2d/g", s.gmail);
end_color();
}
if (s.uiucmail)
{
begin_color (color_mail);
printf ("%2d/u", s.uiucmail);
end_color();
}
if (s.uiucmail || s.gmail)
{
fputs(spc, stdout);
begin_color (color_div);
fputs(divider, stdout);
fputs(spc, stdout);
end_color();
}
begin_color (color_date);
fputs(s.date, stdout);
end_color();
fputs(spc, stdout);
begin_color (color_div);
fputs(divider, stdout);
end_color();
}
fp = fopen(STATS_FILE, "wb");
fwrite(&s, sizeof(struct stats), 1, fp);
fclose(fp);
return 0;
}