To produce a dvd out of a mpeg-ts file we need:

• Project-X: Cut and demux videos
• mplex from the MJPEG Tools: Remux videos
• dvdauthor: create a video-dvd file structure
• growisofs from the DVD+RW package: Create an iso image or burn directly to disk

In Ubuntu you can install them by typing:

sudo apt-get install project-x dvdauthor mjpegtools growisofs

Dvdauthor demands to know the video format, so type

echo "PAL" > ~/.config/video_format

(replace PAL with NTSC if living in the USA or another NTSC-country)

Now you should have everything you need. Copy the makefile to the same folder you downloaded the ts-file(assuming, for simplicity, it’s named sample.ts) to. Now, to just burn it to dvd, one title, no menu, conserving all audio tracks, do

make sample.burn

The advantage of using a Makefile is that you can do each step manually. You can for example cut and demux the files with project-x by hand, or just produce the .mpg files, then use dvdstyler to create a complex menu and burn the dvd.

all:$(patsubst %.ts,%.dvd,$(wildcard *.ts))

MPLEX=mplex
MPLEXFLAGS=-f 8
DVDAUTHOR=dvdauthor
PROJECTX=projectx

DREAMBOX_BASEURL=root:dreambox@192.168.178.22/hdd/movie
.PRECIOUS: %.m2v %.ts %.mpg %.dvd

%.ts:
	wget ftp://$(DREAMBOX_BASEURL)/$@

%_proc.m2v: %.ts
	$(PROJECTX) -out . -name $*_proc $<

%.mpg: %_proc.m2v
	-rm $*_proc*.txt
	$(MPLEX) $(MPLEXFLAGS) -o $@ $*_proc*
	-rm $*_proc*

%.xml: %.mpg
	echo "<dvdauthor><vmgm /><titleset><titles><pgc><vob file=\"$<\" /></pgc></titles></titleset></dvdauthor>" > $*.xml

%.dvd: %.xml
	$(DVDAUTHOR) -x $*.xml -o $@ 

%.burn: %.dvd
	growisofs -Z /dev/dvd -dvd-video -V $* $</

Makefile-movies

There were other problems: readesm was using custom Makefiles, which apparently made compiling the source difficult. I was amazed to discover this wiki entry for fahrlinx, which contained information on how to install the windows version of readesm using wine. As the windows version at that time was cross-compiled in linux and lacked some features, readesm was clearly too difficult to compile.

In readesm versions since march 2011, both problems are solved. Readesm now uses cmake for the build process, and Qt to display the generated html pages in a webkit browser.

Idea

The idea behind readesm is to show you exactly what is in the tachograph file.

Using readesm

Usually you will either associate readesm with a file extension, and have your file manager open readesm for you. Or you can open a file from readesm’s menu.
Alternatively you can use the command line:

readesm tachofile.ddd

will open the file in the gui, and

readesm tachofile.ddd tachofile.html

will convert the file into html format and save it as tachofile.html.

Screenshots

Free software toolchain for tachographs

With readesm, fahrlinx and loadvu, a linux laptop can now connect to vehicle units, read out driver cards and visualize the contents of the files.

To install all three programs in ubuntu:

sudo apt-add-repository ppa:k-2005
sudo apt-get update
sudo apt-get install readesm fahrlinx loadvu

It’s a bit more difficult in Windows, but should be possible nevertheless.

Download readesm

Download the latest files from the project page at sourceforge.

• Use the windows-installer (readesm-XX-win32.exe) to install. The latest version should also associate tachograph files with itself.
• If you cannot or do not want to install readesm, use readesm-XX-win32.zip
• Ubuntu users should either use my ppa or compile from source.
• Users of 64 bit windows might be able to run the 32 bit windows version. Unfortunately, I do not have access to a single 64 bit windows pc.
• For other operating systems, download one of the source packages and compile it yourself.

Without dedicated hardware, this was so far not easily possible in linux, but my python script should make it possible to download the data with a serial cable with the right connector.

Ubuntu package

