pcm/scopes/level.c

/*
 *  PCM - Meter level plugin (ncurses)
 *  Copyright (c) 2001 by Abramo Bagnara <abramo@alsa-project.org>
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation; either version 2.1 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <curses.h>
#include <errno.h>
#include <alsa/asoundlib.h>

#define BAR_WIDTH 70
/* milliseconds to go from 32767 to 0 */
#define DECAY_MS 400
/* milliseconds for peak to disappear */
#define PEAK_MS 800

typedef struct _snd_pcm_scope_level_channel {
	int16_t level;
	int16_t peak;
	unsigned int peak_age;
} snd_pcm_scope_level_channel_t;

typedef struct _snd_pcm_scope_level {
	snd_pcm_t *pcm;
	snd_pcm_scope_t *s16;
	snd_pcm_scope_level_channel_t *channels;
	snd_pcm_uframes_t old;
	int top;
	WINDOW *win;
	unsigned int bar_width;
	unsigned int decay_ms;
	unsigned int peak_ms;
} snd_pcm_scope_level_t;

static int level_enable(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	int y, x;
	level->channels = calloc(snd_pcm_meter_get_channels(level->pcm), sizeof(*level->channels));
	if (!level->channels) {
		free(level);
		return -ENOMEM;
	}
	snd_pcm_scope_set_callback_private(scope, level);
	level->win = initscr();
	winsdelln(level->win, snd_pcm_meter_get_channels(level->pcm));
        getyx(level->win, y, x);
	level->top = y;
	return 0;
}

static void level_disable(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	endwin();
	free(level->channels);
}

static void level_close(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	free(level);
}

static void level_start(snd_pcm_scope_t *scope ATTRIBUTE_UNUSED)
{
}

static void level_stop(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	unsigned int c;
	for (c = 0; c < snd_pcm_meter_get_channels(level->pcm); c++) {
		move(level->top + c, 0);
		clrtoeol();
	}
	move(level->top, 0);
	refresh();
}

static void level_update(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	snd_pcm_t *pcm = level->pcm;
	snd_pcm_sframes_t size;
	snd_pcm_uframes_t size1, size2;
	snd_pcm_uframes_t offset, cont;
	unsigned int c, channels;
	unsigned int ms;
	static char bar[256] = { [0 ... 255] = '#' };
	int max_decay;
	size = snd_pcm_meter_get_now(pcm) - level->old;
	if (size < 0)
		size += snd_pcm_meter_get_boundary(pcm);
	offset = level->old % snd_pcm_meter_get_bufsize(pcm);
	cont = snd_pcm_meter_get_bufsize(pcm) - offset;
	size1 = size;
	if (size1 > cont)
		size1 = cont;
	size2 = size - size1;
	ms = size * 1000 / snd_pcm_meter_get_rate(pcm);
	max_decay = 32768 * ms / level->decay_ms;
	channels = snd_pcm_meter_get_channels(pcm);
	for (c = 0; c < channels; c++) {
		int16_t *ptr;
		int s, lev = 0;
		snd_pcm_uframes_t n;
		snd_pcm_scope_level_channel_t *l;
		unsigned int lev_pos, peak_pos;
		l = &level->channels[c];
		ptr = snd_pcm_scope_s16_get_channel_buffer(level->s16, c) + offset;
		for (n = size1; n > 0; n--) {
			s = *ptr;
			if (s < 0)
				s = -s;
			if (s > lev)
				lev = s;
			ptr++;
		}
		ptr = snd_pcm_scope_s16_get_channel_buffer(level->s16, c);
		for (n = size2; n > 0; n--) {
			s = *ptr;
			if (s < 0)
				s = -s;
			if (s > lev)
				lev = s;
			ptr++;
		}
		l->level = lev;
		l->peak_age += ms;
		if (l->peak_age >= level->peak_ms ||
		    lev >= l->peak) {
			l->peak = lev;
			l->peak_age = 0;
		}
		if (lev < l->level - max_decay)
			lev = l->level - max_decay;
		move(level->top + c, 0);
		lev_pos = lev * level->bar_width / 32768;
		peak_pos = l->peak * level->bar_width / 32768;
		addnstr(bar, lev_pos);
		clrtoeol();
		mvaddch(level->top + c, peak_pos - 1, '#');
	}
	move(level->top, 0);
	refresh();
	level->old = snd_pcm_meter_get_now(pcm);
}

