Fex

\documentclass{latex2man}

\begin{Name}{1}{fex}{Jesse McClure}{Frequency Excusion}{FEX --- The frequency excursion calculator}

\Prog{Fex} - The frequency excursion calculator

\end{Name}

\section{Synopsis}

\Prog{fex}
	[\Opt{-l}|\Opt{--long}]
	[\Opt{-v}|\Opt{--version}]
	[\Opt{-v}|\Opt{--version}]
	\Arg{<wave file>}

\Prog{fex-gtk}
	[\Opt{-l}|\Opt{--long}]
	\Arg{<wave file>}
	[\Arg{<wave file>} ...]


\section{Description}

\Prog{Fex} is a bioacoustic analysis tool for calculating the frequency
excursion of an audio recording of bird songs or other sound waves.



\Prog{Fex-gtk} is a wrapper script for fex that facilitates batch
processing of large numbers of wave files.  \Prog{Fex-gtk} can be
provided a list of file names, or can be run with no parameters to
provide a dialog window to select input wave files.  \Prog{Fex} will be
run on each input file, and the results can either be stored to a data
file or displayed in a dialog window upon completion.

\Prog{Fex-gtk} is also the executable target of \File{fex.desktop} to
allow for drag-and-drop operation of \Prog{fex}.  The desktop file can
accept any number of wave files as a drop target.

\section{Options}

\begin{description}
\item[\Opt{-l}|\Opt{--long}]
	Provide three column output specifying the path length, path
	duration, and frequency excursion (calculated as path length over
	duration).  Default is to provide only the frequency excursion value.
\item[\Opt{-h}|\Opt{--help}]
	Print help message and exit.
\item[\Opt{-v}|\Opt{--version}]
	Print version information and exit.
\end{description}

\section{Configuration}
\Prog{Fex} is configured via a runtime configuration file read from one
of
\File{\$XDG\_CONFIG\_HOME/fex/config},
\File{\$HOME/.config/fex/config},
\File{\$HOME/.fexrc}, or

'\" t
.\" Manual page created with latex2man on Wed Oct  1 12:46:47 EDT 2014
.\" NOTE: This file is generated, DO NOT EDIT.
.de Vb
.ft CW
.nf
..
.de Ve
.ft R

.fi
..
.TH "FEX" "1" "01 October 2014" "Frequency Excusion " "Frequency Excusion "
.SH NAME

.PP
Fex
\- The frequency excursion calculator 
.PP
.SH SYNOPSIS

.PP
fex
[\fB\-l\fP|\fB\-\-long\fP]
[\fB\-v\fP|\fB\-\-version\fP]
[\fB\-v\fP|\fB\-\-version\fP]
\fI<wave file>\fP
.PP
fex\-gtk
[\fB\-l\fP|\fB\-\-long\fP]
\fI<wave file>\fP
[\fI<wave file>\fP
\&.\&.\&.] 
.PP
.SH DESCRIPTION

.PP
Fex
is a bioacoustic analysis tool for calculating the frequency 
excursion of an audio recording of bird songs or other sound waves. 



.PP
Fex\-gtk
is a wrapper script for fex that facilitates batch 
processing of large numbers of wave files. Fex\-gtk
can be 
provided a list of file names, or can be run with no parameters to 
provide a dialog window to select input wave files. Fex
will be 
run on each input file, and the results can either be stored to a data 
file or displayed in a dialog window upon completion. 
.PP
Fex\-gtk
is also the executable target of fex.desktop
to 
allow for drag\-and\-drop operation of fex\&.
The desktop file can 
accept any number of wave files as a drop target. 
.PP
.SH OPTIONS

.PP
.TP
\fB\-l\fP|\fB\-\-long\fP
 Provide three column output specifying the path length, path 
duration, and frequency excursion (calculated as path length over 
duration). Default is to provide only the frequency excursion value. 
.TP
\fB\-h\fP|\fB\-\-help\fP
 Print help message and exit. 
.TP
\fB\-v\fP|\fB\-\-version\fP
 Print version information and exit. 