Ubuntu packages are available in my ppa. You can add my ppa with

sudo apt-add-repository ppa:k-2005

and then install loadVu with

sudo apt-get install loadvu

Usage

Start the program with

./loadvu

The data will be saved to a file named after the vehicle and date.
If your serial connection is not /dev/ttyUSB0, you should specify it with the –serial parameter. A possible call would be

./loadvu --serial /dev/ttyUSB1

Extra transfer response parameters

While the commision regulation 1360/2002 defines TREPs 1 to 6

At least the digital tachographs from Siemens VDO return data on other requests, too. For example Daimler’s TCO-DKG program requests 17,19 and 20 and saves those to an .add file. The vu also returns data requesting trtp 18. To mimic the behaviour of tco-dkg, type

./loadvu --treps 2,3,4,5 -o mycar.esm
./loadvu --treps 17,19,20 -o mycar.add

Download of card data

It is possible to download the data stored in a driver card inserted into the vehicle unit. However, in the current version the script will add vehicle data to the file, so few programs will be able to read it. The current svn of readesm can, but the last release cannot.

./loadvu --treps 6 -o card.esm

Future versions might handle this with more elegance.

Download Speed

With a digital tachograph from 2007, loadvu tells:

$ ./loadvu
Sending 'Request Start Communication Request'
Got the expected response
Sending 'Request Diagnostic Session'
Got the expected response
Sending 'Request Request Byte rate 115200'
Got the expected response
[...]
Sending 'Request Stop Communication'
Got the expected response
data saved to UL-XX YYY 2010-11-09 to 2011-11-18 21.54 (CET).esm
Got 222772 Byte in 1789.75275612 seconds. (124.470823827 Byte/s)

It’s slow. Really slow. Considering how many trucks there are, also expensively slow. And it’s not just this script, it’s that slow with any program. Why? Hard to tell. The transfer is slowest when transferring daily activities, where many cryptographic signatures are transferred. However, there is no technical reason why these would have to be generated at every download, as the data really should not change once written.

Enjoy the script.

loadvu-2011.11.tar.gz

For these cases I found this little bash snippet useful:

ls -tr | tail -n 1 | xargs -I FILE kde-open "FILE"

Instead of kde-open, which opens any file with the associated program, you can use any program, gnome-users might want gnome-open, people with other window managers can use xdg-open from xdg-utils. Or you can just insert mplayer, if you are only interested in music and videos.

I prefer it installed somewhere in the path, and then one can add a command-line parameter, the number of files to be played:

#!/bin/sh
ls -tr | tail -n ${1:-1} | xargs -I FF kde-open "FF"

playlast

ytplay wraps around youtube-dl.py, it searches for a video, orders youtube-dl to get it, and starts playing it in vlc.

Usage is simple:
> ytplay foobar
will search youtube for videos about foobar and play the first one found.

The code is still quite dirty, especially the subprocess part. However, it should work, have fun!

#!/usr/bin/python
# -*- coding: utf-8 -*-
#		parser.add_option('-P', '--play', action='store_true',
#				dest='play', help='play in vlc', default=False)

from optparse import OptionParser
from subprocess import Popen, PIPE
from urllib2 import urlopen 
from urllib import quote_plus
from re import search, match
from os import system

parser = OptionParser(version='2010.02.13')

parser.add_option('-p', '--player',
dest='player', metavar='PROGRAM', help='media player to use', default='vlc')

(opts, args) = parser.parse_args()

if match("http://",args[0]):
	videopageurl = args[0]
else:
	searchargs = '+'.join(args)
	searchurl = "http://www.youtube.com/results?search_type=&aq=f&oq=&search_query=" + quote_plus(searchargs)
	searchresult = urlopen(searchurl).read()
	p=search(r'(watch\?[^"]*)',searchresult)
	if p==None:
		print "No Videos found"
		exit()
	videopageurl="http://www.youtube.com/" + p.group(1)
	

print "Starting youtube-dl for " + videopageurl
ytdl = Popen("youtube-dl.py -t -b " + videopageurl,shell=True,stdout=PIPE)

