From http://www.jwz.org/xscreensaver/xscreensaver-5.30.tar.gz
[xscreensaver] / hacks / fps.c
1 /* fps, Copyright (c) 2001-2011 Jamie Zawinski <jwz@jwz.org>
2  * Draw a frames-per-second display (Xlib and OpenGL).
3  *
4  * Permission to use, copy, modify, distribute, and sell this software and its
5  * documentation for any purpose is hereby granted without fee, provided that
6  * the above copyright notice appear in all copies and that both that
7  * copyright notice and this permission notice appear in supporting
8  * documentation.  No representations are made about the suitability of this
9  * software for any purpose.  It is provided "as is" without express or 
10  * implied warranty.
11  */
12
13 #ifdef HAVE_CONFIG_H
14 # include "config.h"
15 #endif /* HAVE_CONFIG_H */
16
17 #include "screenhackI.h"
18 #include "fpsI.h"
19
20 fps_state *
21 fps_init (Display *dpy, Window window)
22 {
23   fps_state *st;
24   const char *font;
25   XFontStruct *f;
26
27   if (! get_boolean_resource (dpy, "doFPS", "DoFPS"))
28     return 0;
29
30   st = (fps_state *) calloc (1, sizeof(*st));
31
32   st->dpy = dpy;
33   st->window = window;
34   st->clear_p = get_boolean_resource (dpy, "fpsSolid", "FPSSolid");
35
36   font = get_string_resource (dpy, "fpsFont", "Font");
37
38   if (!font) font = "-*-courier-bold-r-normal-*-180-*";
39   f = XLoadQueryFont (dpy, font);
40   if (!f) f = XLoadQueryFont (dpy, "fixed");
41
42   {
43     XWindowAttributes xgwa;
44     XGCValues gcv;
45     XGetWindowAttributes (dpy, window, &xgwa);
46     gcv.font = f->fid;
47     gcv.foreground = 
48       get_pixel_resource (st->dpy, xgwa.colormap, "foreground", "Foreground");
49     st->draw_gc = XCreateGC (dpy, window, GCFont|GCForeground, &gcv);
50     gcv.foreground =
51       get_pixel_resource (st->dpy, xgwa.colormap, "background", "Background");
52     st->erase_gc = XCreateGC (dpy, window, GCFont|GCForeground, &gcv);
53   }
54
55   st->font = f;
56   st->x = 10;
57   st->y = 10;
58   if (get_boolean_resource (dpy, "fpsTop", "FPSTop"))
59     /* don't leave a blank line in GL top-fps. */
60     st->y = - (/*st->font->ascent +*/ st->font->descent + 10);
61
62   strcpy (st->string, "FPS: ... ");
63
64   return st;
65 }
66
67 void
68 fps_free (fps_state *st)
69 {
70   if (st->draw_gc)  XFreeGC (st->dpy, st->draw_gc);
71   if (st->erase_gc) XFreeGC (st->dpy, st->erase_gc);
72   if (st->font) XFreeFont (st->dpy, st->font);
73   free (st);
74 }
75
76
77 void
78 fps_slept (fps_state *st, unsigned long usecs)
79 {
80   st->slept += usecs;
81 }
82
83
84 double
85 fps_compute (fps_state *st, unsigned long polys, double depth)
86 {
87   if (! st) return 0;  /* too early? */
88
89   /* Every N frames (where N is approximately one second's worth of frames)
90      check the wall clock.  We do this because checking the wall clock is
91      a slow operation.
92    */
93   if (st->frame_count++ >= st->last_ifps)
94     {
95 # ifdef GETTIMEOFDAY_TWO_ARGS
96       struct timezone tzp;
97       gettimeofday(&st->this_frame_end, &tzp);
98 # else
99       gettimeofday(&st->this_frame_end);
100 # endif
101
102       if (st->prev_frame_end.tv_sec == 0)
103         st->prev_frame_end = st->this_frame_end;
104     }
105
106   /* If we've probed the wall-clock time, regenerate the string.
107    */
108   if (st->this_frame_end.tv_sec != st->prev_frame_end.tv_sec)
109     {
110       double uprev_frame_end = (st->prev_frame_end.tv_sec +
111                                 ((double) st->prev_frame_end.tv_usec
112                                  * 0.000001));
113       double uthis_frame_end = (st->this_frame_end.tv_sec +
114                                 ((double) st->this_frame_end.tv_usec
115                                  * 0.000001));
116       double fps = st->frame_count / (uthis_frame_end - uprev_frame_end);
117       double idle = (((double) st->slept * 0.000001) /
118                      (uthis_frame_end - uprev_frame_end));
119       double load = 100 * (1 - idle);
120
121       if (load < 0) load = 0;  /* well that's obviously nonsense... */
122
123       st->prev_frame_end = st->this_frame_end;
124       st->frame_count = 0;
125       st->slept       = 0;
126       st->last_ifps   = fps;
127       st->last_fps    = fps;
128
129       sprintf (st->string, (polys 
130                             ? "FPS:   %.1f \nLoad:  %.1f%% "
131                             : "FPS:  %.1f \nLoad: %.1f%% "),
132                fps, load);
133
134       if (polys > 0)
135         {
136           const char *s = "";
137 # if 0
138           if      (polys >= (1024 * 1024)) polys >>= 20, s = "M";
139           else if (polys >= 2048)          polys >>= 10, s = "K";
140 # endif
141
142           strcat (st->string, "\nPolys: ");
143           if (polys >= 1000000)
144             sprintf (st->string + strlen(st->string), "%lu,%03lu,%03lu%s ",
145                      (polys / 1000000), ((polys / 1000) % 1000),
146                      (polys % 1000), s);
147           else if (polys >= 1000)
148             sprintf (st->string + strlen(st->string), "%lu,%03lu%s ",
149                      (polys / 1000), (polys % 1000), s);
150           else
151             sprintf (st->string + strlen(st->string), "%lu%s ", polys, s);
152         }
153
154       if (depth >= 0.0)
155         {
156           unsigned long L = strlen (st->string);
157           char *s = st->string + L;
158           strcat (s, "\nDepth: ");
159           sprintf (s + strlen(s), "%.1f", depth);
160           L = strlen (s);
161           /* Remove trailing ".0" in case depth is not a fraction. */
162           if (s[L-2] == '.' && s[L-1] == '0')
163             s[L-2] = 0;
164         }
165     }
166
167   return st->last_fps;
168 }
169
170
171
172 /* Width (and optionally height) of the string in pixels.
173  */
174 static int
175 string_width (XFontStruct *f, const char *c, int *height_ret)
176 {
177   int x = 0;
178   int max_w = 0;
179   int h = f->ascent + f->descent;
180   while (*c)
181     {
182       int cc = *((unsigned char *) c);
183       if (*c == '\n')
184         {
185           if (x > max_w) max_w = x;
186           x = 0;
187           h += f->ascent + f->descent;
188         }
189       else
190         x += (f->per_char
191               ? f->per_char[cc-f->min_char_or_byte2].width
192               : f->min_bounds.rbearing);
193       c++;
194     }
195   if (x > max_w) max_w = x;
196   if (height_ret) *height_ret = h;
197
198   return max_w;
199 }
200
201
202 /* This function is used only in Xlib mode.  For GL mode, see glx/fps-gl.c.
203  */
204 void
205 fps_draw (fps_state *st)
206 {
207   XWindowAttributes xgwa;
208   const char *string = st->string;
209   const char *s;
210   int x = st->x;
211   int y = st->y;
212   int lines = 1;
213   int lh = st->font->ascent + st->font->descent;
214
215   XGetWindowAttributes (st->dpy, st->window, &xgwa);
216
217   for (s = string; *s; s++) 
218     if (*s == '\n') lines++;
219
220   if (y < 0)
221     y = -y + (lines-1) * lh;
222   else
223     y = xgwa.height - y;
224
225   y -= lh * (lines-1) + st->font->descent;
226
227   /* clear the background */
228   if (st->clear_p)
229     {
230       int w, h;
231       w = string_width (st->font, string, &h);
232       XFillRectangle (st->dpy, st->window, st->erase_gc,
233                       x - st->font->descent,
234                       y - lh,
235                       w + 2*st->font->descent,
236                       h + 2*st->font->descent);
237     }
238
239   /* draw the text */
240   while (lines)
241     {
242       s = strchr (string, '\n');
243       if (! s) s = string + strlen(string);
244       XDrawString (st->dpy, st->window, st->draw_gc,
245                    x, y, string, (int) (s - string));
246       string = s;
247       string++;
248       lines--;
249       y += lh;
250     }
251 }