.PP
.SH CONFIGURATION

Fex
is configured via a runtime configuration file read from one 
of 
$XDG_CONFIG_HOME/fex/config,
$HOME/.config/fex/config,

[Desktop Entry]
Name=Fex
Comment=Calculates the frequency excursion of a sound wave
Exec=fex-gtk %F
#Exec=fex-gtk --long %F
Terminal=false
Type=Application
Categories=Science
Icon=/usr/share/pixmaps/fex.png
MimeType=audio/*

#include <unistd.h>
#include <locale.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include <X11/XKBlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/xpm.h>
#include <string.h>
#include <sndfile.h>
#include <fftw3.h>
#include <math.h>
#include <cairo.h>
#include <cairo-xlib.h>
#include <cairo-ft.h>

extern const char *configure(int, const char **);
/* fft.c */
extern FFT *create_fft(Wave *);
extern int free_fft(FFT **);
/* spectro.c */
extern int create_spectro(FFT *, const char *);
extern int free_spectro();
extern int spectro_spec();
extern int spectro_thresh();
extern int spectro_points();
extern int spectro_draw();
/* wave.c */
extern Wave *create_wave(const char *);
extern int free_wave(Wave **);
/* xlib.c */
extern int create_xlib();
extern int free_xlib();
extern cairo_t *xlib_context();

	cairo_scale(ctx, 1.0, -4.0);
	cairo_translate(ctx, 0, -1.0 * spect->fft_h * conf.scale);
	cairo_set_source_surface(ctx,spect->s_points, 0, 0);
	cairo_paint_with_alpha(ctx, 0.8);
	cairo_surface_write_to_png(img,"/tmp/img3.png");
	cairo_destroy(ctx);
	cairo_surface_destroy(img);
	return 0;
}

int spectro_draw() {
	cairo_t *c = xlib_context();
	cairo_set_source_rgba(c,1.0,1.0,1.0,1.0);
	cairo_rectangle(c,0,0,spect->fft_w,spect->fft_h);
	cairo_fill(c);
	set_color(c,RGBA_SPECT);
	cairo_mask_surface(c,spect->m_spec,0,0);
	if (conf.layers) {
		set_color(c,RGBA_THRESH);
		cairo_mask_surface(c,spect->m_thresh,0,0);
		cairo_scale(c,1.0/conf.scale,1.0/conf.scale);
		cairo_set_source_surface(c,spect->s_points,0,0);
		cairo_paint(c);
	}
	cairo_destroy(c);
	return 0;
}

int create_spectro(FFT *fft, const char *fname) {
	spect = (Spectro *) calloc(1, sizeof(Spectro));
	/* names */
	spect->fname = fname;
	char *c = strrchr(spect->fname,'/');

			w->d[nframe] = mix / winfo->channels;
		}
		free(multi);
	}
	if (n != w->samples)
		fprintf(stderr,"Error reading \"%s\"\n\t"
				"\t%d samples read of\n\t%d reported size\n",
				fname, (int) n, w->samples);
	sf_close(wfile);
	return w;
}

int free_wave(Wave **wp) {
	Wave *w = *wp;
	free(w->d);
	free(w);
	return 0;
}

#define MODE_NULL		0x00
#define MODE_ERASE	0x01
#define MODE_CROP		0x02

#define EVENT_MASK	ExposureMask | ButtonPressMask | KeyPressMask | \
							StructureNotifyMask

extern int img_draw();

static void buttonpress(XEvent *);
static void clientmessage(XEvent *);
static void configurenotify(XEvent *);
static void expose(XEvent *);
static void keypress(XEvent *);
static void motionnotify(XEvent *);

static int crop(int, int);
static int erase(int, int);
static int eraser_cursor(int, int);
static int move(double, double);
static int play(float);
static int pt_line(double, double);
static int screenshot();
static int sp_floor(double);
static int threshold(double);
static int zoom(double);