while not ytdl.stdout.closed:
	line = ytdl.stdout.readline()
	print line,
	if line == '': exit()
	p = search(r'\[download\] Destination: (\S*)',line)
	if p != None:
		print "Starting player: " + opts.player + " " + p.group(1)
		system(opts.player + " " + p.group(1) + " &")

ytplay

And that is basically everything to say, enjoy the little applet.

Installation

Make sure gpsd is installed and set up properly. Also make sure the python bindings are installed.
In Ubuntu you would need to:

sudo apt-get install gpsd python-gps
sudo dpkg-reconfigure gpsd
sudo apt-get install python-plasma python-dev

After those are installed, you can proceed to install the plasmoid with plasmapkg -i.

Problems and TODOs

This is all rather dirty and bloated. The correct way to do it would probably be to write a data engine for plasma, which would provide the positional data. Maybe someone will do it, especially if Marble will one day be able to support overlays integrate GeoClue or something similar.

Right now the data travels from the GPS device to the PC in the form of NMEA sentences, gets then converted into gpsd’s own format, python-gps connects to gpsd over TCP port 2947, interprets the gpsd output, hands it over to the applet, which reformats the data yet again. For something so useless that just wastes too many CPU cycles. Interpreting GPS data entirely in python is not hard, but still a bit harder than with gpsd, especially if one wants to cover a lot of GPS devices. Don’t get me wrong, gpsd does its job quite well, it is just a bit overkill for this task.

Another improvement would be readable coordinates. Something like “10 km northwest of Zürich” or even “200 meters south of Sternen Oerlikon, Zürich” would really be much more useful.

Update February 2010: Version 0.16 now uses KDE’s geolocation data engine. This drops the (direct) dependency on gpsd, and allows for ip-based location – unfortunately i now can no longer get my gps to work with it, hoping for kubuntu lucid.

gps-plasmoid_0.16.plasmoid

gps-plasmoid_0.15.plasmoid

Update, March 2011: There is a new release of readesm, The description provided here no longer applies, the new readesm uses Qt and cmake. You can get the new release at the sourceforge project page and read the documentation here.

For several years now, new trucks sold in the European union are equipped with digital tachographs, that record the driving times and replace the older chart-based mechanical tachographs.

For companies in road transport that means, although in theory they get nice data about their drivers and vehicles, in practice they have to pay a lot of money for the digital tachograph and the associated equipment, which is then used against them – the old fraud schemes no longer work, the machine cruelly gives every police officer the driving times of the last 28 days (and could give much more).

The usability of the devices I’m familiar with is also abysmal. It just takes forever to read out the data (9600 baud per default, 115000 baud maximal, but i guess the company’s software does just the former), and the drivers have to keep track of their times manually – just not up to par with 2009 technology.

The company also had just a very bad software for analyzing the data recorded by the card and the digital tachograph, so I was asked to write a simple visualization program.

Compiling

You can get the program files from this page, or from the development page at Sourceforge.
Since so far there is no binary distribution for the program, you will have to compile it yourself.
To do that, you need a c++ compiler, parts of the boost library (specifically program_options and shared_ptr) and the Gnu MP library, wich is used to check the various RSA signatures. Once all those are installed, typing make/make install should work fine. On Ubuntu systems, you will need to do something like:

svn co https://readesm.svn.sourceforge.net/svnroot/readesm readesm
sudo apt-get install libboost-program-options-dev libgmpxx4ldbl  libgmp3-dev
make
sudo make install

You can of course also use checkinstall instead of make install, or type make package, which invokes checkinstall.

Running the program

In most circumstances, you will run the program from the commandline like this:

readesm --infile foo.esm --outfile bar.html --format=html

Alternatively, if no output file is specified, stdout is used. For KDE users, i wrote a little wrapper script named readesm-wrap-kde.sh. It will get installed my typing make install

Security