static void level_reset(snd_pcm_scope_t *scope)
{
	snd_pcm_scope_level_t *level = snd_pcm_scope_get_callback_private(scope);
	snd_pcm_t *pcm = level->pcm;
	memset(level->channels, 0, snd_pcm_meter_get_channels(pcm) * sizeof(*level->channels));
	level->old = snd_pcm_meter_get_now(pcm);
}

snd_pcm_scope_ops_t level_ops = {
	.enable = level_enable,
	.disable = level_disable,
	.close = level_close,
	.start = level_start,
	.stop = level_stop,
	.update = level_update,
	.reset = level_reset,
};

int snd_pcm_scope_level_open(snd_pcm_t *pcm, const char *name,
			     unsigned int bar_width, unsigned int decay_ms,
			     unsigned int peak_ms,
			     snd_pcm_scope_t **scopep)
{
	snd_pcm_scope_t *scope, *s16;
	snd_pcm_scope_level_t *level;
	int err = snd_pcm_scope_malloc(&scope);
	if (err < 0)
		return err;
	level = calloc(1, sizeof(*level));
	if (!level) {
		free(scope);
		return -ENOMEM;
	}
	level->pcm = pcm;
	level->bar_width = bar_width;
	level->decay_ms = decay_ms;
	level->peak_ms = peak_ms;
	s16 = snd_pcm_meter_search_scope(pcm, "s16");
	if (!s16) {
		err = snd_pcm_scope_s16_open(pcm, "s16", &s16);
		if (err < 0) {
			free(scope);
			free(level);
			return err;
		}
	}
	level->s16 = s16;
	snd_pcm_scope_set_ops(scope, &level_ops);
	snd_pcm_scope_set_callback_private(scope, level);
	if (name)
		snd_pcm_scope_set_name(scope, strdup(name));
	snd_pcm_meter_add_scope(pcm, scope);
	*scopep = scope;
	return 0;
}

int _snd_pcm_scope_level_open(snd_pcm_t *pcm, const char *name,
			      snd_config_t *root, snd_config_t *conf)
{
	snd_config_iterator_t i, next;
	snd_pcm_scope_t *scope;
	long bar_width = -1, decay_ms = -1, peak_ms = -1;
	int err;
	snd_config_for_each(i, next, conf) {
		snd_config_t *n = snd_config_iterator_entry(i);
		const char *id;
		if (snd_config_get_id(n, &id) < 0)
			continue;
		if (strcmp(id, "comment") == 0)
			continue;
		if (strcmp(id, "type") == 0)
			continue;
		if (strcmp(id, "bar_width") == 0) {
			err = snd_config_get_integer(n, &bar_width);
			if (err < 0) {
				SNDERR("Invalid type for %s", id);
				return -EINVAL;
			}
			continue;
		}
		if (strcmp(id, "decay_ms") == 0) {
			err = snd_config_get_integer(n, &decay_ms);
			if (err < 0) {
				SNDERR("Invalid type for %s", id);
				return -EINVAL;
			}
			continue;
		}
		if (strcmp(id, "peak_ms") == 0) {
			err = snd_config_get_integer(n, &peak_ms);
			if (err < 0) {
				SNDERR("Invalid type for %s", id);
				return -EINVAL;
			}
			continue;
		}
		SNDERR("Unknown field %s", id);
		return -EINVAL;
	}
	if (bar_width < 0)
		bar_width = BAR_WIDTH;
	if (decay_ms < 0)
		decay_ms = DECAY_MS;
	if (peak_ms < 0)
		peak_ms = PEAK_MS;
	return snd_pcm_scope_level_open(pcm, name, bar_width, decay_ms, peak_ms,
					&scope);
}