static Display *dpy;
static int scr;
static unsigned int ww, wh, mx, my;
static GC gc;
static Window root, win;
static Pixmap buf; //, ibuf, sbuf;
static Atom WM_DELETE_WINDOW;
//static cairo_t *ictx, *sctx;
static Bool running = True;
static double xsc = 1.0, ysc = 1.0, xoff = 0.0, yoff = 0.0;
static int mode = 0, ew = 31, eh = 64;
static char e_col[2][8];
static void (*handler[LASTEvent])(XEvent *) = {
	[ButtonPress]			= buttonpress,
	[ClientMessage]		= clientmessage,

	XConfigureEvent *e = &ev->xconfigure;
	if (e->window == win) {
		/* The XServer is not storing the new/current values for width +
		 * height.  These must be retrieved directly.
		 * Is this an X11 bug? */
		Window wig;
		int ig;
		unsigned int uig;
		XGetGeometry(dpy, win, &wig, &ig, &ig, &ww, &wh, &uig, &uig);
		//ww = e->width; wh = e->height;
		spectro_draw();
		XSetWindowBackgroundPixmap(dpy, win, buf);
		XClearWindow(dpy,win);
	}
}

	}
	else if (sym == XK_F2) {
		if ( (info->vis = !info->vis) ) XMapRaised(dpy,info->win);
		else XUnmapWindow(dpy,info->win);
		XFlush(dpy);
	}
	else if (sym == XK_e) {
		//mode = MODE_ERASE & (mode ^= MODE_ERASE);
		mode = (mode & MODE_ERASE ? 0 : MODE_ERASE);
		eraser_cursor(0,0);
		info->draw(info);
	}
	else if (sym == XK_c) {
		//mode = MODE_CROP & (mode ^= MODE_CROP);
		mode = (mode & MODE_CROP ? 0 : MODE_CROP);
		if (!(mode & MODE_CROP)) XDefineCursor(dpy, win, None);
		else XDefineCursor(dpy, win, XCreateFontCursor(dpy, 34));
		info->draw(info);
	}
	else if (sym == XK_Escape) {
		mode = MODE_NULL;
		XDefineCursor(dpy, win, None);
		info->draw(info);
	}
	else if (sym == XK_p) play(1.0);
	else if (sym == XK_t) {
		conf.layers = !conf.layers;
		spectro_draw();
		XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	}
	else if (sym == XK_u && mode & (MODE_ERASE)) erase(-1,-1);
	while(XCheckMaskEvent(dpy, KeyPressMask, ev));
}

void motionnotify(XEvent *ev) {
	//static int px, py;
	int x = ev->xmotion.x, y = ev->xmotion.y;
	mx = spect->fft_w * x / (xsc * ww) - 1.0 * xoff + spect->fft_x;
	my = spect->fft_h * (1.0 - y / (ysc * wh)) - 1.0 * yoff + spect->fft_y;
	info->draw(info);
	if (mode == MODE_CROP) {
		XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
		XDrawLine(dpy, win, gc, x, 0, x, wh);

		spectro_draw();
		XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
		info_draw(info);
		if (e.type == ButtonRelease) break;
		while(XCheckMaskEvent(dpy, PointerMotionMask, &e));
	}
	XUngrabPointer(dpy, CurrentTime);
	return 0;
}

int eraser_cursor(int w, int h) {
	XUndefineCursor(dpy, win);
	if ( !(mode & MODE_ERASE) ) return 0;
	if ( (ew+=w) < 3 ) ew = 3;
	if ( (eh+=h) < 3 ) eh = 3;
	if ( ew > ww/4 ) ew = ww / 4;
	if ( eh > wh/2 ) eh = wh / 2;
	int i, stride = ew/ 8 + 1;
	char data[stride * eh];
	char mask[stride * eh];
	XColor bg, fg;
	XAllocNamedColor(dpy,DefaultColormap(dpy,scr),e_col[0],&bg,&bg);
	XAllocNamedColor(dpy,DefaultColormap(dpy,scr),e_col[1],&fg,&fg);
	memset(mask, 0xAA, stride * eh);
	memset(data, 0xAA, stride * eh);
	for (i = 0; i < eh; i+= 2) memset(&mask[stride * i], 0x55, stride);
	Pixmap cd = XCreateBitmapFromData(dpy, win, data, ew, eh);
	Pixmap cm = XCreateBitmapFromData(dpy, win, mask, ew, eh);
	Cursor c = XCreatePixmapCursor(dpy, cd, cm, &fg, &bg, ew/2, eh/2);
	XDefineCursor(dpy, win, c);
	XFreePixmap(dpy, cd);
	XFreePixmap(dpy, cm);
	XFlush(dpy);
	return 0;
}

