//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(); }