FOR SCREENSAVER:
-* use [Un]Inhibit together as a SimulateUserActivity workalike
- * disablegss.py from http://ubuntuforums.org/showthread.php?t=284804
- * this method doesn't work either. tried in gss-poke.py
-* xdg-screensaver suspend / resume to SimulateUserActivity
- * http://tronche.com/gui/x/xlib-tutorial/2nd-program-anatomy.html
- * http://portland.freedesktop.org/xdg-utils-1.0beta3/xdg-screensaver.html
-* SimulateUserActivity
- * does it work on other people's machines?
- * find if other people have their gnome-screensaver run even if they set
- screensaver timeout to 1 minute and run:
- for ((i = 0; i < 999; i++)); do
- sleep 50;
- gnome-screensaver-command --poke;
- done;
+* gnome-screensaver-command --poke
* find irc channel to ask if my understanding is correct
* file bug
* track down bug
* no display window
* no text printed to terminal
* fire up the face detector only just before going to inactive mode.
+ * possibly this is how kreed's version works. read kreed's code to find out
* that way the camera isn't running all the time
- * maybe start 10 seconds before going inactive, then run until activity
+ * maybe start 10 seconds before going inactive, then run until activity, or 10
+ seconds, whichever's first.
* be more aggressive with turning off the screen. dim the screen as soon as
it's not being looked at. turn it off soon thereafter.
* could be enough to save battery. would need to power the camera sometimes,
- but would save on backlight. need to test.
+ but would save on backlight. need to profile.
* don't prevent sleep when face is detected, but user isn't actually looking at
screen.
* requires pose estimation.
--- /dev/null
+/*
+ * Copyright © 2009 Christopher Eby <kreed@kreed.org>
+ *
+ * This file is part of Inertia.
+ *
+ * Inertia is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * Inertia is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * See <http://www.gnu.org/licenses/> for the full license text.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/sync.h>
+#include <X11/extensions/scrnsaver.h>
+
+static Display *dpy = NULL;
+
+static void get_alarm(XSyncAlarm *alarm, XSyncCounter counter, XSyncTestType type, XSyncValue value)
+{
+ XSyncAlarmAttributes attrs;
+
+ XSyncValue delta;
+ XSyncIntToValue(&delta, 0);
+
+ static const unsigned long flags = XSyncCACounter | XSyncCATestType | XSyncCAValue | XSyncCADelta;
+
+ attrs.trigger.counter = counter;
+ attrs.trigger.test_type = type;
+ attrs.trigger.wait_value = value;
+ attrs.delta = delta;
+
+ if (*alarm)
+ XSyncChangeAlarm(dpy, *alarm, flags, &attrs);
+ else
+ *alarm = XSyncCreateAlarm(dpy, flags, &attrs);
+}
+
+static void die(const char *errstr)
+{
+ fputs(errstr, stderr);
+ fflush(stderr);
+ exit(EXIT_FAILURE);
+}
+
+bool wait_for_idle_time(int idle_time)
+{
+ static int xsync_event_base;
+ static XSyncAlarm idle_alarm = None;
+ static XSyncAlarm reset_alarm = None;
+ static XSyncCounter idle = None;
+ static XSyncValue idle_timeout;
+
+ if (idle == None) {
+ if (!(dpy = XOpenDisplay(NULL)))
+ die("Could not open X11 display; exiting.\n");
+
+ int dummy;
+ if (!XQueryExtension(dpy, "XTEST", &dummy, &dummy, &dummy))
+ die("XTEST extension not available; cannot reset idle time\n");
+
+ int xsync_error_base;
+ int xsync_major = SYNC_MAJOR_VERSION;
+ int xsync_minor = SYNC_MINOR_VERSION;
+
+ if (!XSyncQueryExtension(dpy, &xsync_event_base, &xsync_error_base) || !XSyncInitialize(dpy, &xsync_major, &xsync_minor))
+ die("No XSync extension; exiting.\n");
+
+ int i;
+ XSyncSystemCounter *counters = XSyncListSystemCounters(dpy, &i);
+ while (i--)
+ if (!strcmp(counters[i].name, "IDLETIME"))
+ idle = counters[i].counter;
+ XSyncFreeSystemCounterList(counters);
+
+ if (idle == None)
+ die("No IDLETIME counter! xorg-server 1.3 and higher should support it. Exiting.\n");
+
+ XSyncIntToValue(&idle_timeout, idle_time * 1000);
+ get_alarm(&idle_alarm, idle, XSyncPositiveComparison, idle_timeout);
+ }
+
+ XEvent ev;
+
+ while (!XNextEvent(dpy, &ev)) {
+ if (ev.type == xsync_event_base + XSyncAlarmNotify) {
+ XSyncAlarmNotifyEvent *e = (XSyncAlarmNotifyEvent*)&ev;
+
+ if (e->alarm == idle_alarm) {
+ int overflow;
+ XSyncValue reset_timeout;
+ XSyncValue minus_one;
+
+ XSyncIntToValue(&minus_one, -1);
+ XSyncValueAdd(&reset_timeout, e->counter_value, minus_one, &overflow);
+ get_alarm(&reset_alarm, idle, XSyncNegativeComparison, reset_timeout);
+
+ return true;
+ } else if (e->alarm == reset_alarm) {
+ get_alarm(&idle_alarm, idle, XSyncPositiveComparison, idle_timeout);
+ }
+ }
+ }
+
+ return false;
+}
+
+void reset_idle_time()
+{
+ if (!dpy) {
+ if (!(dpy = XOpenDisplay(NULL))) {
+ fputs("Could not open X11 display.\n", stderr);
+ return;
+ }
+ }
+
+ XScreenSaverSuspend(dpy, True);
+ XSync(dpy, False);
+ XScreenSaverSuspend(dpy, False);
+ XSync(dpy, False);
+}
#include <iostream>
#include <time.h>
#include "oble.h"
+#include "idle_x11.h"
using namespace std;
// argument for cvFlip(src, dest, FLIP_TYPE)
#define MIRROR 1
+#define DEBUG 0
+
CvHaarClassifierCascade* load_object_detector(const char* cascade_path)
{
return (CvHaarClassifierCascade*)cvLoad(cascade_path);
CvMemStorage* storage = cvCreateMemStorage(0);
CvSeq* faces;
int i, scale = 1;
+ static int saw_last_time = 0;
/* if the flag is specified, down-scale the input image to get a
performance boost w/o loosing quality (perhaps) */
if(0 < faces->total)
{
t_current = time(NULL);
- //system("./gss-poke.py");
+ if(DEBUG)
+ {
+ printf(":) face \n");
+ }
+ if(saw_last_time)
+ {
+ if(DEBUG)printf("\t\tpoking\n");
+ reset_idle_time();
+ system("gnome-screensaver-command --poke");
+ }
+ saw_last_time = 1;
+ }
+ else
+ {
+ saw_last_time = 0;
+ if(DEBUG)
+ {
+ printf(":( no face \n");
+ }
}
/* draw all the rectangles */
if(elapse > timeout && elapse != last_elapse)
{
last_elapse = elapse;
- printf("elapse = %d\n", elapse);
+ if(DEBUG)
+ {
+ printf("elapse = %d\n", elapse);
+ }
if(!activated)
{
printf("activated\n");
detect_and_draw_objects(mirrored, cascade, 1);
cvShowImage("mywindow", mirrored);
// Do not release the frame!
- screensave(t_current);
+ //screensave(t_current);
//If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
//remove higher bits using AND operator
projects / ozzloy@gmail.com / oble / commitdiff