int move(double x, double y) {
	xoff += x / xsc * spect->fft_w; yoff += y / ysc * spect->fft_h;
	if ( yoff > spect->fft_h * (1.0 - 1.0/ysc) )
		yoff = spect->fft_h * (1.0 - 1.0/ysc);
	if ( yoff < 0) yoff = 0;
	if ( xoff < spect->fft_w * (1.0/xsc - 1.0) )
		xoff = spect->fft_w * (1.0/xsc - 1.0);
	if ( xoff > 0) xoff = 0;
	if (x || y) { /* don't redraw for offset checks */
		spectro_draw();
		XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	}
	return 0;
}

int play(float speed) {
	/* calculate fft coordinates of current view window */
	int tw = spect->fft_w / xsc;
	int th = spect->fft_h / ysc;
	int tx = spect->fft_x - xoff;

		XDrawLine(dpy, win, gc, i, 0, i, wh);
		XDrawLine(dpy, win, gc, i+step, 0, i+step, wh);
		XFlush(dpy);
		usleep(usec);
	}
	XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	XFlush(dpy);
	return 0;
}

int pt_line(double p, double l) {
	conf.col[RGBA_POINTS].w += p;
	conf.col[RGBA_LINES].w += l;
	if (conf.col[RGBA_POINTS].w < 0) conf.col[RGBA_POINTS].w = 0.0;
	if (conf.col[RGBA_LINES].w < 0) conf.col[RGBA_LINES].w = 0.0;
	spectro_points();
	spectro_draw();
	XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	return 0;
}

int screenshot() {
	char fname[256];
	static int n = 0;
	snprintf(fname, 256, "%s-%d.png", spect->name, n++);
	cairo_surface_t *t = cairo_xlib_surface_create(dpy, buf,
			DefaultVisual(dpy,scr), ww, wh);
	cairo_surface_write_to_png(t, fname);
	cairo_surface_destroy(t);
	return 0;
}

int sp_floor(double f) {
	conf.spect_floor += f;
	spectro_spec();
	spectro_draw();
	XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	if (info->vis) info->draw(info);
	return 0;
}

int threshold(double f) {
	conf.thresh += f;
	spectro_thresh();
	spectro_points();
	spectro_draw();
	XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	if (info->vis) info->draw(info);
	return 0;
}

int zoom(double f) {
	double px = xsc, py = ysc;
	xsc += f; ysc += f;
	if (xsc < 1.0) xsc = 1.0;
	if (ysc < 1.0) ysc = 1.0;
	xoff += (spect->fft_w/xsc - spect->fft_w/px) / 2.0;
	yoff += (spect->fft_h/py - spect->fft_h/ysc) / 2.0;
	if (f < 0) move(0,0); /* check offsets for bounds */
	spectro_draw();
	XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
	return 0;
}

int create_xlib() {
	if (!setlocale(LC_CTYPE,"")) die("unable to set locale");
	if (!XSupportsLocale()) die("unsupported locale");
	if (!XSetLocaleModifiers("")) die("unable to set locale modifiers");
	if ( !(dpy=XOpenDisplay(0x0)) ) die("unable to open display");

}

int free_xlib() {
	XUndefineCursor(dpy, win);
	toolwin_destroy();
	XFlush(dpy);
	XCloseDisplay(dpy);
	return 0;
}

