//int ed_tilecol = 0;
gint VID_EditorUpdate(gpointer data)
{
/*if(ed_tilecol >= 255-16)
ed_tilecol = 0;
int i, j;
for(i = 0; i < vid.height; i++)
{
for(j = 0; j < vid.width; j++)
ed_backtile->data[i * vid.width + j] = ed_tilecol;
i += 16;
}
for(i = 0; i < vid.width; i++)
{
for(j = 0; j < vid.height; j++)
ed_backtile->data[j * vid.width + i] = ed_tilecol;
i += 16;
}
ed_tilecol++;
*/
gdk_draw_indexed_image(gtk_widget_get_window(x_win), x_gc, 0, 0, ed_backtile->width, ed_backtile->height, GDK_RGB_DITHER_NONE, ed_backtile->data, ed_backtile->width, x_cmap);
if(ed_file)
{
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, 0, ed_menubar->allocation.height, ed_file->width, ed_file->height, GDK_RGB_DITHER_NONE, ed_file->data, ed_file->width, ed_cmap);
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, ed_file->width, ed_menubar->allocation.height, ed_palfile->width, ed_palfile->height, GDK_RGB_DITHER_NONE, ed_palfile->data, ed_palfile->width, ed_cmap);
return 1;
}
gdk_draw_indexed_image(gtk_widget_get_window(ed_window), ed_pic, 0, ed_menubar->allocation.height, ed_palfile->width, ed_palfile->height, GDK_RGB_DITHER_NONE, ed_palfile->data, ed_palfile->width, ed_cmap);
return 1;
}
gint Repaint(gpointer data) {
GtkWidget * widget = (GtkWidget *)data;
#ifdef TRUE_COLOR
gdk_draw_rgb_image( widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
0,
0,
SCREEN_XRES,
SCREEN_YRES,
GDK_RGB_DITHER_NONE,
(guchar *)(V_CPU.shm_base_addr + SCRN_OFFSET + SHM_SCRN_IOCTL),
SCREEN_XRES*(SCREEN_BPP/8));
#else
gdk_draw_indexed_image( widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
0,
0,
SCREEN_XRES,
SCREEN_YRES,
GDK_RGB_DITHER_NORMAL,
(guchar *)(V_CPU.shm_base_addr + SCRN_OFFSET + SHM_SCRN_IOCTL),
SCREEN_XRES,
V_CPU.cmap);
#endif
return TRUE;
}
gint on_darea_expose(GtkWidget *widget, GdkEventExpose *event, gpointer user_data) {
#ifdef TRUE_COLOR
gdk_draw_rgb_image( widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
0,
0,
SCREEN_XRES,
SCREEN_YRES,
GDK_RGB_DITHER_NONE,
(guchar *)(V_CPU.shm_base_addr + SCRN_OFFSET + SHM_SCRN_IOCTL),
SCREEN_XRES*(SCREEN_BPP/8));
#else
gdk_draw_indexed_image( widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
0,
0,
SCREEN_XRES,
SCREEN_YRES,
GDK_RGB_DITHER_NORMAL,
(guchar *)(V_CPU.shm_base_addr + SCRN_OFFSET + SHM_SCRN_IOCTL),
SCREEN_XRES,
V_CPU.cmap);
#endif
return FALSE;
}
static void the_fftscope(void)
{
guchar *loc;
guchar bits [256 * 129];
int i, h;
running = 1;
while (running) {
guint val;
gint j;
gint k;
memset(bits, 0, 256 * 128);
for (i=0; i < BARS; i++) {
val = 0;
for (j = xranges[i]; j < xranges[i + 1]; j++) {
/* k = (guint)(sqrt(fftout[j]) * fftmult); */
k = (fft_buf[j] + fft_buf[256+j]) / 256;
val += k;
}
if(val > 127) val = 127;
if (val > (guint)maxbar[ i ])
maxbar[ i ] = val;
else {
k = maxbar[ i ] - (4 + (8 / (128 - maxbar[ i ])));
val = k > 0 ? k : 0;
maxbar[ i ] = val;
}
loc = bits + 256 * 128;
for (h = val; h > 0; h--) {
for (j = (256 / BARS) * i + 0; j < (256 / BARS) * i + ((256 / BARS) - 1); j++) {
*(loc + j) = val-h;
}
loc -=256;
}
}
GDK_THREADS_ENTER();
gdk_draw_indexed_image(area->window, area->style->white_gc,
0,0,256,128, GDK_RGB_DITHER_NONE, bits, 256, color_map);
gdk_flush();
GDK_THREADS_LEAVE();
dosleep(SCOPE_SLEEP);
}
GDK_THREADS_ENTER();
fftscope_hide();
GDK_THREADS_LEAVE();
}
/* The actual FFTscope renderer function. */
static void the_fftscope()
{
guint8 *loc;
guint8 bits[256 * 129];
int i, h;
running = 1;
while (running) {
int w;
guint val;
memset(bits, 128, 256 * SCOPE_HEIGHT);
for (i = 0; i < 256; i++) {
val = (act_fft[i] + act_fft[i + 256]) / (64 * (128 / SCOPE_HEIGHT));
if (val > (SCOPE_HEIGHT-1)) {
val = (SCOPE_HEIGHT-1);
}
loc = bits + i + 256 * (SCOPE_HEIGHT-1);
for (h = val; h > 0; h--) {
*loc = h;
loc -= 256;
}
}
GDK_THREADS_ENTER();
gdk_draw_indexed_image(area->window, area->style->white_gc,
0, 0, 256, SCOPE_HEIGHT, GDK_RGB_DITHER_NONE,
bits, 256, color_map);
gdk_flush();
GDK_THREADS_LEAVE();
dosleep(SCOPE_SLEEP);
}
GDK_THREADS_ENTER();
fftscope_hide();
GDK_THREADS_LEAVE();
}
/* draw a part of a pixmap info to the window */
void draw_pinfo(GdkWindow *w, GdkGC *gc,struct pixmap_info *p_info,
int srcx,int srcy, int destx, int desty,
int width, int height)
{
guchar *bitbuf=p_info->row_pointers[srcy]+srcx*p_info->bit_depth/8;
if (p_info->num_palette) {
GdkRgbCmap* cmap=gdk_rgb_cmap_new(p_info->gdk_palette,
p_info->num_palette);
/* printf("drawing %x:(%d,%d) to (%d,%d) w:%d h=%d\n",(int)p_info,
srcx,srcy,destx,desty,width,height); */
gdk_draw_indexed_image(w,gc,destx,desty,width,height,
GDK_RGB_DITHER_NONE,
bitbuf,p_info->row_len,
cmap);
gdk_rgb_cmap_free(cmap);
} else {
gdk_draw_rgb_image(w,gc,destx,desty,width,height,
GDK_RGB_DITHER_NONE,bitbuf,
p_info->row_len);
}
}
/* This is a generic rendering function. It works for all signal styles.
* The input always looks like one big PCM sample; if the input is really
* a spectrum, then it will have been transformed by blurk_render_pcm()
* into 256 PCM samples, with 20000 meaning "no sound" and smaller/negative
* values representing a lot of sound. This particular transformation was
* chosen simply because the normal PCM plotter can then produce a nice-looking
* spectrum graph.
*
* This function supports a variety of ways to plot the [pseudo-]PCM samples.
* In addition to the usual line graph, it can also mirror the line graph or
* produce a "bead" graph by passing the data off to render_bead().
* The decision of how to plot is based on the value of "variation".
*/
static void update_image(gint32 loudness, gint ndata, gint16 *data)
{
gint i, y, thick, quiet, center;
gint beat;
guchar *img;
gint width, height, bpl;
#if 0
/* If events are pending, then skip this frame */
if (gdk_events_pending())
return;
#endif
/* If we completed a resize operation a few seconds ago, then save the
* new size now.
*/
if (savewhen != 0L && time(NULL) >= savewhen)
{
//config_write(FALSE, NULL, NULL);
savewhen = 0L;
}
/* If we're supposed to be in fullscreen mode, and aren't, then
* toggle fullscreen mode now.
*/
#if 0
if (config.fullscreen_desired && !fullscreen_method)
blursk_fullscreen(FALSE);
#endif
/* Detect whether this is a beat, and choose a line thickness */
beat = detect_beat(loudness, &thick, &quiet);
/* If quiet, then maybe choose a new preset */
//if (quiet)
//preset_quiet();
/* Perform the blurring. This also affects whether the center of the
* signal will be moved lower in the window.
*/
center = img_height/2 + blur(beat, quiet);
/* Perform the fade or solid flash */
if (beat && !strcmp(config.flash_style, "Full flash"))
i = 60;
else
{
switch (config.fade_speed[0])
{
case 'S': i = -1; break; /* Slow */
case 'M': i = -3; break; /* Medium */
case 'F': i = -9; break; /* Fast */
default: i = 0; /* None */
}
}
if (i != 0)
loopfade(i);
/* special processing for "Invert" & bitmap logo flashes */
if (beat)
{
if (!strcmp(config.flash_style, "Invert flash"))
img_invert();
else if ((i = bitmap_index(config.flash_style)) >= 0)
bitmap_flash(i);
}
/* Maybe change hue on beats */
if (beat)
color_beat();
/* Add the signal data to the image */
render(thick, center, ndata, data);
/* Add floaters */
drawfloaters(beat);
/* shift the "ripple effect" from one frame to another */
img_rippleshift += 3; /* cyclic, since img_rippleshift is a guchar */
/* Apply the overall effect, if any */
if (!strcmp(config.overall_effect, "Bump effect"))
{
img = img_bump(&width, &height, &bpl);
}
else if (!strcmp(config.overall_effect, "Anti-fade effect"))
{
img = img_travel(&width, &height, &bpl);
}
else if (!strcmp(config.overall_effect, "Ripple effect"))
{
img = img_ripple(&width, &height, &bpl);
}
else /* "Normal effect" */
{
img = img_expand(&width, &height, &bpl);
}
/* show info about the track */
img = show_info(img, height, bpl);
/* Allow the background color to change */
color_bg(ndata, data);
/* Copy the image into the window. This also converts from
* 8-bits to 16/24/32 if necessary.
*/
#if 0
GDK_THREADS_ENTER();
#if HAVE_XV
if (!xv_putimg(img, width, height, bpl))
#endif
gdk_draw_indexed_image(area->window,
area->style->white_gc,
0, 0, width, height, GDK_RGB_DITHER_NONE,
img, bpl, color_map);
GDK_THREADS_LEAVE();
#endif
/* Convert colors */
uint32* pDst = (uint32*)blursk_bitmap->LockRaster();
uint8* pSrc = img;
for( y = 0; y < height; y++ )
{
for( i = 0; i < width; i++ )
{
*pDst++ = color_map[*pSrc++];
}
pSrc += bpl - width;
}
blursk_view->DrawBitmap( blursk_bitmap, blursk_bitmap->GetBounds(), blursk_bitmap->GetBounds() );
blursk_view->Flush();
}
