path: root/gbeat.c

#include <gtk/gtk.h>
#include <glade/glade.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>
#include <ctype.h>

#include "galsa.h"
#include "gfft.h"

#define gladewidget(x) GtkWidget *x = glade_xml_get_widget(xml, #x);
GladeXML *xml;

static GdkPixmap *pxm;
//static GdkImage *img_buffer;
//static GdkPixbuf *pxb;
double ofac_s = 110./64000.; // 1./(perpixel);

static gboolean bother(gpointer param)
{
	gladewidget(img)
	gladewidget(status)
	char buf[256];
	gtk_widget_queue_draw(img);
	snprintf(buf, sizeof(buf), "scaling: %lf", ofac_s);
	gtk_label_set_text(GTK_LABEL(status), buf);
	return FALSE;
}

static double clen(fftw_complex c)
{
	return sqrt(c[0] * c[0] + c[1] * c[1]);
}

static double degs(fftw_complex c, double radbase)
{
	double len = clen(c);
	double a = c[0] / len, b = c[1] / len;
	double alpha = asin(b);
	if (a < 0.)
		alpha = M_PI - alpha;
	alpha -= radbase;
	while (alpha < 0)
		alpha += 2 * M_PI;
	while (alpha >= 2 * M_PI)
		alpha -= 2 * M_PI;
	return alpha * 180 / M_PI;
}

static double hsvcos(double i)
{
	i /= 180;
	while (i < -1)
		i += 2;
	while (i  > 1)
		i -= 2;
	if (i < -0.667 || i > 0.667)
		return 0.0;
	return cos(i * 0.75 * M_PI);
}

static GdkColor complex2color(fftw_complex c, double lscale)
{
	double l = clen(c), d = degs(c, 0.0);
	GdkColor ret;

	l /= lscale;
	if (l > 1.0)
		l = 1.0;
	l *= l;

	ret.red   = 65535 * l * hsvcos(d);
	ret.green = 65535 * l * hsvcos(d + 120);
	ret.blue  = 65535 * l * hsvcos(d + 240);
	return ret;
}

static GdkColor colorinv(GdkColor c)
{
	c.red   = 65535 - c.red;
	c.green = 65535 - c.green;
	c.blue = 65535 - c.blue;
	return c;
}

static gboolean errbox(gpointer data)
{
	struct fe *fe = data;

	gladewidget(mainwnd)
	GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(mainwnd),
		GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
		"capture error:\n%s", fe->errp);
	gtk_dialog_run(GTK_DIALOG(dlg));
	gtk_widget_destroy(dlg);

	free(fe->errp);
	free(fe);
	return FALSE;
}

#define NBANDS		32
#define EVALBANDS	32
#define FPS		60
#define HISTSIZE	FPS * 7

struct bdctx {
	double bandenergy[EVALBANDS][HISTSIZE];
//	double boffs[EVALBANDS];
	double goffs;
};

struct renderargs {
	struct fft_runner *fftr;
	struct bdctx bdctx;
};

size_t bd_nbands, bd_bandlim;
double bd_charge, bd_decay;

static void logscale(fftw_complex *in, size_t isz, fftw_complex *out, size_t osz)
{
	double tlog = 1. / log(isz + 1.0);
	double *divs = calloc(sizeof(double), osz);
	memset(out, 0, osz * sizeof(fftw_complex));

	for (size_t i = 0; i < isz; i++) {
		double bpos = log(i + 1.0) * tlog;
		double tpos = log(i + 2.0) * tlog;
		double len = tpos - bpos;

		double xdiv = 0.25 * log(i + 2.) / log(isz + 2.);

		for (size_t o = 0; o < osz; o++) {
			double dpos = o / (double) osz;
			if (dpos < bpos || dpos > tpos)
				continue;
			double factor = 0.5 * (1. - cos ((dpos - bpos) / len));
			out[o][0] += in[i][0] * factor * xdiv;
			out[o][1] += in[i][1] * factor * xdiv;
			divs[o] += factor;
		}
	}
	for (size_t o = 0; o < osz; o++) {
		double d = divs[o];
		out[o][0] /= d;
		out[o][1] /= d;
	}
}

static bool bd_perform(struct bdctx *ctx, fftw_complex *data, size_t size)
{
	size_t bandsize = size / NBANDS;
	size_t beatbands = 0;

	for (size_t i = 0; i < bd_bandlim; i++) {
		double energy = 0.0, average = 0.0;
		for (size_t j = 0; j < bandsize; j++) {
			energy += sqrt(
				pow(data[i * bandsize + j][0], 2) +
				pow(data[i * bandsize + j][1], 2));
		}
		energy /= bandsize;

		for (size_t j = 0; j < HISTSIZE; j++)
			average += ctx->bandenergy[i][j];
		average /= HISTSIZE;

		if (energy > average * 1.5 * (1.0 + ctx->goffs))
			beatbands++;

		memmove(&ctx->bandenergy[i][0], &ctx->bandenergy[i][1],
				(HISTSIZE - 1) * sizeof(double));
		ctx->bandenergy[i][HISTSIZE - 1] = energy;
	}

	if (beatbands > bd_nbands)
		ctx->goffs = bd_charge;
	else
		ctx->goffs *= bd_decay;

	return beatbands > bd_nbands;
}

