Hello tableteers,
I've done some initial experiments hacking my N800/OS2008 and ran into a
couple of issues:
When using the supplied SDL library for doing timer-based frame
rendering, there seems to be
- heavy tearing
- significant overhead due to X server
(rendering pipe is : SDL -> X -> Framebuffer)
[Note: yes, I'm aware that doing full screen blits is evil on the N800
due to limited framebuffer -> video RAM bus bandwidth.]
Q: Is this expected behaviour? What could I do about the tearing? What
about the Xomap overhead?
==
I've read a lot of bits on the web 'bout mplayer, vsync, omapfb etc.
and tried to assemble a minimal example of using direct framebuffer
access for gfx output.
Q: I can't get the tearing away (only fixed at certain line positions).
What am I doing wrong?
Q: Also, frame rate is sluggish, though CPU load is much lower than
SDL/X. Ok, my FB example is not threaded like the SDL timer example ..
is that the reason for framerate even < 15/s?
Q: btw - how can I shutdown Maemo Launcher/Hildon/Matchbox/Xomap?
Whenever I do one of
/etc/init.d/maemo-launcher stop
/etc/init.d/x-server stop
the device will automatically reboot.
==
I wondered if there would be any plans to make SDL run directly on
framebuffer .. if not, I'd maybe give it a try.
Q: Where can I find the sources to the OS2008 SDL?
Thx and cheers,
tgo
=========================================
SDL Test
===> Makefile:
##
## produce ARM11 target optimized code
## use hardware FP, but use soft FP ABI for math lib
##
OPT_FLAGS = -O3 -fomit-frame-pointer -mcpu=arm1136j-s -mfpu=vfp
-mfloat-abi=softfp
##
## SDL compile/link flags
##
SDL_FLAGS = `sdl-config --cflags` `sdl-config --libs`
##
## compiler command
##
CC = gcc -Wall $(OPT_FLAGS) $(SDL_FLAGS)
all: sdl_timer
sdl_timer: sdl_timer.c
$(CC) sdl_timer.c -o sdl_timer
===> Source:
//
// minimal timer based SDL fullscreen test for N800
//
// the test seems to indicate 2 problems:
//
// 1) heavy tearing
// 2) significant overhead due to X server (rendering pipe is : SDL ->
X -> Framebuffer)
//
/*
Mem: 90376K used, 36452K free, 0K shrd, 716K buff, 42956K cached
Load average: 1.01 0.64 0.44
PID USER STATUS VSZ PPID %CPU %MEM COMMAND
756 root SW< 11368 338 21.8 8.9 Xomap
1831 root SW 12532 1365 7.3 9.8 sdl_timer
1815 root RW 1960 1799 3.0 1.5 top
78 root SW< 0 6 2.7 0.0 OMAP McSPI/0
1032 user SW< 32052 957 2.1 25.2 maemo-launcher
376 root SW< 0 6 1.6 0.0 cx3110x
...
*/
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "SDL.h"
#define HRES 800
#define VRES 480
#define BPP 16
//
// frame render callback
//
Uint32 renderFrame (Uint32 interval, void *param)
{
static int col = 0;
// get screen surface from parameter
SDL_Surface *screen = (SDL_Surface*) param;
// lock surface if needed
if (SDL_MUSTLOCK(screen))
{
if (SDL_LockSurface(screen) < 0)
{
fprintf (stderr, "unable to lock surface\n");
exit(1);
}
}
// "render" whole frame in single color
memset(screen->pixels, ++col, HRES * BPP / 8 * VRES);
// unlock surface if needed
if (SDL_MUSTLOCK(screen))
{
SDL_UnlockSurface(screen);
}
// update whole screen
SDL_UpdateRect(screen, 0, 0, HRES, VRES);
// continue firing
return interval;
}
int main (int argc, char** argv)
{
// initialize SDL
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER) < 0)
{
fprintf (stderr, "unable to initialize SDL : %s\n", SDL_GetError());
exit(1);
}
// register SDL cleanup
atexit (SDL_Quit);
// set mouse pointer invisible
SDL_ShowCursor (SDL_DISABLE);
// set video mode to fullscreen
SDL_Surface *screen = SDL_SetVideoMode(HRES, VRES, BPP, SDL_SWSURFACE
| SDL_FULLSCREEN);
if (screen == NULL)
{
fprintf (stderr, "unable to initialize video : %s\n", SDL_GetError());
exit(1);
}
// setup frame renderer at rate 17 frames/s (every 60ms)
SDL_TimerID tid = SDL_AddTimer (60,
(SDL_NewTimerCallback) renderFrame,
screen);
// run for 60 secs
sleep (60);
// shutdown frame renderer
SDL_bool ret = SDL_RemoveTimer (tid);
if (!ret)
{
fprintf (stderr, "could not shutdown timer : %s\n", SDL_GetError());
exit(1);
}
// finished
return 0;
}
===
=========================================
Framebuffer Test
===> Makefile:
##
## produce ARM11 target optimized code
## use hardware FP, but use soft FP ABI for math lib
##
OPT_FLAGS = -O3 -fomit-frame-pointer -mcpu=arm1136j-s -mfpu=vfp
-mfloat-abi=softfp
##
## compiler command
##
CC = gcc -Wall $(OPT_FLAGS) -lX11
all: fb_minimal
fb_minimal: fb_minimal.c
$(CC) fb_minimal.c -o fb_minimal
===> Source:
//////////////////////////////////////////////////////////////////////////
//
// Test for direct framebuffer graphics bypassing X. (tested on N800)
//
//////////////////////////////////////////////////////////////////////////
/*
Mem: 89132K used, 37696K free, 0K shrd, 716K buff, 42116K cached
Load average: 0.80 0.25 0.18
PID USER STATUS VSZ PPID %CPU %MEM COMMAND
1686 root RW 3124 1685 6.1 2.4 fb_minimal
1032 user SW< 32052 957 2.2 25.2 maemo-launcher
1687 root RW 1960 1365 2.1 1.5 top
756 root SW< 10492 338 1.1 8.2 Xomap
78 root SW< 0 6 0.9 0.0 OMAP McSPI/0
376 root SW< 0 6 0.3 0.0 cx3110x
346 root SW 776 338 0.1 0.6 bme_RX-34
987 user SW< 27532 957 0.0 21.6 maemo-launcher
...
Nokia-N800-50-2:/home/oberstet# time ./fb_minimal
real 1m 48.01s
user 0m 6.31s
sys 0m 0.33s
Nokia-N800-50-2:/home/oberstet#
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <asm-arm/arch-omap/omapfb.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
//
/scratchbox/compilers/cs2005q3.2-glibc2.5-arm/usr/include/asm-arm/arch-omap/omapfb.h
//
/scratchbox/compilers/cs2005q3.2-glibc2.5-arm/arm-none-linux-gnueabi/sys-include/asm-arm/arch-omap/omapfb.h
#define HRES 800
#define VRES 480
#define BPP 16
#define LOOPN 1000
#define OMAPFB_FORMAT_FLAG_TEARSYNC 0x0200
#define OMAPFB_FORMAT_FLAG_FORCE_VSYNC 0x0400
int main (int argc, char** argv)
{
//////////////////////////////////////////////////////////////////////////
//
// setup X stuff (we pull up a "pseudo X window" in fullscreen, so our
// framebuffer graphics will not be overwritten by X server - otherwise
// we had to shutdown X server).
//
//////////////////////////////////////////////////////////////////////////
// setup display, screen and window
Display *display = XOpenDisplay (getenv ("DISPLAY"));
if (display == NULL)
{
fprintf (stderr, "cannot open X display\n");
exit (1);
}
int screen_num = DefaultScreen (display);
Window win = XCreateSimpleWindow(display,
RootWindow (display, screen_num),
0,
0,
720,
420,
0,
WhitePixel (display, screen_num),
BlackPixel (display, screen_num));
XMapWindow (display, win);
XSelectInput (display, win, ExposureMask);
XFlush (display);
XEvent xev;
XWindowEvent (display, win, ExposureMask, &xev);
// bring window to fullscreen
xev.xclient.type = ClientMessage;
xev.xclient.serial = 0;
xev.xclient.send_event = True;
xev.xclient.message_type = XInternAtom (display, "_NET_WM_STATE", False);
xev.xclient.window = win;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = XInternAtom (display,
"_NET_WM_STATE_FULLSCREEN", False);
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;
if (!XSendEvent (display,
DefaultRootWindow (display),
False,
SubstructureRedirectMask | SubstructureNotifyMask,
&xev))
{
fprintf (stderr, "cannot bring X window to fullscreen\n");
exit (1);
}
XSync(display, False);
//////////////////////////////////////////////////////////////////////////
//
// setup framebuffer stuff
//
//////////////////////////////////////////////////////////////////////////
// open framebuffer device
int fbfd = open("/dev/fb0", O_RDWR);
if (!fbfd)
{
fprintf (stderr, "cannot open framebuffer device\n");
exit (1);
}
// screen size
size_t ssize = HRES * BPP / 8 * VRES;
// map framebuffer
char* fbp = (char*) mmap (0, ssize, PROT_READ | PROT_WRITE,
MAP_SHARED, fbfd, 0);
if ((int) fbp == -1)
{
fprintf (stderr, "failed to memory map framebuffer\n");
exit (1);
}
// setup fullscreen update info struct
struct omapfb_update_window update;
// copy full screen from fb to lcd video ram
update.x = 0;
update.y = 0;
update.width = HRES;
update.height = VRES;
// request native pixel format, tearsync and vsync
update.format = OMAPFB_COLOR_RGB565 | OMAPFB_FORMAT_FLAG_TEARSYNC |
OMAPFB_FORMAT_FLAG_FORCE_VSYNC;
//////////////////////////////////////////////////////////////////////////
//
// render loop
//
//////////////////////////////////////////////////////////////////////////
int n;
for (n = 0; n < LOOPN; ++n)
{
// wait for fb->lcd video ram transfer complete
ioctl (fbfd, OMAPFB_SYNC_GFX);
// "render" whole frame in single color
memset (fbp, n, ssize);
// wait for vsync
ioctl (fbfd, OMAPFB_VSYNC);
// request transfer of fb-> lcd video ram for whole screen
ioctl (fbfd, OMAPFB_UPDATE_WINDOW, &update);
}
//////////////////////////////////////////////////////////////////////////
//
// cleanup
//
//////////////////////////////////////////////////////////////////////////
// cleanup framebuffer stuff
munmap (fbp, ssize);
close (fbfd);
// cleanup X stuff
if (display)
{
XCloseDisplay (display);
display = NULL;
}
// finished
return 0;
}
===
_______________________________________________
maemo-developers mailing list
maemo-developers@maemo.org
https://lists.maemo.org/mailman/listinfo/maemo-developers
