int visual_audio_normalise_spectrum (VisBuffer *buffer)
{
visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_dft_log_scale_standard (visual_buffer_get_data (buffer),
visual_buffer_get_data (buffer),
visual_buffer_get_size (buffer) / sizeof (float));
return VISUAL_OK;
}
static void act_bumpscope_render (VisPluginData *plugin, VisVideo *video, VisAudio *audio)
{
BumpscopePrivate *priv = visual_plugin_get_private (plugin);
priv->video = video;
visual_audio_get_sample_mixed_simple (audio, priv->pcmbuf, 2,
VISUAL_AUDIO_CHANNEL_LEFT,
VISUAL_AUDIO_CHANNEL_RIGHT);
__bumpscope_render_pcm (priv, visual_buffer_get_data (priv->pcmbuf));
visual_mem_copy (visual_video_get_pixels (video), priv->rgb_buf2, visual_video_get_size (video));
priv->colorupdate++;
/* Let's not overload the color selector */
if (priv->colorupdate > 1)
priv->colorupdate = 0;
if (priv->colorchanged == TRUE && priv->colorupdate == 0) {
/* I couldn't hold myself */
visual_param_set_value_color (
visual_param_list_get (
visual_plugin_get_params (plugin), "color"), &priv->color);
}
}
int visual_video_set_buffer (VisVideo *video, void *buffer)
{
visual_return_val_if_fail (video != NULL, -VISUAL_ERROR_VIDEO_NULL);
if (visual_buffer_get_allocated (video->buffer)) {
visual_log (VISUAL_LOG_ERROR, _("Trying to set a screen buffer on "
"a VisVideo structure which points to an allocated screen buffer"));
return -VISUAL_ERROR_VIDEO_HAS_ALLOCATED;
}
visual_buffer_set_data (video->buffer, buffer);
visual_buffer_set_destroyer (video->buffer, NULL);
if (video->pixel_rows != NULL) {
visual_mem_free (video->pixel_rows);
video->pixel_rows = NULL;
}
if (visual_buffer_get_data (video->buffer) != NULL) {
video->pixel_rows = visual_mem_new0 (void *, video->height);
precompute_row_table (video);
}
static int act_jakdaw_render (VisPluginData *plugin, VisVideo *video, VisAudio *audio)
{
JakdawPrivate *priv = visual_object_get_private (VISUAL_OBJECT (plugin));
uint32_t *vscr = visual_video_get_pixels (video);
visual_audio_get_sample_mixed_simple (audio, priv->pcmbuf, 2,
VISUAL_AUDIO_CHANNEL_LEFT,
VISUAL_AUDIO_CHANNEL_RIGHT);
visual_audio_get_spectrum_for_sample (priv->freqbuf, priv->pcmbuf, TRUE);
_jakdaw_feedback_render (priv, vscr);
_jakdaw_plotter_draw (priv,
visual_buffer_get_data (priv->pcmbuf),
visual_buffer_get_data (priv->freqbuf), vscr);
return 0;
}
int visual_audio_get_spectrum_for_sample (VisBuffer *buffer, VisBuffer *sample, int normalised)
{
VisDFT dft;
visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_return_val_if_fail (sample != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_dft_init (&dft, visual_buffer_get_size (buffer) / sizeof (float),
visual_buffer_get_size (sample) / sizeof (float));
/* Fourier analyze the pcm data */
visual_dft_perform (&dft, visual_buffer_get_data (buffer), visual_buffer_get_data (sample));
if (normalised == TRUE)
visual_audio_normalise_spectrum (buffer);
visual_object_unref (VISUAL_OBJECT (&dft));
return VISUAL_OK;
}
int visual_audio_sample_buffer_mix (VisBuffer *dest, VisBuffer *src, int divide, float multiplier)
{
float *dbuf;
float *sbuf;
int scnt;
int i;
visual_return_val_if_fail (dest != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_return_val_if_fail (src != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_return_val_if_fail (visual_buffer_get_size (dest) == visual_buffer_get_size (src),
-VISUAL_ERROR_BUFFER_OUT_OF_BOUNDS);
dbuf = visual_buffer_get_data (dest);
sbuf = visual_buffer_get_data (src);
scnt = visual_buffer_get_size (dest) / sizeof (float);
/* FIXME make simd version of these */
if (divide == FALSE) {
if (multiplier == 1.0) {
for (i = 0; i < scnt; i++)
dbuf[i] += sbuf[i];
} else {
for (i = 0; i < scnt; i++)
dbuf[i] += (sbuf[i] * multiplier);
}
} else {
if (multiplier == 1.0) {
for (i = 0; i < scnt; i++)
dbuf[i] = (dbuf[i] + sbuf[i]) * 0.5;
} else {
for (i = 0; i < scnt; i++)
dbuf[i] = (dbuf[i] + (sbuf[i] * multiplier)) * 0.5;
}
}
return VISUAL_OK;
}
int visual_audio_get_spectrum_for_sample_multiplied (VisBuffer *buffer, VisBuffer *sample, int normalised, float multiplier)
{
int ret;
float *data;
int datasize;
visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_return_val_if_fail (sample != NULL, -VISUAL_ERROR_BUFFER_NULL);
ret = visual_audio_get_spectrum_for_sample (buffer, sample, normalised);
data = visual_buffer_get_data (buffer);
datasize = visual_buffer_get_size (buffer) / sizeof (float);
visual_math_vectorized_multiplier_floats_const_float (data, data, datasize, multiplier);
return ret;
}
int visual_audio_get_spectrum_multiplied (VisAudio *audio, VisBuffer *buffer, int samplelen, const char *channelid, int normalised, float multiplier)
{
int ret;
float *data;
int datasize;
visual_return_val_if_fail (audio != NULL, -VISUAL_ERROR_AUDIO_NULL);
visual_return_val_if_fail (buffer != NULL, -VISUAL_ERROR_BUFFER_NULL);
visual_return_val_if_fail (channelid != NULL, -VISUAL_ERROR_BUFFER_NULL);
ret = visual_audio_get_spectrum (audio, buffer, samplelen, channelid, normalised);
data = visual_buffer_get_data (buffer);
datasize = visual_buffer_get_size (buffer) / sizeof (float);
visual_math_vectorized_multiplier_floats_const_float (data, data, datasize, multiplier);
return ret;
}
static int nebulus_sound (NebulusPrivate *priv, VisAudio *audio)
{
int i, c, y, tmp;
GLfloat val, energy = 0;
int xscale[] = { 0, 1, 2, 3, 5, 7, 10, 14, 20, 28, 40, 54, 74, 101, 137, 187, 255 };
float *fbuf;
VisBuffer *buf;
float freq[256];
visual_audio_get_sample_mixed_simple (audio, priv->pcmbuf, 2,
VISUAL_AUDIO_CHANNEL_LEFT,
VISUAL_AUDIO_CHANNEL_RIGHT);
buf = visual_buffer_new_wrap_data (freq, sizeof (freq));
visual_audio_get_spectrum_for_sample (buf, priv->pcmbuf, FALSE);
visual_buffer_free (buf);
fbuf = visual_buffer_get_data (priv->pcmbuf);
for (i = 0; i < 1024; i++) {
pcm_data[i] = fbuf[i] * 32767; // FIXME pull the 32767 as a constant from somewhere, also in goom2.c
}
for(y = 15; y > 0; y--) {
for(i = 0; i < 16; i++)
heights[y][i] = heights[y - 1][i];
}
for(i = 0; i < NUM_BANDS; i++) {
for(c = xscale[i], y = 0; c < xscale[i + 1]; c++) {
if(freq[c] > y)
y = freq[c];
}
loudness += (y / (xscale[i + 1] - xscale[i] + 1)) *
(abs (i - NUM_BANDS / 2) + NUM_BANDS / 2) * (4 + i);
y >>= 7;
if(y > 0)
val = (log(y) * scale);
else
val = 0;
heights[0][i] = val;
}
loudness /= (NUM_BANDS * 4);
beat = nebulus_detect_beat (loudness);
too_long++;
if (!point_general->freeze) {
if (too_long > 1000) {
too_long = 0;
point_general->effect = nebulus_random_effect();
point_general->changement = TRUE;
}
if (beat) {
if (beat_compteur > point_general->beat - 1) {
point_general->effect = nebulus_random_effect();
point_general->changement = TRUE;
beat_compteur = 0;
too_long = 0;
}
beat_compteur += beat;
}
}
for (i = 0; i < 256; i++) {
tmp = freq[i] * 0.0625;
energy += tmp * tmp;
}
energy = energy / 65536 / 256 * 256;
energy += 6.0f;
energy *= 1.2f;
if (energy > 10)
energy = 10;
point_general->energy = energy;
return 0;
}
static int fixate_with_partial_data_request (VisRingBuffer *ringbuffer, VisBuffer *data, int offset, int nbytes,
int *buffercorr)
{
VisListEntry *le = NULL;
VisRingBufferEntry *entry;
int curoffset = 0;
int startat = 0;
*buffercorr = 0;
while ((entry = visual_list_next (ringbuffer->entries, &le)) != NULL) {
int bsize = 0;
startat++;
if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_BUFFER) {
if ((bsize = visual_buffer_get_size (entry->buffer)) > 0)
curoffset += bsize;
/* This buffer partially falls within the offset */
if (curoffset > offset) {
visual_buffer_put_data (data,
((uint8_t *) visual_buffer_get_data (entry->buffer) +
visual_buffer_get_size (entry->buffer)) -
(curoffset - offset), curoffset - offset, 0);
*buffercorr = curoffset - offset;
break;
}
} else if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_FUNCTION) {
if (entry->sizefunc != NULL) {
curoffset += entry->sizefunc (ringbuffer, entry);
/* This buffer partially falls within the offset */
if (curoffset > offset) {
VisBuffer *tempbuf = entry->datafunc (ringbuffer, entry);
visual_buffer_put_data (data,
((uint8_t *) visual_buffer_get_data (tempbuf) +
visual_buffer_get_size (tempbuf)) -
(curoffset - offset), curoffset - offset, 0);
visual_buffer_unref (tempbuf);
*buffercorr = curoffset - offset;
break;
}
} else {
VisBuffer *tempbuf = entry->datafunc (ringbuffer, entry);
if ((bsize = visual_buffer_get_size (tempbuf)) > 0)
curoffset += bsize;
/* This buffer partially falls within the offset */
if (curoffset > offset) {
visual_buffer_put_data (data,
((uint8_t *) visual_buffer_get_data (tempbuf) +
visual_buffer_get_size (tempbuf)) -
(curoffset - offset), curoffset - offset, 0);
*buffercorr = curoffset - offset;
break;
}
visual_buffer_unref (tempbuf);
}
}
}
return startat;
}
int visual_ringbuffer_get_data_offset (VisRingBuffer *ringbuffer, VisBuffer *data, int offset, int nbytes)
{
VisListEntry *le = NULL;
VisRingBufferEntry *entry;
int curposition = 0;
int startat = 0;
int buffercorr = 0;
visual_return_val_if_fail (ringbuffer != NULL, -VISUAL_ERROR_RINGBUFFER_NULL);
visual_return_val_if_fail (data != NULL, -VISUAL_ERROR_BUFFER_NULL);
/* Fixate possible partial buffer */
if (offset > 0)
startat = fixate_with_partial_data_request (ringbuffer, data, offset, nbytes, &buffercorr);
curposition = buffercorr;
/* Buffer fixated with partial segment, request the other segments */
while (curposition < nbytes) {
int lindex = 0;
le = NULL;
/* return immediately if there are no elements in the list */
if(visual_list_count(ringbuffer->entries) == 0)
return VISUAL_OK;
while ((entry = visual_list_next (ringbuffer->entries, &le)) != NULL) {
VisBuffer *tempbuf = NULL;
lindex++;
/* Skip to the right offset buffer fragment */
if (lindex <= startat)
continue;
if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_BUFFER) {
tempbuf = entry->buffer;
} else if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_FUNCTION) {
/* Will bail out through visual_error_raise(), this is fatal, let's not try to
* recover, it's a very obvious bug in the software */
if (entry->datafunc == NULL) {
visual_log (VISUAL_LOG_ERROR,
_("No VisRingBufferDataFunc data provider function set on "
"type VISUAL_RINGBUFFER_ENTRY_TYPE_FUNCTION"));
return -VISUAL_ERROR_IMPOSSIBLE;
}
tempbuf = entry->datafunc (ringbuffer, entry);
}
if (curposition + visual_buffer_get_size (tempbuf) > nbytes) {
VisBuffer *buf;
buf = visual_buffer_new_wrap_data (visual_buffer_get_data (tempbuf), nbytes - curposition);
visual_buffer_put (data, buf, curposition);
visual_buffer_free (buf);
if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_FUNCTION)
visual_buffer_unref (tempbuf);
return VISUAL_OK;
}
visual_buffer_put (data, tempbuf, curposition);
curposition += visual_buffer_get_size (tempbuf);
if (entry->type == VISUAL_RINGBUFFER_ENTRY_TYPE_FUNCTION)
visual_buffer_unref (tempbuf);
/* Filled without room for partial buffer addition */
if (curposition == nbytes)
return VISUAL_OK;
}
startat = 0;
}
return VISUAL_OK;
}
