int main(int argc, char **argv)
{
optproc(argc, argv, &opts); if(audio_init(&opts) < 0) exit(1);
SDL_Surface *screen = sdl_setup(&opts, IM_SIZE);
im_w = screen->w - screen->w%16; im_h = screen->h - screen->h%16;
printf("running with %dx%d bufs\n", im_w, im_h);
if(strcmp(opts.map_name, "rational") == 0) {
map_func = soft_map_rational_interp;
if(opts.quality >= 1) map_func = soft_map_rational;
}
else if(strcmp(opts.map_name, "butterfly") == 0) {
// map_func = soft_map_butterfly_interp;
// if(opts.quality >= 1)
map_func = soft_map_butterfly;
}
else if(opts.quality >= 1) map_func = soft_map;
maxsrc = maxsrc_new(im_w, im_h);
struct pal_ctx *pal_ctx = pal_ctx_new(screen->format->BitsPerPixel == 8);
uint16_t *map_surf[3];
void *map_surf_mem = aligned_alloc(64, 3 * im_w * im_h * sizeof(uint16_t));
for(int i=0; i<3; i++)
map_surf[i] = map_surf_mem + i * im_w * im_h * sizeof(uint16_t);
memset(map_surf_mem, 0, 3 * im_w * im_h * sizeof(uint16_t));
tribuf *map_tb = tribuf_new((void **)map_surf, 1);
int beats = 0;
int frmcnt = 0;
int lastdrawn=0;
SDL_Thread *map_thread = SDL_CreateThread((void *)&run_map_thread, map_tb);
SDL_Delay(100);
uint32_t frametimes[FPS_HIST_LEN]; for(int i=1; i<FPS_HIST_LEN; i++) frametimes[i] = 0;
uint32_t totframetime = frametimes[0] = MIN(1000/opts.draw_rate, 1);
Uint32 tick0 = SDL_GetTicks();
Uint32 lastpalstep, lastupdate, fps_oldtime; fps_oldtime = lastpalstep = lastupdate = tick0;
SDL_Event event;
while(SDL_PollEvent(&event) >= 0)
{
if(event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)) {
break;
} else if(tribuf_check_fresh(map_tb)) {
Uint32 now = SDL_GetTicks();
if(now - lastpalstep >= 2048/256) { // want pallet switch to take ~2 seconds
pal_ctx_step(pal_ctx, IMIN((now - lastpalstep)*256/2048, 64));
lastpalstep = now;
}
pallet_blit_SDL(screen, tribuf_get_read(map_tb), im_w, im_h, pal_ctx_get_active(pal_ctx));
tribuf_finish_read(map_tb);
char buf[64];
sprintf(buf,"%6.1f FPS %6.1f UPS %6.1f", map_fps, FPS_HIST_LEN*1000.0f/totframetime, maxfrms*1000.0f/(now-tick0));
DrawText(screen, buf);
SDL_Flip(screen);
int newbeat = beat_get_count();
if(newbeat != beats) pal_ctx_start_switch(pal_ctx, newbeat);
beats = newbeat;
now = SDL_GetTicks();
int delay = (tick0 + frmcnt*1000/opts.draw_rate) - now;
if(delay > 0) SDL_Delay(delay);
totframetime -= frametimes[frmcnt%FPS_HIST_LEN];
totframetime += (frametimes[frmcnt%FPS_HIST_LEN] = now - fps_oldtime);
fps_oldtime = now;
frmcnt++;
} else {
SDL_Delay(1000/opts.draw_rate/2); // wait half a frame and hope we get a new buffer
}
}
running = 0;
int status;
SDL_WaitThread(map_thread, &status);
aligned_free(map_surf_mem);
audio_shutdown();
SDL_Quit();
return 0;
}
int main(int argc, char *argv[]) {
int returnCode = 0;
struct args *all;
char *msg = malloc(sizeof(char)*80);
FILE *log;
all = optproc(argc, argv); // This extracts our options
struct fileAndLen *histFile = malloc(sizeof(struct fileAndLen));
histFile->file = fopen(all->file, "r");
histFile->length = countLines(histFile->file);
int n;
char *line = malloc(sizeof(int)*100);
char *nudderline;
char *logFilePath;
char *logFile;
int cmdCode = cmdproc(argc, argv);
switch(cmdCode) {
case 0:
fprintf(stderr, "Error incorrect arguments. Usage: lumber command options\n");
returnCode = ARGUMENT_ERROR;
break;
case 1: // 1 for a create statement
logFile = strcat(argv[2],".lumb");
logFilePath = pathToFile(logDirectory,argv[2]);
if (access(logFilePath, F_OK) != -1) {
fprintf(stderr, "ERROR: log \"%s\" already exists\n", argv[2]);
returnCode = LOG_EXISTS_ERROR;
}
log = fopen(logFilePath, "w");
if (!log) {
fprintf(stderr, "ERROR: file could not be opened\n");
returnCode = FILE_ERROR;
}
break;
case 2: // 2 for a switch statement
logFile = strcat(argv[2],".lumb");
logFilePath = pathToFile(logDirectory, argv[2]);
if (access(logFilePath, F_OK) == -1) {
fprintf(stderr, "ERROR: log \"%s\" does not exist\n", argv[2]);
return INVALID_LOG_ERROR;
}
log = fopen(logFilePath, "r");
if (!log) {
fprintf(stderr, "ERROR: file could not be opened\n");
returnCode = FILE_ERROR;
break;
} else {
// This line is supposed to get the bottom line
line = getNthLineFromBottom(log, line, 0);
// This line gets the identifier from that line
line = getIdentifierFromLine(line);
all->lines = histFile->length - getLineNumberWithIdent(histFile->file, line);
fclose(log);
}
log = fopen(logFilePath, "a");
strcat(msg,"switch lumber");
printf("%s\n",msg);
returnCode = sendMessage(msg);
if (returnCode != 0)
fprintf(stderr, "Connection Error: check lumberd is running \n\t Error Code: %d\n", returnCode);
break;
case 3:
returnCode = sendMessage("kill");
if (returnCode != 0)
// Maybe build in the ability to start lumberd from here if not running
fprintf(stderr, "Connection Error: check lumberd is running \n\t Error Code: %d\n", returnCode);
break;
}
if ((cmdCode == 1 || cmdCode == 2) && returnCode == 0) {
for (n = all->lines;n >= 0; n--) { // This component takes the last n lines
fprintf(log, "%s\n", getNthLine(histFile->file, line, histFile->length - n)); // from the history file and enters it into the
} // log file
}
return returnCode;
}
int main(int argc, char **argv)
{
opt_data opts; optproc(argc, argv, &opts);
if(audio_init(&opts) < 0) exit(1);
int x = 0, y = 0, w, h;
if(opts.w < 0 && opts.h < 0) opts.w = opts.h = 512;
else if(opts.w < 0) opts.w = opts.h;
else if(opts.h < 0) opts.h = opts.w;
w = opts.w; h = opts.h;
XEvent event;
dpy = XOpenDisplay( NULL );
if(dpy == NULL) {
printf("Error: couldn't open display %s\n", getenv("DISPLAY"));
exit(EXIT_FAILURE);
}
int glx_major, glx_minor;
if(!glXQueryVersion(dpy, &glx_major, &glx_minor)) {
printf("GLX extension missing!\n");
XCloseDisplay(dpy);
exit(EXIT_FAILURE);
}
printf("GLX version %i.%i\n", glx_major, glx_minor);
int glxErrBase, glxEventBase;
glXQueryExtension(dpy, &glxErrBase, &glxEventBase);
printf("GLX: errorBase = %i, eventBase = %i\n", glxErrBase, glxEventBase);
Window xwin, root;
int numReturned;
GLXFBConfig *fbConfigs;
fbConfigs = glXChooseFBConfig( dpy, DefaultScreen(dpy), fbattrib, &numReturned );
if(fbConfigs == NULL) { //TODO: handle this?
printf("No suitable fbconfigs!\n");
exit(EXIT_FAILURE);
}
XVisualInfo *vinfo = glXGetVisualFromFBConfig( dpy, fbConfigs[0] );
root = DefaultRootWindow(dpy);
/* window attributes */
XSetWindowAttributes attrs;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
attrs.colormap = XCreateColormap(dpy, root, vinfo->visual, AllocNone);
//attrs.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
attrs.event_mask = StructureNotifyMask | KeyPressMask;
unsigned long mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
xwin = XCreateWindow(dpy, root, x, y, w, h,
0, vinfo->depth, InputOutput,
vinfo->visual, mask, &attrs);
XFree(vinfo);
// Set hints and properties:
{
XSizeHints sizehints;
sizehints.x = x;
sizehints.y = y;
sizehints.width = w;
sizehints.height = h;
sizehints.flags = USSize | USPosition;
XSetNormalHints(dpy, xwin, &sizehints);
XSetStandardProperties(dpy, xwin, "Julia-vis", "Julia-vis",
None, (char **)NULL, 0, &sizehints);
}
/* Create a GLX context for OpenGL rendering */
GLXContext context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, NULL, True );
#if 0
GLXContext context = 0;
glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0;
glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc)glXGetProcAddressARB( (const GLubyte *) "glXCreateContextAttribsARB" );
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_ARB_create_context") || !glXCreateContextAttribsARB) {
printf("glXCreateContextAttribsARB() not found ... using old-style GLX context\n");
context = glXCreateNewContext(dpy, fbConfigs[0], GLX_RGBA_TYPE, 0, True);
} else {
const int context_attribs[] = {
GLX_RENDER_TYPE, GLX_RGBA_TYPE,
GLX_CONTEXT_MAJOR_VERSION_ARB, 2,
GLX_CONTEXT_MINOR_VERSION_ARB, 1,
None
};
context = glXCreateContextAttribsARB(dpy, fbConfigs[0], NULL, True, context_attribs);
}
if(context == NULL) {
printf("Failed to create context!\n");
return EXIT_FAILURE;
}
#endif
glxWin = glXCreateWindow(dpy, fbConfigs[0], xwin, NULL );
XMapWindow(dpy, xwin);
XIfEvent(dpy, &event, WaitForNotify, (XPointer) xwin);
glXMakeContextCurrent(dpy, glxWin, glxWin, context);
init_gl(&opts, w, h);
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_MESA_swap_control")) {
PFNGLXSWAPINTERVALMESAPROC swap_interval = glXGetProcAddressARB("glXSwapIntervalMESA");
swap_interval(1);
opts.draw_rate = 300;
}
if(strstr(glXQueryExtensionsString(dpy, 0), "GLX_INTEL_swap_event")) {
glXSelectEvent(dpy, glxWin, GLX_BUFFER_SWAP_COMPLETE_INTEL_MASK);
have_intel_swap_event = GL_TRUE;
}
int debug_maxsrc = 0, debug_pal = 0, show_mandel = 0, show_fps_hist = 0;
if(have_intel_swap_event)
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
while(1) {
if(!have_intel_swap_event) render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
int clear_key = 1;
while (XPending(dpy) > 0)
{
XNextEvent(dpy, &event);
if(event.type == glxEventBase + GLX_BufferSwapComplete) {
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
continue;
}
switch (event.type) {
case Expose:
/* we'll redraw below */
break;
/*case ConfigureNotify:
window_w = event.xconfigure.width;
window_h = event.xconfigure.height;
if (surface_type == EGL_WINDOW_BIT)
reshape(window_w, window_h);
break;*/
case KeyPress:
{
clear_key = 0;
char buffer[10];
int r, code;
code = XLookupKeysym(&event.xkey, 0);
if (code == XK_F1) {
debug_maxsrc = !debug_maxsrc;
} else if (code == XK_F2) {
debug_pal = !debug_pal;
} else if (code == XK_F3) {
show_mandel = !show_mandel;
} else if (code == XK_F4) {
show_fps_hist = !show_fps_hist;
} else {
code = XLookupKeysym(&event.xkey, 1);
if(code == XK_Escape) {
goto glx_main_loop_quit;
}
}
}
break;
default:
//printf("Bar %i!\n", event.type);
break;
}
}
}
glx_main_loop_quit:
audio_shutdown();
XDestroyWindow(dpy, xwin);
XCloseDisplay(dpy);
return 0;
}
int main(int argc, char *argv[])
{
struct opt_data opts; optproc(argc, argv, &opts);
if(audio_init(&opts) < 0) exit(1);
if(opts.w < 0 && opts.h < 0) opts.w = opts.h = 512;
else if(opts.w < 0) opts.w = opts.h;
else if(opts.h < 0) opts.h = opts.w;
int ret;
ret = init_drm(&opts, 512);
if (ret) {
printf("failed to initialize DRM\n");
return ret;
}
ret = init_gbm();
if (ret) {
printf("failed to initialize GBM\n");
return ret;
}
ret = init_egl();
if (ret) {
printf("failed to initialize EGL\n");
return ret;
}
// call init_gl
//init_gl(&opts, drm.mode->hdisplay, drm.mode->vdisplay);
init_gl(&opts, opts.w, opts.h); //TODO: better dealing with our great big screen
eglSwapBuffers(gl.display, gl.surface);
struct gbm_bo *bo = gbm_surface_lock_front_buffer(gbm.surface);
fb = drm_fb_get_from_bo(bo);
/* set mode: */
ret = drmModeSetCrtc(drm.fd, drm.crtc_id, fb->fb_id, 0, 0,
&drm.connector_id, 1, drm.mode);
if (ret) {
printf("failed to set mode: %s\n", strerror(errno));
return ret;
}
// turn off line buffering on input and echoing of characters
struct termios term;
tcgetattr(STDIN_FILENO, &save_term);
tcgetattr(STDIN_FILENO, &term);
term.c_lflag &= ~(ICANON|ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &term);
atexit(shutdown_cleanup);
drmVBlank vbl;
/* Get current count first hopefully also sync up with blank too*/
vbl.request.type = DRM_VBLANK_RELATIVE;
vbl.request.sequence = 1;
ret = drmWaitVBlank(drm.fd, &vbl);
if (ret != 0) {
printf("drmWaitVBlank (relative, event) failed ret: %i\n", ret);
return -1;
}
printf("starting msc: %d\n", vbl.request.sequence);
/* Queue an event for frame + 1 */
vbl.request.type = DRM_VBLANK_RELATIVE | DRM_VBLANK_EVENT;
vbl.request.sequence = 1;
vbl.request.signal = NULL;
ret = drmWaitVBlank(drm.fd, &vbl);
if (ret != 0) {
printf("drmWaitVBlank (relative, event) failed ret: %i\n", ret);
return -1;
}
struct pollfd pfds[] = {
{drm.fd, POLLIN | POLLPRI, 0 },
{STDIN_FILENO, POLLIN, 0 },
};
int debug_maxsrc = 0, debug_pal = 0, show_mandel = 0, show_fps_hist = 0;
bool done = false;
while (!done) {
render_frame(debug_maxsrc, debug_pal, show_mandel, show_fps_hist);
while (waiting_for_flip) { // TODO: input handling
ret = poll(pfds, 2, -1);
if (ret < 0) {
printf("poll err: %s\n", strerror(errno));
return ret;
} else if (ret == 0) {
printf("poll timeout!\n");
done = true;
break;
}
if (pfds[1].revents) {
char buf[128];
int cnt = read(STDIN_FILENO, buf, sizeof(buf));
if(buf[0] == 27) done = true;
else if(buf[0] == '1') debug_maxsrc = !debug_maxsrc;
else if(buf[0] == '2') debug_pal = !debug_pal;
else if(buf[0] == '3') show_mandel = !show_mandel;
else if(buf[0] == '4') show_fps_hist = !show_fps_hist;
//continue;
}
if(pfds[0].revents)
drmHandleEvent(drm.fd, &evctx);
}
/* release last buffer to render on again: */
gbm_surface_release_buffer(gbm.surface, bo);
bo = next_bo;
}
audio_shutdown();
return ret;
}