It is a really pleasant surprise to see a nice security model in the digital tachographs, considering the rules for the security implementations were made by politicians. Both cards and vehicle units work with 1024-bit RSA keys, and each vehicle unit has its own key, with an certificate signed by the member state, which in turn is signed by an European master key. Data is hashed with SHA-1, subsequently padded and signed by the vehicle unit, and that signature appended to the readouts. The law even states that the companies have to store the data in this signed form, so there is little chance to tamper with the data, once recorded.

Since the most likely attacker – the evil manager who wants to exploit the drivers – has physical access to the card and vehicle unit, which contain the private keys, even 1024-bit RSA provides no absolute security. The manager could try a timing attack, or take a really close look at the storage, both times avoiding having to solve the RSA problem.

The connection from tachograph to sensor is also secured, using Triple-DES. The week point here is the sensor – a successful attack against the sensors some DAF trucks are equipped with is to disturb it using strong permanent magnets, thereby preventing it from recognizing the changing magnetic fields.

All possible attacks against the security system however face the problem of being unveiled by police checkpoints or a cross-correlation of the faked data with data from other sources, for example the toll systems recording every few highway kilometers in Germany.

error, cannot open image photos/screenshots/readesm/2011.11.

readesm.tar.bz2

Usage

• Start the Program, add a parameter for the port your nmea device is attached to (/dev/ttyUSB0 is the default
• Start google earth or something, load the generated kml file (/tmp/posdate by default)
• Exit the program by pressing ctrl-c, track data will be written to /tmp/track-some time.gpx

Guess I should code something with extra geek value now.
It might be comfortable to have google earth automatically reload the file, so instead open sth. like

1
2
3
4
5
6
7
8
9
10
11
12

<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.1">
<NetworkLink>
	<name>GPS</name>
	<flyToView>1</flyToView>
	<Url>
		<href>/tmp/posdata.kml</href>
		<refreshMode>onInterval</refreshMode>
		<refreshInterval>10</refreshInterval>
	</Url>
</NetworkLink>
</kml>

#!/usr/bin/python
"""
Script to read nmea data from a GPS mouse
Copyright (C) 2008  Andreas Goelzer
 
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
This program 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 the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
This program reads data from a nmea device (uses the GGA sentence),
and creates a google kml file with the current position and the path
leading there. Additionally, a gpx file is generated containing the
track data with time information.
"""

from serial import Serial;
from time import strftime, gmtime;
from optparse import OptionParser;


hist = "";
gpx = "";

kmlmask="""<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://earth.google.com/kml/2.0">
<Document>
	<Placemark>
		<name>Your Position</name>
		<Point>
			<coordinates>%s</coordinates>
		</Point>
	</Placemark>
	<Placemark>
		<name>Previous positions</name>
		<description>Path that lead you here</description>
		<LineString>
			<coordinates>%s</coordinates>
		</LineString>
	</Placemark>
</Document>
</kml>"""
#			<altitudeMode>absolute</altitudeMode>

gpxmask = """<?xml version="1.0" encoding="UTF-8" standalone="no" ?><gpx xmlns="http://www.topografix.com/GPX/1/1" xmlns:gpxx="http://www.garmin.com/xmlschemas/GpxExtensions/v3" xmlns:gpxtpx="http://www.garmin.com/xmlschemas/TrackPointExtension/v1" creator="Colorado 300" version="1.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd http://www.garmin.com/xmlschemas/GpxExtensions/v3 http://www.garmin.com/xmlschemas/GpxExtensions/v3/GpxExtensionsv3.xsd http://www.garmin.com/xmlschemas/TrackPointExtension/v1 http://www.garmin.com/xmlschemas/TrackPointExtension/v1/TrackPointExtensionv1.xsd">
<trk><name>%s</name><trkseg>%s</trkseg></trk></gpx>"""

def gpstime():
	return strftime("%Y-%m-%dT%H:%M:%SZ",gmtime());

def readlatlon(value,inverse):
	lat = float(value);
	lat2 = int(lat) / 100;
	lat = lat2 + (lat - 100 * lat2)/ 60; 
	if inverse:
		lat = -lat;
	return lat;

def calcchecksum(checkstr):
	cs = ord(checkstr[0]);
	for i in range(1,len(checkstr)):
		cs ^= ord(checkstr[i])
	return cs;


class sentencevalidator:
	"Check checksum and other stuff and split to fields"
	def __init__(self,line):
		if(line[0] == '$' and line[-5] == '*' and calcchecksum(line[1:-5]) ==  int(line[-4:-2],16)):
			self.valid = True;
			self.sentence = line[3:6];
			self.data = line[7:-5].split(',');
		else :
			self.valid = False;

parser = OptionParser(version="%prog 0.1");
parser.add_option("-s", "--serial", dest="serial",
                  help="serial terminal of the gps unit", default='/dev/ttyUSB0', metavar="FILE");
parser.add_option("-g", "--gpxfile", dest="gpxfile",
                  help="GPX output file", default="/tmp/track" + gpstime() + ".gpx", metavar="FILE");
parser.add_option("-k", "--kmlfile", dest="kmlfile",
                  help="KML output file", default="/tmp/posdata.kml", metavar="FILE");
parser.add_option("-v", "--verbose",
                  action="store_true", dest="verbose", default=False,
                  help="print debug messages");
 
(options, args) = parser.parse_args();

gps = Serial(options.serial, 4800, timeout=1);


#on sirf chips, activate all sentences
for i in range(1,5):
	cmd = "PSRF103,0%d,00,05,01" % i;
	realcmd="$%s*%x\r\n" % (cmd,calcchecksum(cmd));
	print realcmd;
	gps.write(realcmd)

try:
	while 1:
		line = gps.readline()
		if(options.verbose): print line,
		s = sentencevalidator(line);
		if(s.valid and s.sentence == "GGA" and int(s.data[5]) != 0):
			lat = readlatlon(s.data[1],s.data[2]=='S');
			lon = readlatlon(s.data[3],s.data[4]=='W');
			alt = float(s.data[8]);
				
			gpx += "\n" + '<trkpt lat="%f" lon="%f"><ele>%f</ele><time>%s</time></trkpt>' % (lon,lat,alt,gpstime())
			
			position =  "%f, %f, %f" % (lon,lat,alt);
			print position
			hist += "\n" + position;
			f=open("/tmp/posdata.kml",'w');
			f.write(kmlmask % (position,hist));
			f.close();

except:
	0

f=open(options.gpxfile,'w');
f.write(gpxmask % (gpstime(),gpx));
f.close();

gps.close()

readgps.py

After reading about the amazing 5-seconds bootup I decided to once again compile a kernel myself. Compiling a kernel is almost trivial these days, but customizing the configuration can still be quite confusing. For example, the names of the modules in lsmod aren’t the ones you select as config options. To map them, I found some scripts in the LQWiki, but they weren’t that easily to use, and also programming in bash is just painful.

So i wrote a python variant, that takes an input config(for example your distributions config) and changes the reply to “y” for all config options if the respective module is loaded(ie. if ext3 is loaded, CONFIG_EXT3_FS=y will be set).

In almost all cases you still want to tweak the resulting config file with make menuconfig. Also keep in mind that some things don’t work that easily if compiled in, for example if firmware has to be loaded from a file, the disk should be accessible.

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Script to modify kernel config based on lsmod output
Copyright (C) 2008  Andreas Goelzer
 
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
This program 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 the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
Based on a previous config and the output of lsmod, this script determines
which modules could be compiled in and generates a new config.
See http://andreas.goelzer.de/kernel-config-based-on-lsmod-output for updates
"""

import re;
from optparse import OptionParser;
from os import popen;
from sys import stderr, stdout, stdin;

parser = OptionParser(version="%prog 0.31");
parser.add_option("-i", "--infile", dest="cfgfile",
                  help="input config file", default=".config", metavar="FILE");
parser.add_option("-o", "--outfile", dest="outfile",
                  help="output config file", default="-", metavar="FILE");
parser.add_option("-l", "--logfile", dest="logfile",
                  help="file to log errors to", default="-", metavar="FILE");
parser.add_option("-s", "--sourcedir", dest="sourcedir",
                  help="kernel source tree", default=".", metavar="DIR");
#parser.add_option("-v", "--verbose",
                  #action="store_true", dest="verbose", default=False,
                  #help="print debug messages");

(options, args) = parser.parse_args();
if(options.outfile == '-'): of = stdout;
else: of = open(options.outfile, 'w');
if(options.logfile != '-'): stderr = open(options.logfile, 'w');


loadedmods=popen('lsmod | tail -n+2').readlines();
getmodname=re.compile(r"^(?P<modname>\w*)");

#prob. need to replace kernel with sth. like (kernel|ubuntu) for an ubuntu kernel source
parsepath=re.compile(r"/kernel(?P<path>/.*/)(?P<file>.*).ko")

wantin=[];
for module in loadedmods:
	modname = re.search(getmodname,module).group('modname');
	moduleprops=re.search(parsepath,popen('modinfo -n ' + modname).read());
	if(moduleprops):
		#search the makefile for the module name
		try:
			f=open(options.sourcedir + moduleprops.group('path') + 'Makefile' , 'r');
		except IOError:
			stderr.write('Could not find Makefile for ' + modname + '\n');
			continue
		cont=f.read();
		f.close();
		m=re.search(r"obj-\$\((?P<cfgname>[A-Z0-9_]*)\)\W*\+=\W*"+moduleprops.group('file')+r"\.o",cont);
		if(m):wantin.append(m.group('cfgname'));
		else:stderr.write('Could not determine config name for ' + modname + '\n');
	else:
		stderr.write('Could not parse modinfo for ' + modname + '\n');



if(options.cfgfile != '-'): 
	f=open(options.cfgfile, 'r');
	lines=f.readlines();
	f.close();
else:
	lines=stdin.readlines();

confparse = re.compile(r"\W*(?P<iscomment>#?)\W*(?P<cfgname>CONFIG_[A-Z0-9_]*)\W*=?\W*(?P<answer>[nmy]?)");

for line in lines:
	matches = re.search(confparse,line);
	if(matches and matches.group('cfgname') in wantin): 
		of.write(matches.group('cfgname')+'=y\n');
	else: 
		#if(matches and matches.group('answer') == 'm'):of.write(matches.group('cfgname')+'=n\n');
		of.write(line);

customconfig.py

To use the script, call it for example like ./customconfig.py -i /boot/config-2.6.24-21-generic -o .config if it is located in a linux kernel directory. Then modify the resulting config to suit your needs with make menuconfig, and then you can proceed to compile your kernel.

By default, xscreensaver takes the directory out of its configfile ~/.xscreensaver, and passes it to a helper script xscreensaver-getimage-file, which then prints the complete path to a random file in that directory. So all one needs to do to add another source for pictures is to replace that file, there is already xscreensaver-getimage-flickr
, which pulls photos off flickr. So I wrote a similar script in python to print a random file from my digikam database. Maybe there are more?

Installation

The script is written in python, so that has to be installed (which is usually the case), it also requires sqlite and python bindings for it (apt-get install python-pysqlite2 in debian and ubuntu). If those are installed, backup the original xscreensaver-getimage-file, and copy the script there. Check that it is executable.
the overall process would look like(assuming xscreensaver-glslideshow already works)

sudo apt-get install python-pysqlite2
cd ~
wget http://andreas.goelzer.de/download/xscreensaver-getimage-digikam.py
chmod +x xscreensaver-getimage-digikam.py
cd /usr/bin
sudo mv xscreensaver-getimage-file xscreensaver-getimage-file-original
sudo mv ~/xscreensaver-getimage-digikam.py /usr/bin/
ln -s xscreensaver-getimage-digikam.py xscreensaver-getimage-file

If you had previously pointed xscreensaver to your digikam photo folder, that should work now. If not, edit ~/.xscreensaver and add a line pointing to that directory, in my case:

imageDirectory: /home/goelzera/Documents/Bilder

Modification

Right now this is all a bit hacky. at the beginning of the file, there is a line

bad_tags = "('private','me','Nophoto','Notmeanttobenice')"

If called, the script will take a random picture out of the database, then check if it has one of those tags. If it is tagged with one of those, it will be dismissed, similarly, if it has an extension indicating xscreensaver won’t be able to display it. So, set those line to the tags you do not want in your slideshow. For everything else you need to change the sql queries or the source code.

Running

Set your screensaver to glslideshow and wait for it to start

#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Script to choose random pictures from the digikam database
Copyright (C) 2008  Andreas Goelzer

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.


This program takes one random picture out of a sqlite-database
made by digikam.
This is useful for screensavers, xscreensaver-glslideshow in particular.
"""

#import sys;
#ef=open('/home/goelzera/Documents/Programme/python/xscreensaver-errlog','a')
#sys.stderr = ef

good_extensions = ('jpg', 'jpeg', 'pjpeg', 'pjpg', 'png', 'gif', 'tif', 'tiff', 'xbm', 'xpm')
bad_tags = "('private','me','Nophoto','Notmeanttobenice')"
#good_tags = "('public')"
good_tags = ""
attempts = 200


import sqlite3;
from sys import argv, exit;
from os.path import splitext;

digikamversion = "4";

if(len(argv) > 1):
	dirname = argv[len(argv) - 1]
else:
	dirname = "/home/goelzera/Documents/Pictures"
	
con = sqlite3.connect(dirname + "/digikam" + digikamversion + ".db")
if(digikamversion == "4"):
	url = "relativePath"
	dirid = "album"
else:
	url = "url"
	dirid = "dirid"
	
#from time import time
#f=open('/home/goelzera/Documents/Programme/python/xscreensaver-log','a')
#f.write(str(time()) + '\t' + str(argv) + '\t')

#get tagids for bad tags
def getTagIdsFromNames(names):
	tag_ids = ' ';
	for row in con.execute("SELECT id FROM Tags WHERE name IN "+ names):
		tag_ids += str(row[0]) + ','
	tag_ids = '(' + tag_ids[:-1] + ')'
	return tag_ids

if(bad_tags != ""): bad_tag_ids = getTagIdsFromNames(bad_tags)
if(good_tags != ""): good_tag_ids = getTagIdsFromNames(good_tags)

file = 'none';
#search for images, take a random one out of the db and see if it fulfills the criteria
for attempt in range(attempts):
	#get a random picture, i guess this is the wrong way, performs horrible
	#truely random, but painfully slow
	#row = con.execute("SELECT id, name, $dirid FROM Images ORDER BY RANDOM() LIMIT 0,1").fetchone()
	#fast, but not as random
	row = con.execute("SELECT id, name, "+ dirid+" FROM Images WHERE id >= (abs(RANDOM()) % (SELECT max(id) FROM Images)) LIMIT 0,1").fetchone()
	#f.write(str(row[0]) + ',')
	
	#check for bad tag
	if(bad_tags != ""):
		if(con.execute("SELECT 1 FROM ImageTags WHERE imageid = " + str(row[0]) + " AND tagid IN "+ bad_tag_ids).fetchone()): continue

	#check for good tag
	if(good_tags != ""):
		if(not con.execute("SELECT 1 FROM ImageTags WHERE imageid = " + str(row[0]) + " AND tagid IN "+ good_tag_ids).fetchone()): continue


	#check for invalid extension
	ext = splitext(row[1])
	ext = ext[1][1:].lower()
	if(not ext in good_extensions): continue
	
	#not rejected, get directory
	drow = con.execute("SELECT "+url+" FROM Albums WHERE id = " + str(row[2])).fetchone()
	file = dirname + drow[0] + '/' + row[1]
	break

print file.encode('utf-8')

#f.write(file.encode('latin-1') + '\n')

xscreensaver-getimage-digikam.py