void Messages::dialog::input()
{
canceled = false;
if( filtering ) {
filter.query( false );
if( filter.confirmed() || filter.canceled() ) {
filtering = false;
}
if( !filter.canceled() ) {
const std::string &new_filter_str = filter.text();
if( new_filter_str != filter_str ) {
filter_str = new_filter_str;
do_filter( filter_str );
}
} else {
filter.text( filter_str );
}
} else {
const std::string &action = ctxt.handle_input();
if( action == "DOWN" && offset + max_lines < folded_filtered.size() ) {
++offset;
} else if( action == "UP" && offset > 0 ) {
--offset;
} else if( action == "PAGE_DOWN" ) {
if( offset + max_lines * 2 <= folded_filtered.size() ) {
offset += max_lines;
} else if( max_lines <= folded_filtered.size() ) {
offset = folded_filtered.size() - max_lines;
} else {
offset = 0;
}
} else if( action == "PAGE_UP" ) {
if( offset >= max_lines ) {
offset -= max_lines;
} else {
offset = 0;
}
} else if( action == "FILTER" ) {
filtering = true;
#if defined(__ANDROID__)
if( get_option<bool>( "ANDROID_AUTO_KEYBOARD" ) ) {
SDL_StartTextInput();
}
#endif
} else if( action == "RESET_FILTER" ) {
filter_str.clear();
filter.text( filter_str );
do_filter( filter_str );
} else if( action == "QUIT" ) {
canceled = true;
}
}
}
static int do_cmd(int argc, char **argv)
{
if (matches(*argv, "qdisc") == 0)
return do_qdisc(argc-1, argv+1);
if (matches(*argv, "class") == 0)
return do_class(argc-1, argv+1);
if (matches(*argv, "filter") == 0)
return do_filter(argc-1, argv+1);
if (matches(*argv, "actions") == 0)
return do_action(argc-1, argv+1);
if (matches(*argv, "monitor") == 0)
return do_tcmonitor(argc-1, argv+1);
if (matches(*argv, "help") == 0) {
usage();
return 0;
}
fprintf(stderr, "Object \"%s\" is unknown, try \"tc help\".\n",
*argv);
return -1;
}
int
output_filter(const unsigned char *id, const unsigned char *prefix,
unsigned short plen, unsigned int ifindex)
{
int res;
res = do_filter(output_filters, id, prefix, plen, NULL, ifindex, 0);
if(res < 0)
res = 0;
return res;
}
int
redistribute_filter(const unsigned char *prefix, unsigned short plen,
unsigned int ifindex, int proto)
{
int res;
res = do_filter(redistribute_filters, NULL, prefix, plen, NULL,
ifindex, proto);
if(res < 0)
res = INFINITY;
return res;
}
int
input_filter(const unsigned char *id,
const unsigned char *prefix, unsigned short plen,
const unsigned char *neigh, unsigned int ifindex)
{
int res;
res = do_filter(input_filters, id, prefix, plen, neigh, ifindex, 0);
if(res < 0)
res = 0;
return res;
}
int process(unsigned nframes, void *v)
{
(void) v;
float seq_sqr[nframes];
float seq_noise[nframes];
float sqr[nframes];
float noise[nframes];
float lfo_f_out[nframes];
float filter_in[nframes];
float *output = (float*) jack_port_get_buffer(port, nframes);
void *josc_buf = jack_port_get_buffer(josc, nframes);
jack_midi_event_t in_event;
jack_nframes_t event_count = jack_midi_get_event_count(josc_buf);
// tag::buf-read[]
if(event_count)
{
for(unsigned i=0; i<event_count; i++)
{
jack_midi_event_get(&in_event, josc_buf, i);
assert(*in_event.buffer == '/');
RtDataImpl d;
ports.dispatch((char*)in_event.buffer+1, d);
}
}
while(uToB.hasNext())
{
RtDataImpl d;
d.matches = 0;
ports.dispatch(uToB.read()+1, d);
if(d.matches == 0)
fprintf(stderr, "Unknown Port '%s'\n", uToB.peak());
}
// end::buf-read
gen_seq(seq_sqr, seq_noise, &seq, nframes);
gen_noise(noise, seq_noise, nframes);
gen_square(sqr, seq_sqr, &osc, nframes);
gen_lfo(lfo_f_out, &lfo, nframes);
do_sum(filter_in, noise, sqr, nframes);
do_filter(output, filter_in, lfo_f_out, &filter, nframes);
return 0;
}
void stack(const std::string section, bool clear = true)
{
if (l2opts.send_delay)
{
char buf[15];
snprintf(buf,sizeof(buf),"delay=%d",l2opts.send_delay);
add_arg(buf);
do_filter("pace");
}
ITER(i,filters)
ADD((*ini[section])["filters"],(*i));
if (l2opts.flags & FLAG_B_TPUARTS_ACKGROUP)
(*ini[section])["ack-group"] = "true";
if (l2opts.flags & FLAG_B_TPUARTS_ACKINDIVIDUAL)
(*ini[section])["ack-individual"] = "true";
if (l2opts.flags & FLAG_B_TPUARTS_DISCH_RESET)
(*ini[section])["reset"] = "true";
if (l2opts.flags & FLAG_B_NO_MONITOR)
(*ini[section])["monitor"] = "false";
ITER(i, more_args)
(*ini[section])[i->first] = i->second;
more_args.clear();
if (tracelevel >= 0 || errorlevel >= 0 || no_timestamps) {
char b1[10],b2[50];
snprintf(b2,sizeof(b2),"debug-%s",section.c_str());
(*ini[section])["debug"] = b2;
if (tracelevel >= 0)
{
snprintf(b1,sizeof(b1),"0x%x",tracelevel);
(*ini[b2])["trace-mask"] = b1;
}
if (errorlevel >= 0)
{
snprintf(b1,sizeof(b1),"0x%x",errorlevel);
(*ini[b2])["error-level"] = b1;
}
if (no_timestamps)
{
(*ini[b2])["timestamps"] = "false";
}
}
if (clear)
reset();
}
/*
* Main. Read the command line and call do_filter().
*/
int main(int argc, char **argv)
{
struct option long_options[] = {
{"verbose", no_argument, 0, 'v'},
{"output", required_argument, 0, 'o'},
{"input", required_argument, 0, 'f'},
{"device", required_argument, 0, 'd'},
{"filter", required_argument, 0, 'F'}
};
while (1) {
switch (getopt_long(argc, argv, "-vo:f:d:F:", long_options, 0)) {
case '?':
case 1:
die(STATUS_COMMANDLINE, "error parsing command line");
break;
case -1:
goto end_options;
break;
case 'v':
opt_verbose = 1;
break;
case 'f':
opt_infile = optarg;
break;
case 'o':
opt_outfile = optarg;
break;
case 'd':
opt_device = optarg;
break;
case 'F':
opt_filter = optarg;
break;
default:
die(STATUS_COMMANDLINE, "error parsing command line");
}
}
end_options:
do_filter();
return STATUS_OK;
}
static void filter_bitmap(JNIEnv* env, jobject obj, jobject bitmap,
float intensity, Filter t)
{
AndroidBitmapInfo info;
int ret = checkInfo(env, bitmap, &info);
if (ret < 0) {
return;
}
void* pixels;
if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
}
do_filter(&info, pixels, intensity, t);
AndroidBitmap_unlockPixels(env, bitmap);
}
int main(int argc, char **argv)
{
char *basename;
basename = strrchr(argv[0], '/');
if (basename == NULL)
basename = argv[0];
else
basename++;
/* batch mode */
if (argc > 1 && matches(argv[1], "-batch") == 0) {
FILE *batch;
char line[400];
char *largv[100];
int largc, ret=0;
#define BMAXARG (sizeof(largv)/sizeof(char *)-2)
if (argc != 3) {
fprintf(stderr, "Wrong number of arguments in batch mode\n");
exit(-1);
}
if (matches(argv[2], "-") != 0) {
if ((batch = fopen(argv[2], "r")) == NULL) {
fprintf(stderr, "Cannot open file \"%s\" for reading: %s=n", argv[2], strerror(errno));
exit(-1);
}
} else {
if ((batch = fdopen(0, "r")) == NULL) {
fprintf(stderr, "Cannot open stdin for reading: %s=n", strerror(errno));
exit(-1);
}
}
tc_core_init();
while (fgets(line, sizeof(line)-1, batch)) {
if (line[strlen(line)-1]=='\n') {
line[strlen(line)-1] = '\0';
} else {
fprintf(stderr, "No newline at the end of line, looks like to long (%d chars or more)\n", strlen(line));
exit(-1);
}
largc = 0;
largv[largc]=strtok(line, " ");
while ((largv[++largc]=strtok(NULL, " ")) != NULL) {
if (largc > BMAXARG) {
fprintf(stderr, "Over %d arguments in batch mode, enough!\n", BMAXARG);
exit(-1);
}
}
if (matches(largv[0], "qdisc") == 0) {
ret += do_qdisc(largc-1, largv+1);
} else if (matches(largv[0], "class") == 0) {
ret += do_class(largc-1, largv+1);
} else if (matches(largv[0], "filter") == 0) {
ret += do_filter(largc-1, largv+1);
} else if (matches(largv[0], "help") == 0) {
usage(); /* note that usage() doesn't return */
} else {
fprintf(stderr, "Object \"%s\" is unknown, try \"tc help\".\n", largv[1]);
exit(-1);
}
}
fclose(batch);
exit(0); /* end of batch, that's all */
}
while (argc > 1) {
if (argv[1][0] != '-')
break;
if (matches(argv[1], "-stats") == 0 ||
matches(argv[1], "-statistics") == 0) {
++show_stats;
} else if (matches(argv[1], "-details") == 0) {
++show_details;
} else if (matches(argv[1], "-raw") == 0) {
++show_raw;
} else if (matches(argv[1], "-Version") == 0) {
printf("tc utility, iproute2-ss%s\n", SNAPSHOT);
exit(0);
} else if (matches(argv[1], "-iec") == 0) {
++use_iec;
} else if (matches(argv[1], "-help") == 0) {
usage();
} else {
fprintf(stderr, "Option \"%s\" is unknown, try \"tc -help\".\n", argv[1]);
exit(-1);
}
argc--; argv++;
}
tc_core_init();
if (argc > 1) {
if (matches(argv[1], "qdisc") == 0)
return do_qdisc(argc-2, argv+2);
if (matches(argv[1], "class") == 0)
return do_class(argc-2, argv+2);
if (matches(argv[1], "filter") == 0)
return do_filter(argc-2, argv+2);
if (matches(argv[1], "help") == 0)
usage();
fprintf(stderr, "Object \"%s\" is unknown, try \"tc help\".\n", argv[1]);
exit(-1);
}
usage();
}
void Filter::filter(const Eigen::MatrixXf &imageEigen) {
do_filter(imageEigen);
}
void Filter::filter(const cv::Mat &imageMat) {
do_filter(imageMat);
}
static bool HandleClient(t_x11 *x11, int ID, t_gmx *gmx)
{
t_pulldown *pd;
pd = gmx->pd;
switch (ID)
{
/* File Menu */
case IDDUMPWIN:
write_gmx(x11, gmx, IDDODUMP);
break;
case IDDODUMP:
if (gmx->man->bAnimate)
{
hide_but(x11, gmx->man->vbox);
}
dump_it(gmx->man);
if (gmx->man->bAnimate)
{
show_but(x11, gmx->man->vbox);
}
break;
case IDCLOSE:
case IDIMPORT:
case IDEXPORT:
ShowDlg(gmx->dlgs[edExport]);
break;
case IDDOEXPORT:
write_sto_conf(gmx->confout, *gmx->man->top.name,
&(gmx->man->top.atoms),
gmx->man->x, NULL, gmx->man->molw->ePBC, gmx->man->box);
break;
case IDQUIT:
show_mb(gmx, emQuit);
break;
case IDTERM:
done_gmx(x11, gmx);
return true;
/* Edit Menu */
case IDEDITTOP:
edit_file("topol.gmx");
break;
case IDEDITCOORDS:
edit_file("confin.gmx");
break;
case IDEDITPARAMS:
edit_file("mdparin.gmx");
break;
/* Display Menu */
case IDFILTER:
if (gmx->filter)
{
ShowDlg(gmx->dlgs[edFilter]);
}
break;
case IDDOFILTER:
do_filter(x11, gmx->man, gmx->filter);
break;
case IDANIMATE:
check_pd_item(pd, IDANIMATE, toggle_animate(x11, gmx->man));
break;
case IDLABELSOFF:
no_labels(x11, gmx->man);
break;
case IDRESETVIEW:
reset_view(gmx->man->view);
ExposeWin(x11->disp, gmx->man->molw->wd.self);
break;
case IDPHOTO:
show_mb(gmx, emNotImplemented);
break;
case IDBONDOPTS:
ShowDlg(gmx->dlgs[edBonds]);
break;
case IDTHIN:
set_bond_type(x11, gmx->man->molw, eBThin);
break;
case IDFAT:
set_bond_type(x11, gmx->man->molw, eBFat);
break;
case IDVERYFAT:
set_bond_type(x11, gmx->man->molw, eBVeryFat);
break;
case IDBALLS:
set_bond_type(x11, gmx->man->molw, eBSpheres);
break;
case IDNOBOX:
set_box_type(x11, gmx->man->molw, esbNone);
break;
case IDRECTBOX:
set_box_type(x11, gmx->man->molw, esbRect);
break;
case IDTRIBOX:
set_box_type(x11, gmx->man->molw, esbTri);
break;
case IDTOBOX:
set_box_type(x11, gmx->man->molw, esbTrunc);
break;
/* Analysis Menu */
case IDBOND:
case IDANGLE:
case IDDIH:
case IDRMS:
case IDRDF:
case IDENERGIES:
case IDCORR:
show_mb(gmx, emNotImplemented);
break;
/* Help Menu */
case IDHELP:
show_mb(gmx, emHelp);
break;
case IDABOUT:
show_logo(x11, gmx->logo);
break;
default:
break;
}
return false;
}
static irqreturn_t atmel_tsadcc_interrupt(int irq, void *dev)
{
struct atmel_tsadcc *ts_dev = (struct atmel_tsadcc *)dev;
struct input_dev *input_dev = ts_dev->input;
struct at91_tsadcc_data *pdata = input_dev->dev.parent->platform_data;
static int count = 0;
unsigned int status;
unsigned int reg;
unsigned int x, y;
unsigned int z1, z2;
unsigned int Rxp = 1;
unsigned int factor = 1000;
#if defined(CONFIG_MACH_AT91SAM9M10G45EK) || defined(CONFIG_MACH_AT91SAM9G45EKES) || defined(CONFIG_MACH_AT91SAM9M10EKES)
static unsigned int point_buffer_x[COUNT_MAX];
static unsigned int point_buffer_y[COUNT_MAX];
#endif
status = atmel_tsadcc_read(ATMEL_TSADCC_SR);
status &= atmel_tsadcc_read(ATMEL_TSADCC_IMR);
if (status & ATMEL_TSADCC_NOCNT) {
/* Contact lost */
if (cpu_has_9x5_adc()) {
/* 9X5 using TSMR to set PENDBC time */
reg = atmel_tsadcc_read(ATMEL_TSADCC_TSMR) | ((pdata->pendet_debounce << 28) & ATMEL_TSADCC_PENDBC);
atmel_tsadcc_write(ATMEL_TSADCC_TSMR, reg);
} else {
reg = atmel_tsadcc_read(ATMEL_TSADCC_MR) | ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_MR, reg);
}
atmel_tsadcc_write(ATMEL_TSADCC_TRGR, ATMEL_TSADCC_TRGMOD_NONE);
atmel_tsadcc_write(ATMEL_TSADCC_IDR,
ATMEL_TSADCC_CONVERSION_END | ATMEL_TSADCC_NOCNT);
atmel_tsadcc_write(ATMEL_TSADCC_IER, ATMEL_TSADCC_PENCNT);
input_report_key(input_dev, BTN_TOUCH, 0);
input_report_abs(input_dev, ABS_PRESSURE, 0);
input_sync(input_dev);
} else if (status & ATMEL_TSADCC_PENCNT) {
/* Pen detected */
if (cpu_has_9x5_adc()) {
reg = atmel_tsadcc_read(ATMEL_TSADCC_TSMR);
reg &= ~ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_TSMR, reg);
} else {
reg = atmel_tsadcc_read(ATMEL_TSADCC_MR);
reg &= ~ATMEL_TSADCC_PENDBC;
atmel_tsadcc_write(ATMEL_TSADCC_MR, reg);
}
atmel_tsadcc_write(ATMEL_TSADCC_IDR, ATMEL_TSADCC_PENCNT);
atmel_tsadcc_write(ATMEL_TSADCC_IER,
ATMEL_TSADCC_CONVERSION_END | ATMEL_TSADCC_NOCNT);
if (cpu_has_9x5_adc()) {
atmel_tsadcc_write(ATMEL_TSADCC_TRGR,
ATMEL_TSADCC_TRGMOD_PERIOD | (0x00D0 << 16));
}else{
atmel_tsadcc_write(ATMEL_TSADCC_TRGR,
ATMEL_TSADCC_TRGMOD_PERIOD | (trigger_period << 16));
}
count = 0;
} else if ((status & ATMEL_TSADCC_CONVERSION_END) == ATMEL_TSADCC_CONVERSION_END) {
/* Conversion finished */
/* make new measurement */
if (cpu_has_9x5_adc()) {
unsigned int xscale, yscale;
/* calculate position */
reg = atmel_tsadcc_read(ATMEL_TSADCC_XPOSR);
ts_dev->prev_absx = (reg & ATMEL_TSADCC_XPOS) << 10;
xscale = (reg & ATMEL_TSADCC_XSCALE) >> 16;
ts_dev->prev_absx /= xscale ? xscale: 1;
reg = atmel_tsadcc_read(ATMEL_TSADCC_YPOSR);
ts_dev->prev_absy = (reg & ATMEL_TSADCC_YPOS) << 10;
yscale = (reg & ATMEL_TSADCC_YSCALE) >> 16;
ts_dev->prev_absy /= yscale ? yscale: 1 << 10;
/* calculate the pressure */
reg = atmel_tsadcc_read(ATMEL_TSADCC_PRESSR);
z1 = reg & ATMEL_TSADCC_PRESSR_Z1;
z2 = (reg & ATMEL_TSADCC_PRESSR_Z2) >> 16;
if (z1 != 0)
ts_dev->prev_absz = Rxp * (ts_dev->prev_absx * factor / 1024) * (z2 * factor / z1 - factor) / factor;
else
ts_dev->prev_absz = 0;
} else {
ts_dev->prev_absx = atmel_tsadcc_read(ATMEL_TSADCC_CDR3) << 10;
ts_dev->prev_absx /= atmel_tsadcc_read(ATMEL_TSADCC_CDR2);
ts_dev->prev_absy = atmel_tsadcc_read(ATMEL_TSADCC_CDR1) << 10;
ts_dev->prev_absy /= atmel_tsadcc_read(ATMEL_TSADCC_CDR0);
}
#if defined(CONFIG_MACH_AT91SAM9M10G45EK) || defined(CONFIG_MACH_AT91SAM9G45EKES) || defined(CONFIG_MACH_AT91SAM9M10EKES)
if (count < COUNT_MAX) {
point_buffer_x[count] = ts_dev->prev_absx;
point_buffer_y[count] = ts_dev->prev_absy;
count++;
} else {
count = 0;
x = do_filter(point_buffer_x, COUNT_MAX, COUNT_MAX * 3 / 4);
y = do_filter(point_buffer_y, COUNT_MAX, COUNT_MAX * 3 / 4);
do_calibrate(&x,&y);
input_report_abs(input_dev, ABS_X, x);
input_report_abs(input_dev, ABS_Y, y);
input_report_key(input_dev, BTN_TOUCH, 1);
input_report_abs(input_dev, ABS_PRESSURE, 7500);
input_sync(input_dev);
}
#endif
#if defined(CONFIG_MACH_AT91SAM9X5EK)
/* report measurement to input layer */
if (ts_dev->prev_absz < ZTHRESHOLD) {
dev_dbg(&input_dev->dev,
"x = %d, y = %d, pressure = %d\n",
ts_dev->prev_absx, ts_dev->prev_absy,
ts_dev->prev_absz);
x = ts_dev->prev_absx;
y = ts_dev->prev_absy;
do_calibrate(&x,&y);
input_report_abs(input_dev, ABS_X, x);
input_report_abs(input_dev, ABS_Y, y);
if (cpu_has_9x5_adc())
input_report_abs(input_dev, ABS_PRESSURE, ts_dev->prev_absz);
input_report_key(input_dev, BTN_TOUCH, 1);
input_sync(input_dev);
} else {
dev_dbg(&input_dev->dev,
"pressure too low: not reporting\n");
}
#endif
}
int main(int argc, char** argv) {
int showhelp = 0;
unsigned int channels = 1;
int window_size = 1024;
int shift = 256;
snd_pcm_format_t format = SND_PCM_FORMAT_UNKNOWN;
int opt;
while ((opt = getopt(argc, argv, "hw:s:f:")) != -1) {
switch (opt) {
case 'h':
showhelp = 1;
break;
case 'w':
window_size = atoi(optarg);
break;
case 's':
shift = atoi(optarg);
break;
case 'f':
format = snd_pcm_format_value(optarg);
break;
default: /* '?' */
showhelp = 1;
break;
}
}
if (showhelp || argc - optind < 2) {
fprintf(stderr, "Usage: %s [-w window_size] [-s shift] "
"[-f format] <inputFile> <outputFile>\n" , argv[0]);
exit(EXIT_SUCCESS);
}
if (format == SND_PCM_FORMAT_UNKNOWN) {
fprintf(stderr, "Unknown format\n");
exit(EXIT_FAILURE);
}
// Load Audio File
FILE* input = fopen(argv[optind], "r");
if (input == NULL) {
fprintf(stderr, "Cannot Open File %s : %s\n", argv[optind],
strerror(errno));
exit(EXIT_FAILURE);
}
double** data;
unsigned long int count = pcm_size(input, channels, format);
count = read_file(input, count, channels, format, &data);
fprintf(stderr, "%lu samples read\n", count);
fclose(input);
// Transform
int nos = number_of_spectrum(count, window_size, shift);
TimeFreq* tf = alloc_tf(window_size, nos);
stft(data[0], count, window_size, shift, tf);
free(data[0]);
// Spectral subtraction
TimeFreq* ntf = alloc_tf(window_size, nos);
do_filter(zerophase, NULL, tf, ntf);
// Inverse transform
count = istft_size(tf);
data[0] = malloc(count * sizeof(double));
istft(ntf, data[0]);
FILE* output = fopen(argv[optind + 1], "w");
if (output == NULL) {
fprintf(stderr, "Cannot Open File %s : %s\n",
argv[optind + 1], strerror(errno));
exit(EXIT_FAILURE);
}
count = write_file(output, count, channels, format, data);
fclose(output);
free_data(data, channels);
free_tf(tf);
free_tf(ntf);
exit(EXIT_SUCCESS);
}