cairo_t *xlib_context() {
	cairo_surface_t *t = cairo_xlib_surface_create(dpy, buf,
			DefaultVisual(dpy,scr), ww, wh);
	cairo_t *c = cairo_create(t);
	cairo_surface_destroy(t);

int xlib_event_loop() {
	XMapWindow(dpy, win);
	XMapWindow(dpy, info->win);
	XEvent ev;
	while (running && !XNextEvent(dpy,&ev))
		if (ev.type < LASTEvent && handler[ev.type])
			handler[ev.type](&ev);
	return 0;
}

	Bool vis;
	int (*backing)(ToolWin *);
	int (*draw)(ToolWin *);
	int (*button)(ToolWin *, XButtonEvent *);
};

static int toolwin_backing(ToolWin *);
//static int toolwin_button(ToolWin *, XButtonEvent *);
static int toolwin_create();
static int toolwin_destroy();
static int toolwin_draw(ToolWin *);
static int toolwin_win_create(ToolWin *);
static int toolwin_win_destroy(ToolWin *);

static ToolWin *info; //, *help;

	cairo_show_text(tw->ctx,"Crop");
	/* draw */
	toolwin_draw(tw);
	return 0;
}

static int info_button(ToolWin *tw, XButtonEvent *e) {
	if (e->y < 170 || e->y > 190) return 0;
	if (e->x < 10 || e->x > tw->w - 10) return 0;
	if (e->x < tw->w / 2.0 - 5) { /* erase button */
		if (e->button == 1) {
			//mode = MODE_ERASE & (mode ^= MODE_ERASE);
			mode = (mode & MODE_ERASE ? 0 : MODE_ERASE);
			eraser_cursor(0,0);
			tw->draw(tw);
		}
	}
	else { /* crop button */
		if (e->button == 1) {
			//mode = MODE_CROP & (mode ^= MODE_CROP);
			mode = (mode & MODE_CROP ? 0 : MODE_CROP);
			if (!(mode & MODE_CROP)) XDefineCursor(dpy, win, None);
			else XDefineCursor(dpy, win, XCreateFontCursor(dpy, 34));
			tw->draw(tw);
		}
		else if (e->button == 3) { /* uncrop */
			mode |= MODE_CROP;
			tw->draw(tw);
			spect->fft_x = 0;
			spect->fft_y = spect->fft_lo;
			spect->fft_w = spect->fft->ntime;
			spect->fft_h = spect->fft_hi - spect->fft_lo;
			spectro_spec();
			spectro_thresh();
			spectro_points();
			spectro_draw();
			XCopyArea(dpy, buf, win, gc, 0, 0, ww, wh, 0, 0);
			mode &= ~MODE_CROP;
			tw->draw(tw);
		}
	}
	return 0;
}

int toolwin_backing(ToolWin *tw) {
	cairo_set_source_rgba(tw->ctx,0.6,0.6,0.6,1.0);
	cairo_rectangle(tw->ctx, 0, 0, tw->w,tw->h);
	cairo_fill(tw->ctx);
	return 0;
}

//int toolwin_button(ToolWin *tw, XButtonEvent *e) {
//	XRaiseWindow(dpy, tw->win);

//	return 0;
//}

int toolwin_create() {
	info = (ToolWin *) calloc(1, sizeof(ToolWin));
	//help = (ToolWin *) calloc(1, sizeof(ToolWin));
	info->w = 240; info->h = 200;
	info->name = spect->name;
	info->vis = True;

}

int toolwin_destroy() {
	toolwin_win_destroy(info);
	//toolwin_win_destroy(help);
	free(info);
	//free(help);
	return 0;
}

int toolwin_draw(ToolWin *tw) {
	XClearWindow(dpy,tw->win);
	XFlush(dpy);
	return 0;
}

	return 0;
}

int toolwin_win_destroy(ToolWin *tw) {
	cairo_destroy(tw->ctx);
	XDestroyWindow(dpy, tw->win);
	XFreePixmap(dpy, tw->buf);
	return 0;
}