-General-
The goal of this task should be to create an application like Apple's
Photobooth. It should be able to take photos and videos from the
webcam and save them. Further some graphical effects should be
provided in order to please the users play instinct and integration
in some other programs and services, like described below. 

-Non-technical Description-
The program consists of one main window, in which the current webcam
image and the just recorded photos and videos are shown. You can see
a very simple draft under [1] and [2] (sorry, but I'm not a good
drawer ;). Following things are thought to be implemented:

* Take a photo: Simply click on a button, take a photo and save it
* Take videos. Same result as above, but the result is a video
* Show the already taken photos and videos and provide the
  functionality to delete them
* Effects: Provide some effects to alter the photo.
* Provide a simple DBus-Interface to remote control the application,
  e.g. if some other applications want to take a photo from the
  webcam. This includes a photo conversion (size, format), where
  other applications can define their requirements.
* flickr/youtube integration: Share your photos and movies with your
  friends all over the world
* Providing an integration with other applications:
 - gnome-about-me: set the icon of the user to a special foto made with photobooth
 - gossip: set the buddy icon to a special photo made with the application
Note, that I will implement only those two in the time of SoC.
Though other integrations would be possible: gaim, evolution,
f-spot... But they will only be implemented if there is enough time
left and the application is running stable. 

The User Interface should be pretty simple and pretty like Apple's
one, because I think, they made a good job. By default, the actual
webcam photo is shown [1]. Only the "Take a Photo/Video"-buttons and
the effects-button is visible. If a already taken photo/video is
clicked, this photo/video will be shown. Further the "integration"-
buttons will be shown. In our case for now only the gnome-about-me
and the gossip icon. 

-Technical Description-
There are already two projects in a very early stage, which can take
photos and provide some effects. Both are implemented in python, see
[3] and [4]. [3] isn't finished at the moment and [4] seems to be
abandoned. For this reason and as quite all applications in GNOME are
implemented in C, this application will also be implemented in C with
GTK+. The interface will be built with glade-3. Note, that the source
of the two projects mentioned above is available, but won't be
anything more for me than a reference, because they are implemented
in python.

Gstreamer will be used to get photos and videos off the camera and to
display them. The data provided by the camera has to be filtered
twice, one to satisfy the requirements of the JPEG encoder, and the
second to satisfy the xvimagesink (generally, this is a X-Framebuffer),
which displays the photo. That means, that the signal has to be copied
and processed twice. Some more information can be found under [5].

The effects are provided by the Gstreamer-plugin gstreamer0.10-good
[6]. If we have a look on the effectv-homepage [7], we can see, that
there are quite more effects available. To use them too, they have to
be implemented as Gstreamer-plugins, but this is secondary in the
meantime.

As the program should work with other GNOME-applications, I will
provide a DBus-interface, which every other program can use. To make
use of that, the program has to provide a service-file, which DBus
can use to execute the service routines provided. Doing that allows
to use those routines, even if the program isn't running.  Moreover
DBus locks that routine, to prevent multiple calls of the same
routine. For now i will provide those routines: 
* take_photo take a photo. The format and the size can be set when
  calling this routine. The application will copy the original and
  modify to the caller's requirements. jpeg and png will be supported.
* take_video take a photo. For now, this routine won't provide any
  further settings.

Both routines will start the program and draw the UI. When the user
closes the window, it returns a string-variable which holds the path
and filename of the just taken photo or video. This file will be a
copy of the original, modified to meet the requirements, so the
calling program can do whatever it wants with that file. Moreover,
those functions will start the application in a special mode. In this
mode, the "integration-buttons" won't be visible. After taken the
photo, the path of the last or the actually marked photo will be
returned for further editing.

* get_photo_folder return the folder containing the photos
* take_remote_photo Same as take_photo, but can be used for remote control

I will create a "two-way-integration". This means, that we can use
the photos/videos taken with the program from both sides: from a
program, which needs a photo and from the application itself. The
first part will be simply done by implement the interface described
above. The second part will be done by a DBus-interface, if given.
Else I will reimplement the part needed. E.g. the gnome-about-me
integration is simply done by using libebook, which provides some
functions to edit this special "self" address book entry, which
contains the informations of the user.

The flickr/youtube integration will be done using libsoup and the
XML-RPC-API of those two services [9]. youtube requires a Developer
ID, so I don't have access at the documentation at the moment. But
simplified I will have to connect to a special URL on that platform.
After authenticating I can post the photo/video with some special
parameters.

There will be a small preferences-dialog in which a user can choose
the place, where new photos should be saved. Also the flickr/youtube
account settings can be stored here.

[1]: http://home.cs.tum.edu/~siegel/files/photobooth1.jpg
[2]: http://home.cs.tum.edu/~siegel/files/photobooth2.jpg
[3]: http://raphael.slinckx.net/blog/2007-03-12/lets-take-pictures
[4]: http://adam.uwcs.co.uk/kaapow
[5]: http://maemo.org/platform/docs/howtos/howto_camera_api_bora.html
[6]: http://gstreamer.freedesktop.org/data/doc/gstreamer/0.10.0/gst-plugins-good-plugins/html/gst-plugins-good-plugins-plugin-effectv.html
[7]: http://effectv.sourceforge.net
[9]: http://www.flickr.com/services/api/upload.api.html