static gpointer renderf(gpointer param)
{
	struct renderargs *arg = param;
	struct fe *fe;

	size_t logsz = 400;
	fftw_complex *pos, *logsc;

	GdkDrawable *drawto = GDK_DRAWABLE(pxm);
	GdkGC *gc = gdk_gc_new(drawto);

	gint w, h, y;
	GdkColor col;

	logsc = fftw_malloc(sizeof(fftw_complex) * logsz);

	gdk_drawable_get_size(drawto, &w, &h);
#if 0
	if (h > (gint)arg->fftr->dev->pktsize)
		h = arg->fftr->dev->pktsize;
#endif
	if (h > (gint)logsz)
		h = logsz;

	while (1) {
		fe = g_async_queue_pop(arg->fftr->queue);

		if (fe->message == FE_STOPPED) {
			free(fe);
			break;
		} else if (fe->message == FE_DEV_ERROR) {
			g_idle_add(errbox, fe);
			continue;
		}

		logscale(fe->data, arg->fftr->dev->pktsize, logsc, logsz);

		// bool beat = bd_perform(&arg->bdctx, fe->data, fe->size);
		bool beat = bd_perform(&arg->bdctx, logsc, logsz);

		if (beat) {
			FILE *f = fopen("/home/equinox/python/.dmxbeat", "w");
			if (f)
				fclose(f);
		}

		gdk_threads_enter();
		gdk_draw_drawable(drawto, gc, drawto, 1, 0, 0, 0, w - 1, h);

		pos = logsc; // fe->data;
		for (y = h - 1; y >= 0; y--) {
			fftw_complex c;
			c[0] = c[1] = sqrt(
				pow(pos[0][0], 2.0) +
				pow(pos[0][1], 2.0));
			pos++;
			col = complex2color(c, 4.0);
			if (beat)
				col = colorinv(col);

			gdk_gc_set_rgb_fg_color(gc, &col);
			gdk_draw_point(drawto, gc, w - 1, y);
		}
		gdk_threads_leave();
		g_idle_add(bother, NULL);

		fftw_free(fe->data);
		free(fe);
	};

	fftw_free(logsc);
	return NULL;
}


struct device *dev;

void on_bdapply(GtkWidget *widget, gpointer user_data)
{
	gladewidget(bdnbands);
	gladewidget(bdbandlim);
	gladewidget(bdcharge);
	gladewidget(bddecay);

	const gchar *nbands = gtk_entry_get_text(GTK_ENTRY(bdnbands));
	const gchar *bandlim = gtk_entry_get_text(GTK_ENTRY(bdbandlim));
	const gchar *charge = gtk_entry_get_text(GTK_ENTRY(bdcharge));
	const gchar *decay = gtk_entry_get_text(GTK_ENTRY(bddecay));

	bd_nbands = strtoul(nbands, NULL, 10);
	bd_bandlim = strtoul(bandlim, NULL, 10);
	if (bd_bandlim > EVALBANDS)
		bd_bandlim = EVALBANDS;
	bd_charge = strtod(charge, NULL);
	bd_decay = strtod(decay, NULL);
}

void on_open_toggled(GtkWidget *widget, gpointer user_data)
{
	//gladewidget(mainwnd)
	gladewidget(bopen)
	gladewidget(brun)
	gboolean state;

	if (!!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(bopen)) == !!(dev != NULL))
		return;

	if (dev) {
		device_close(dev);
		dev = NULL;
	} else do {
		gladewidget(edev)
		gladewidget(erate)
		const gchar *udev = gtk_entry_get_text(GTK_ENTRY(edev));
		const gchar *rate = gtk_entry_get_text(GTK_ENTRY(erate));
		gchar *errptr;
		unsigned long urate;

		urate = strtoul(rate, &errptr, 0);
/*		if (*errptr || !*rate) {
			strcpy(errmsg, "Invalid rate");
			break;
		} */

		dev = device_open(udev, urate, 2, urate / FPS);
	} while (0);

	state = dev != NULL;
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(brun), 0);
	gtk_widget_set_sensitive(brun, state);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bopen), state);

/*	if (*errmsg) {
		GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(mainwnd),
			GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
			"Error: %s", errmsg);
		gtk_dialog_run(GTK_DIALOG(dlg));
		gtk_widget_destroy(dlg);
	} */
}

void on_run_toggled(GtkWidget *widget, gpointer user_data)
{
	gladewidget(brun)
	GError *error = NULL;

	if (!dev)
		return;
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(brun))) {
		struct fft_runner *fftr = fftrun_attach(dev, window_hard, 6);
		struct renderargs *arg = calloc(sizeof(*arg), 1);
		arg->fftr = fftr;
		g_thread_create(renderf, arg, 0, &error);

		device_start(dev);
	} else {
		device_stop(dev);
	}
}

int main(int argc, char **argv)
{
	g_thread_init(NULL);
	gtk_init(&argc, &argv);
	gdk_threads_init();
	xml = glade_xml_new("gbeat.glade", NULL, NULL);
	glade_xml_signal_autoconnect(xml);
	{
		gladewidget(edev)
		gladewidget(erate)
		gladewidget(img)
		gtk_entry_set_text(GTK_ENTRY(edev), "hw:0,0");
		gtk_entry_set_text(GTK_ENTRY(erate), "48000");
		//pxb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, 0, 8, 300, 720);
		//gtk_image_set_from_pixbuf(GTK_IMAGE(img), pxb);
		//img_buffer = gdk_image_new(GDK_IMAGE_FASTEST, gdk_visual_get_system(), 300, 740);
		//gtk_image_set_from_image(GTK_IMAGE(img), img_buffer, NULL);
		pxm = gdk_pixmap_new(NULL, 300, 720, 24);
		gtk_image_set_from_pixmap(GTK_IMAGE(img), pxm, NULL);
	}
	on_bdapply(NULL, NULL);
	gtk_main ();
	return 0;
}