added clutter-gst

29 files changed, 4097 insertions, 0 deletions

diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..a5b620e
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,4 @@
+Matthew Allum <mallum@o-hand.com> - primary authour
+Emmanuele Bassi <ebassi@o-hand.com> - python bindings, gobject/glib mastery
+Iain Holmes <iain@o-hand.com> - GTK Clutter widget
+Jorn Baayen <jorn@o-hand.com> - Gstreamer bits
\ No newline at end of file
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..b1e3f5a
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..25ad5cd
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,3 @@
+2006-08-30  Jorn Baayen  <jorn@openedhand.com>
+
+	* Split off from clutter
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..54caf7c
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,229 @@
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
+Foundation, Inc.
+
+   This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+   These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  (Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.)
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You only need
+`configure.ac' if you want to change it or regenerate `configure' using
+a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes awhile.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  Run `./configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not support the `VPATH'
+variable, you have to compile the package for one architecture at a
+time in the source code directory.  After you have installed the
+package for one architecture, use `make distclean' before reconfiguring
+for another architecture.
+
+Installation Names
+==================
+
+   By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=PATH' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, `configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the `--target=TYPE' option to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+will cause the specified gcc to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+`configure' Invocation
+======================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--help'
+`-h'
+     Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..49b725d
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,20 @@
+SUBDIRS=clutter-gst doc examples 
+
+pcfiles = clutter-gst-@CLUTTER_GST_MAJORMINOR@.pc
+
+%-@CLUTTER_GST_MAJORMINOR@.pc: %.pc
+	cp $< $@
+
+pkgconfig_DATA = $(pcfiles)
+pkgconfigdir   = $(libdir)/pkgconfig
+
+EXTRA_DIST = clutter-gst.pc.in
+
+CLEANFILES = $(pcfiles)
+
+DISTCHECK_CONFIGURE_FLAGS=--enable-gtk-doc
+
+# Extra clean files so that maintainer-clean removes *everything*
+MAINTAINERCLEANFILES = aclocal.m4 compile config.guess config.sub \
+                       configure depcomp install-sh ltmain.sh     \
+                       Makefile.in missing config.h.in
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/NEWS
diff --git a/README b/README
new file mode 100644
index 0000000..3161b66
--- /dev/null
+++ b/README
@@ -0,0 +1,5 @@
+Clutter-gst README.
+===================
+
+This package contains a video texture actor and an audio player object for
+use with clutter.
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 0000000..aecfb84
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,4 @@
+#! /bin/sh
+gtkdocize || exit 1
+autoreconf -v --install || exit 1
+./configure --enable-maintainer-mode "$@"
diff --git a/clutter-gst.pc.in b/clutter-gst.pc.in
new file mode 100644
index 0000000..fb7e3e2
--- /dev/null
+++ b/clutter-gst.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: clutter-@CLUTTER_MAJORMINOR@
+Description: Clutter GStreamer bits
+Version: @VERSION@
+Libs: -L${libdir} -lclutter-gst-@CLUTTER_MAJORMINOR@ 
+Cflags: -I${includedir}/clutter-gst-@CLUTTER_MAJORMINOR@
+Requires: clutter-0.1 gstreamer-0.10 gstreamer-plugins-base-0.10
diff --git a/clutter-gst/Makefile.am b/clutter-gst/Makefile.am
new file mode 100644
index 0000000..da86449
--- /dev/null
+++ b/clutter-gst/Makefile.am
@@ -0,0 +1,22 @@
+source_h =				      \
+	$(srcdir)/clutter-gst-video-texture.h \
+	$(srcdir)/clutter-gst-audio.h
+
+source_c = clutter-gst-media.c         \
+	   clutter-gst-video-texture.c \
+	   clutter-gst-audio.c
+
+libclutter_gst_@CLUTTER_GST_MAJORMINOR@_la_SOURCES = $(MARSHALFILES) \
+                                                     $(source_c)     \
+                                                     $(source_h)
+
+INCLUDES = @GCC_FLAGS@ @CLUTTER_GST_CFLAGS@  $(GST_CFLAGS) -I$(top_srcdir)
+
+lib_LTLIBRARIES = libclutter-gst-@CLUTTER_GST_MAJORMINOR@.la
+
+libclutter_gst_@CLUTTER_GST_MAJORMINOR@_la_LIBADD  = @CLUTTER_GST_LIBS@ $(GST_LIBS)
+libclutter_gst_@CLUTTER_GST_MAJORMINOR@_la_LDFLAGS = @CLUTTER_GST_LT_LDFLAGS@
+
+cluttergstheadersdir = $(includedir)/clutter-gst-@CLUTTER_GST_MAJORMINOR@/clutter-gst
+cluttergstheaders_HEADERS = $(source_h) 		\
+		            clutter-gst.h
diff --git a/clutter-gst/clutter-gst-audio.c b/clutter-gst/clutter-gst-audio.c
new file mode 100644
index 0000000..c66fa83
--- /dev/null
+++ b/clutter-gst/clutter-gst-audio.c
@@ -0,0 +1,781 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *             Jorn Baayen  <jorn@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:clutter-audio
+ * @short_description: Object for playback of audio files.
+ *
+ * #ClutterGstAudio is an object that plays audio files.
+ */
+
+#include "clutter-gst-audio.h"
+
+#include <gst/gst.h>
+#include <gst/audio/gstbaseaudiosink.h>
+
+#include <glib.h>
+
+struct _ClutterGstAudioPrivate
+{
+  GstElement *playbin;
+  char       *uri;
+  gboolean    can_seek;
+  int         buffer_percent;
+  int         duration;
+  guint       tick_timeout_id;
+};
+
+enum {
+  PROP_0,
+  /* ClutterGstMedia proprs */
+  PROP_URI,
+  PROP_PLAYING,
+  PROP_POSITION,
+  PROP_VOLUME,
+  PROP_CAN_SEEK,
+  PROP_BUFFER_PERCENT,
+  PROP_DURATION
+};
+
+
+#define TICK_TIMEOUT 0.5
+
+static void clutter_gst_media_init (ClutterGstMediaInterface *iface);
+
+static gboolean tick_timeout (ClutterGstAudio *audio);
+
+G_DEFINE_TYPE_EXTENDED (ClutterGstAudio,                          \
+			clutter_gst_audio,                        \
+			G_TYPE_OBJECT,                         \
+			0,                                            \
+			G_IMPLEMENT_INTERFACE (CLUTTER_GST_TYPE_MEDIA,    \
+					       clutter_gst_media_init));
+
+/* Interface implementation */
+
+static void
+set_uri (ClutterGstMedia *media,
+	 const char      *uri)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+  GstState                state, pending;
+
+  g_return_if_fail (CLUTTER_GST_IS_AUDIO (audio));
+
+  priv = audio->priv;
+
+  if (!priv->playbin)
+    return;
+
+  g_free (priv->uri);
+
+  if (uri) 
+    {
+      priv->uri = g_strdup (uri);
+    
+      /**
+       * Ensure the tick timeout is installed.
+       * 
+       * We also have it installed in PAUSED state, because
+       * seeks etc may have a delayed effect on the position.
+       **/
+    if (priv->tick_timeout_id == 0) 
+      {
+	priv->tick_timeout_id = g_timeout_add (TICK_TIMEOUT * 1000,
+					       (GSourceFunc) tick_timeout,
+					       audio);
+      }
+    } 
+  else 
+    {
+      priv->uri = NULL;
+    
+      if (priv->tick_timeout_id > 0) 
+	{
+	  g_source_remove (priv->tick_timeout_id);
+	  priv->tick_timeout_id = 0;
+	}
+    }
+  
+  priv->can_seek = FALSE;
+  priv->duration = 0;
+
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+
+  if (pending)
+    state = pending;
+  
+  gst_element_set_state (priv->playbin, GST_STATE_NULL);
+  
+  g_object_set (priv->playbin,
+		"uri", uri,
+		NULL);
+  
+  /**
+   * Restore state.
+   **/
+  if (uri) 
+    gst_element_set_state (priv->playbin, state);
+  
+  /*
+   * Emit notififications for all these to make sure UI is not showing
+   * any properties of the old URI.
+   */
+  g_object_notify (G_OBJECT (audio), "uri");
+  g_object_notify (G_OBJECT (audio), "can-seek");
+  g_object_notify (G_OBJECT (audio), "duration");
+  g_object_notify (G_OBJECT (audio), "position");
+  
+}
+
+static const char *
+get_uri (ClutterGstMedia *media)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), NULL);
+
+  priv = audio->priv;
+
+  return priv->uri;
+}
+
+static void
+set_playing (ClutterGstMedia *media,
+	     gboolean         playing)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+
+  g_return_if_fail (CLUTTER_GST_IS_AUDIO (audio));
+
+  priv = audio->priv;
+
+  if (!priv->playbin)
+    return;
+        
+  if (priv->uri) 
+    {
+      GstState state;
+    
+      if (playing)
+	state = GST_STATE_PLAYING;
+      else
+	state = GST_STATE_PAUSED;
+    
+      gst_element_set_state (audio->priv->playbin, state);
+    } 
+  else 
+    {
+      if (playing)
+	g_warning ("Tried to play, but no URI is loaded.");
+    }
+  
+  g_object_notify (G_OBJECT (audio), "playing");
+  g_object_notify (G_OBJECT (audio), "position");
+}
+
+static gboolean
+get_playing (ClutterGstMedia *media)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+  GstState                state, pending;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), FALSE);
+	
+  priv = audio->priv;
+
+  if (!priv->playbin)
+    return FALSE;
+  
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+  
+  if (pending)
+    return (pending == GST_STATE_PLAYING);
+  else
+    return (state == GST_STATE_PLAYING);
+}
+
+static void
+set_position (ClutterGstMedia *media,
+	      int              position) /* seconds */
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+  GstState                state, pending;
+
+  g_return_if_fail (CLUTTER_GST_IS_AUDIO (audio));
+
+  priv = audio->priv;
+
+  if (!priv->playbin)
+    return;
+
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+
+  if (pending)
+    state = pending;
+
+  gst_element_set_state (priv->playbin, GST_STATE_PAUSED);
+
+  gst_element_seek (priv->playbin,
+		    1.0,
+		    GST_FORMAT_TIME,
+		    GST_SEEK_FLAG_FLUSH,
+		    GST_SEEK_TYPE_SET,
+		    position * GST_SECOND,
+		    0, 0);
+
+  gst_element_set_state (priv->playbin, state);
+}
+
+static int
+get_position (ClutterGstMedia *media)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+  GstQuery               *query;
+  gint64                  position;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), -1);
+
+  priv = audio->priv;
+
+  if (!priv->playbin)
+    return -1;
+  
+  query = gst_query_new_position (GST_FORMAT_TIME);
+  
+  if (gst_element_query (priv->playbin, query)) 
+    gst_query_parse_position (query, NULL, &position);
+  else
+    position = 0;
+  
+  gst_query_unref (query);
+  
+  return (position / GST_SECOND);
+}
+
+static void
+set_volume (ClutterGstMedia *media,
+	    double           volume)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+
+  g_return_if_fail (CLUTTER_GST_IS_AUDIO (audio));
+  // g_return_if_fail (volume >= 0.0 && volume <= GST_VOL_MAX);
+
+  priv = audio->priv;
+  
+  if (!priv->playbin)
+    return;
+  
+  g_object_set (G_OBJECT (audio->priv->playbin),
+		"volume", volume,
+		NULL);
+  
+  g_object_notify (G_OBJECT (audio), "volume");
+}
+
+static double
+get_volume (ClutterGstMedia *media)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+  ClutterGstAudioPrivate *priv; 
+  double                  volume;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), 0.0);
+
+  priv = audio->priv;
+  
+  if (!priv->playbin)
+    return 0.0;
+
+  g_object_get (priv->playbin,
+		"volume", &volume,
+		NULL);
+  
+  return volume;
+}
+
+static gboolean
+can_seek (ClutterGstMedia *media)
+{
+  ClutterGstAudio        *audio = CLUTTER_GST_AUDIO(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), FALSE);
+  
+  return audio->priv->can_seek;
+}
+
+static int
+get_buffer_percent (ClutterGstMedia *media)
+{
+  ClutterGstAudio         *audio = CLUTTER_GST_AUDIO(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), -1);
+  
+  return audio->priv->buffer_percent;
+}
+
+static int
+get_duration (ClutterGstMedia *media)
+{
+  ClutterGstAudio         *audio = CLUTTER_GST_AUDIO(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_AUDIO (audio), -1);
+
+  return audio->priv->duration;
+}
+
+static void
+clutter_gst_media_init (ClutterGstMediaInterface *iface)
+{
+  iface->set_uri            = set_uri;
+  iface->get_uri            = get_uri;
+  iface->set_playing        = set_playing;
+  iface->get_playing        = get_playing;
+  iface->set_position       = set_position;
+  iface->get_position       = get_position;
+  iface->set_volume         = set_volume;
+  iface->get_volume         = get_volume;
+  iface->can_seek           = can_seek;
+  iface->get_buffer_percent = get_buffer_percent;
+  iface->get_duration       = get_duration;
+}
+
+static void
+clutter_gst_audio_dispose (GObject *object)
+{
+  ClutterGstAudio        *self;
+  ClutterGstAudioPrivate *priv; 
+
+  self = CLUTTER_GST_AUDIO(object); 
+  priv = self->priv;
+
+  /* FIXME: flush an errors off bus ? */
+  /* gst_bus_set_flushing (priv->bus, TRUE); */
+
+  if (priv->playbin) 
+    {
+      gst_element_set_state (priv->playbin, GST_STATE_NULL);
+      gst_object_unref (GST_OBJECT (priv->playbin));
+      priv->playbin = NULL;
+    }
+
+  if (priv->tick_timeout_id > 0) 
+    {
+      g_source_remove (priv->tick_timeout_id);
+      priv->tick_timeout_id = 0;
+    }
+
+  G_OBJECT_CLASS (clutter_gst_audio_parent_class)->dispose (object);
+}
+
+static void
+clutter_gst_audio_finalize (GObject *object)
+{
+  ClutterGstAudio        *self;
+  ClutterGstAudioPrivate *priv; 
+
+  self = CLUTTER_GST_AUDIO(object); 
+  priv = self->priv;
+
+  if (priv->uri)
+    g_free(priv->uri);
+
+  G_OBJECT_CLASS (clutter_gst_audio_parent_class)->finalize (object);
+}
+
+static void
+clutter_gst_audio_set_property (GObject      *object, 
+			        guint         property_id,
+				const GValue *value, 
+				GParamSpec   *pspec)
+{
+  ClutterGstAudio *audio;
+
+  audio = CLUTTER_GST_AUDIO(object);
+
+  switch (property_id)
+    {
+    case PROP_URI:
+      clutter_gst_media_set_uri (CLUTTER_GST_MEDIA(audio), 
+			     g_value_get_string (value));
+      break;
+    case PROP_PLAYING:
+      clutter_gst_media_set_playing (CLUTTER_GST_MEDIA(audio),
+				 g_value_get_boolean (value));
+      break;
+    case PROP_POSITION:
+      clutter_gst_media_set_position (CLUTTER_GST_MEDIA(audio),
+				  g_value_get_int (value));
+      break;
+    case PROP_VOLUME:
+      clutter_gst_media_set_volume (CLUTTER_GST_MEDIA(audio),
+				g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+clutter_gst_audio_get_property (GObject    *object, 
+				guint       property_id,
+				GValue     *value, 
+				GParamSpec *pspec)
+{
+  ClutterGstAudio *audio;
+  ClutterGstMedia    *media;
+
+  audio = CLUTTER_GST_AUDIO (object);
+  media = CLUTTER_GST_MEDIA (audio);
+
+  switch (property_id)
+    {
+    case PROP_URI:
+      g_value_set_string (value, clutter_gst_media_get_uri (media));
+      break;
+    case PROP_PLAYING:
+      g_value_set_boolean (value, clutter_gst_media_get_playing (media));
+      break;
+    case PROP_POSITION:
+      g_value_set_int (value, clutter_gst_media_get_position (media));
+      break;
+    case PROP_VOLUME:
+      g_value_set_double (value, clutter_gst_media_get_volume (media));
+      break;
+    case PROP_CAN_SEEK:
+      g_value_set_boolean (value, clutter_gst_media_get_can_seek (media));
+      break;
+    case PROP_BUFFER_PERCENT:
+      g_value_set_int (value, clutter_gst_media_get_buffer_percent (media));
+      break;
+    case PROP_DURATION:
+      g_value_set_int (value, clutter_gst_media_get_duration (media));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+clutter_gst_audio_class_init (ClutterGstAudioClass *klass)
+{
+  GObjectClass        *object_class;
+
+  object_class = (GObjectClass*)klass;
+
+  object_class->dispose      = clutter_gst_audio_dispose;
+  object_class->finalize     = clutter_gst_audio_finalize;
+  object_class->set_property = clutter_gst_audio_set_property;
+  object_class->get_property = clutter_gst_audio_get_property;
+
+  /* Interface props */
+
+  g_object_class_override_property (object_class, PROP_URI, "uri");
+  g_object_class_override_property (object_class, PROP_PLAYING, "playing");
+  g_object_class_override_property (object_class, PROP_POSITION, "position");
+  g_object_class_override_property (object_class, PROP_VOLUME, "volume");
+  g_object_class_override_property (object_class, PROP_CAN_SEEK, "can-seek");
+  g_object_class_override_property (object_class, PROP_DURATION, "duration");
+  g_object_class_override_property (object_class, PROP_BUFFER_PERCENT, 
+				    "buffer-percent" );
+}
+
+static void
+bus_message_error_cb (GstBus          *bus,
+                      GstMessage      *message,
+                      ClutterGstAudio *audio)
+{
+  GError *error;
+
+  error = NULL;
+  gst_message_parse_error (message, &error, NULL);
+        
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(audio), "error", error);
+
+  g_error_free (error);
+}
+
+static void
+bus_message_eos_cb (GstBus          *bus,
+                    GstMessage      *message,
+                    ClutterGstAudio *audio)
+{
+  g_object_notify (G_OBJECT (audio), "position");
+
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(audio), "eos");
+}
+
+static void
+bus_message_tag_cb (GstBus          *bus,
+                    GstMessage      *message,
+                    ClutterGstAudio *audio)
+{
+  GstTagList *tag_list;
+
+  gst_message_parse_tag (message, &tag_list);
+
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(audio), 
+			 "metadata-available", 
+			 tag_list);
+  
+  gst_tag_list_free (tag_list);
+}
+
+static void
+bus_message_buffering_cb (GstBus          *bus,
+                          GstMessage      *message,
+                          ClutterGstAudio *audio)
+{
+  const GstStructure *str;
+  
+  str = gst_message_get_structure (message);
+  if (!str)
+    return;
+
+  if (!gst_structure_get_int (str,
+			      "buffer-percent",
+			      &audio->priv->buffer_percent))
+    return;
+        
+  g_object_notify (G_OBJECT (audio), "buffer-percent");
+}
+
+static void
+bus_message_duration_cb (GstBus          *bus,
+                         GstMessage      *message,
+                         ClutterGstAudio *audio)
+{
+  GstFormat format;
+  gint64 duration;
+
+  gst_message_parse_duration (message,
+			      &format,
+			      &duration);
+
+  if (format != GST_FORMAT_TIME)
+    return;
+  
+  audio->priv->duration = duration / GST_SECOND;
+
+  g_object_notify (G_OBJECT (audio), "duration");
+}
+
+static void
+bus_message_state_change_cb (GstBus          *bus,
+                             GstMessage      *message,
+                             ClutterGstAudio *audio)
+{
+  gpointer src;
+  GstState old_state, new_state;
+
+  src = GST_MESSAGE_SRC (message);
+        
+  if (src != audio->priv->playbin)
+    return;
+
+  gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
+
+  if (old_state == GST_STATE_READY && 
+      new_state == GST_STATE_PAUSED) 
+    {
+      GstQuery *query;
+      
+      /**
+       * Determine whether we can seek.
+       **/
+      query = gst_query_new_seeking (GST_FORMAT_TIME);
+      
+      if (gst_element_query (audio->priv->playbin, query)) {
+	gst_query_parse_seeking (query,
+				 NULL,
+				 &audio->priv->can_seek,
+				 NULL,
+				 NULL);
+      } else {
+	/*
+	 * Could not query for ability to seek. Determine
+	 * using URI.
+	 */
+	
+	if (g_str_has_prefix (audio->priv->uri,
+			      "http://")) {
+	  audio->priv->can_seek = FALSE;
+	} else {
+	  audio->priv->can_seek = TRUE;
+	}
+      }
+      
+      gst_query_unref (query);
+      
+      g_object_notify (G_OBJECT (audio), "can-seek");
+      
+      /**
+       * Determine the duration.
+       **/
+      query = gst_query_new_duration (GST_FORMAT_TIME);
+      
+      if (gst_element_query (audio->priv->playbin, query)) 
+	{
+	  gint64 duration;
+	  
+	  gst_query_parse_duration (query, NULL, &duration);
+
+	  audio->priv->duration = duration / GST_SECOND;
+                        
+	  g_object_notify (G_OBJECT (audio), "duration");
+	}
+
+      gst_query_unref (query);
+    }
+}
+
+static gboolean
+tick_timeout (ClutterGstAudio *audio)
+{
+  g_object_notify (G_OBJECT (audio), "position");
+
+  return TRUE;
+}
+
+static gboolean
+lay_pipeline (ClutterGstAudio *audio)
+{
+  ClutterGstAudioPrivate *priv;
+  GstElement             *audio_sink = NULL;
+
+  priv = audio->priv;
+
+  priv->playbin = gst_element_factory_make ("playbin", "playbin");
+
+  if (!priv->playbin) 
+    {
+      g_warning ("Unable to create playbin GST element.");
+      return FALSE;
+    }
+
+  audio_sink = gst_element_factory_make ("gconfaudiosink", "audio-sink");
+  if (!audio_sink) 
+    {
+      audio_sink = gst_element_factory_make ("autoaudiosink", "audio-sink");
+      if (!audio_sink) 
+	{
+	  audio_sink = gst_element_factory_make ("alsasink", "audio-sink");
+	  g_warning ("Could not create a GST audio_sink. "
+		     "Audio unavailable.");
+
+	  if (!audio_sink) 	/* Need to bother ? */
+	    audio_sink = gst_element_factory_make ("fakesink", "audio-sink");
+	}
+    }
+
+  g_object_set (G_OBJECT (priv->playbin),
+		"audio-sink", audio_sink,
+		NULL);
+
+  return TRUE;
+}
+
+static void
+clutter_gst_audio_init (ClutterGstAudio *audio)
+{
+  ClutterGstAudioPrivate *priv;
+  GstBus                 *bus;
+
+  priv         = g_new0 (ClutterGstAudioPrivate, 1);
+  audio->priv  = priv;
+
+  if (!lay_pipeline(audio))
+    {
+      g_warning("Failed to initiate suitable playback pipeline.");
+      return;
+    }
+
+  bus = gst_pipeline_get_bus (GST_PIPELINE (priv->playbin));
+
+  gst_bus_add_signal_watch (bus);
+
+  g_signal_connect_object (bus,
+			   "message::error",
+			   G_CALLBACK (bus_message_error_cb),
+			   audio,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::eos",
+			   G_CALLBACK (bus_message_eos_cb),
+			   audio,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::tag",
+			   G_CALLBACK (bus_message_tag_cb),
+			   audio,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::buffering",
+			   G_CALLBACK (bus_message_buffering_cb),
+			   audio,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::duration",
+			   G_CALLBACK (bus_message_duration_cb),
+			   audio,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::state-changed",
+			   G_CALLBACK (bus_message_state_change_cb),
+			   audio,
+			   0);
+
+  gst_object_unref (GST_OBJECT (bus));
+
+  return;
+}
+
+/**
+ * clutter_gst_audio_new:
+ *
+ * Creates #ClutterGstAudio object.
+ *
+ * Return value: A newly allocated #ClutterGstAudio object.
+ */
+ClutterGstAudio*
+clutter_gst_audio_new (void)
+{
+  return g_object_new (CLUTTER_GST_TYPE_AUDIO, NULL);
+}
+
diff --git a/clutter-gst/clutter-gst-audio.h b/clutter-gst/clutter-gst-audio.h
new file mode 100644
index 0000000..f295895
--- /dev/null
+++ b/clutter-gst/clutter-gst-audio.h
@@ -0,0 +1,87 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *             Jorn Baayen  <jorn@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _HAVE_CLUTTER_GST_AUDIO_H
+#define _HAVE_CLUTTER_GST_AUDIO_H
+
+#include <glib-object.h>
+#include <clutter-gst/clutter-gst-media.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_GST_TYPE_AUDIO clutter_gst_audio_get_type()
+
+#define CLUTTER_GST_AUDIO(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  CLUTTER_GST_TYPE_AUDIO, ClutterGstAudio))
+
+#define CLUTTER_GST_AUDIO_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  CLUTTER_GST_TYPE_AUDIO, ClutterGstAudioClass))
+
+#define CLUTTER_GST_IS_AUDIO(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  CLUTTER_GST_TYPE_AUDIO))
+
+#define CLUTTER_GST_IS_AUDIO_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  CLUTTER_GST_TYPE_AUDIO))
+
+#define CLUTTER_GST_AUDIO_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  CLUTTER_GST_TYPE_AUDIO, ClutterGstAudioClass))
+
+typedef struct _ClutterGstAudio        ClutterGstAudio;
+typedef struct _ClutterGstAudioClass   ClutterGstAudioClass;
+typedef struct _ClutterGstAudioPrivate ClutterGstAudioPrivate;
+
+/* #define CLUTTER_GST_AUDIO_ERROR clutter_gst_audio_error_quark() */
+
+struct _ClutterGstAudio
+{
+  GObject              parent;
+  ClutterGstAudioPrivate *priv;
+}; 
+
+struct _ClutterGstAudioClass 
+{
+  GObjectClass parent_class;
+
+  /* Future padding */
+  void (* _clutter_reserved1) (void);
+  void (* _clutter_reserved2) (void);
+  void (* _clutter_reserved3) (void);
+  void (* _clutter_reserved4) (void);
+  void (* _clutter_reserved5) (void);
+  void (* _clutter_reserved6) (void);
+}; 
+
+GType            clutter_gst_audio_get_type (void) G_GNUC_CONST;
+ClutterGstAudio *clutter_gst_audio_new      (void);
+
+G_END_DECLS
+
+#endif
diff --git a/clutter-gst/clutter-gst-media.c b/clutter-gst/clutter-gst-media.c
new file mode 100644
index 0000000..bb338cf
--- /dev/null
+++ b/clutter-gst/clutter-gst-media.c
@@ -0,0 +1,377 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:clutter-media
+ * @short_description: An interface for controlling playback of media data.
+ *
+ * #ClutterGstMedia is an interface  for controlling playback of media data.
+ */
+
+#include "config.h"
+
+#include "clutter-gst-media.h"
+
+static void clutter_gst_media_base_init (gpointer g_class);
+
+GType
+clutter_gst_media_get_type (void)
+{
+  static GType media_type = 0;
+
+  if (!media_type)
+    {
+      static const GTypeInfo media_info =
+      {
+	sizeof (ClutterGstMediaInterface),
+	clutter_gst_media_base_init,
+	NULL,			
+      };
+
+      media_type = g_type_register_static (G_TYPE_INTERFACE, "ClutterGstMedia",
+					   &media_info, 0);
+    }
+
+  return media_type;
+}
+
+static void
+clutter_gst_media_base_init (gpointer g_iface)
+{
+  static gboolean initialized = FALSE;
+
+  if (!initialized)
+    {
+      initialized = TRUE;
+
+      /* props */
+
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_string 
+	 ("uri",
+	  "URI",
+	  "The loaded URI.",
+	  NULL,
+	  G_PARAM_READWRITE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_boolean
+	 ("playing",
+	  "Playing",
+	  "TRUE if playing.",
+	  FALSE,
+	  G_PARAM_READWRITE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_int
+	 ("position",
+	  "Position",
+	  "The position in the current stream in seconds.",
+	  0, G_MAXINT, 0,
+	  G_PARAM_READWRITE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_double
+	 ("volume",
+	  "Volume",
+	  "The audio volume.",
+	  0, 100, 50,
+	  G_PARAM_READWRITE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_boolean
+	 ("can-seek",
+	  "Can seek",
+	  "TRUE if the current stream is seekable.",
+	  FALSE,
+	  G_PARAM_READABLE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+	 
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_int
+	 ("buffer-percent",
+	  "Buffer percent",
+	  "The percentage the current stream buffer is filled.",
+	  0, 100, 0,
+	  G_PARAM_READABLE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+	 
+      g_object_interface_install_property 
+	(g_iface,
+	 g_param_spec_int
+	 ("duration",
+	  "Duration",
+	  "The duration of the current stream in seconds.",
+	  0, G_MAXINT, 0,
+	  G_PARAM_READABLE |
+	  G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK |
+	  G_PARAM_STATIC_BLURB));
+
+      /* signals */
+
+      g_signal_new ("metadata-available",
+		    CLUTTER_GST_TYPE_MEDIA,
+		    G_SIGNAL_RUN_LAST,
+		    G_STRUCT_OFFSET (ClutterGstMediaInterface,
+				     metadata_available),
+		    NULL, NULL,
+		    g_cclosure_marshal_VOID__POINTER,
+		    G_TYPE_NONE, 1, G_TYPE_POINTER);
+      
+      g_signal_new ("eos",
+		    CLUTTER_GST_TYPE_MEDIA,
+		    G_SIGNAL_RUN_LAST,
+		    G_STRUCT_OFFSET (ClutterGstMediaInterface,
+				     eos),
+		    NULL, NULL,
+		    g_cclosure_marshal_VOID__VOID,
+		    G_TYPE_NONE, 0);
+      
+      g_signal_new ("error",
+		    CLUTTER_GST_TYPE_MEDIA,
+		    G_SIGNAL_RUN_LAST,
+		    G_STRUCT_OFFSET (ClutterGstMediaInterface,
+				     error),
+		    NULL, NULL,
+		    g_cclosure_marshal_VOID__POINTER,
+		    G_TYPE_NONE, 1, G_TYPE_POINTER);
+    }
+}
+
+/**
+ * clutter_gst_media_set_uri:
+ * @media: #ClutterGstMedia object
+ * @uri: Uri
+ *
+ * Sets the uri of @media to @uri.
+ */
+void
+clutter_gst_media_set_uri (ClutterGstMedia *media,
+		           const char      *uri)
+{
+  g_return_if_fail (CLUTTER_GST_IS_MEDIA(media));
+
+  CLUTTER_GST_MEDIA_GET_INTERFACE (media)->set_uri (media, uri);
+}
+
+/**
+ * clutter_gst_media_get_uri:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves the URI from @media.
+ *
+ * Return value: The URI as a string.
+ */
+const char*
+clutter_gst_media_get_uri (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), NULL);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_uri (media);
+}
+
+/**
+ * clutter_gst_media_set_playing:
+ * @media: A #ClutterGstMedia object
+ * @playing: TRUE to start playing, FALSE to stop.
+ *
+ * Starts or stops @media playing.
+ */
+void
+clutter_gst_media_set_playing (ClutterGstMedia *media,
+			       gboolean         playing)
+{
+  g_return_if_fail (CLUTTER_GST_IS_MEDIA(media));
+
+  CLUTTER_GST_MEDIA_GET_INTERFACE (media)->set_playing (media, playing);
+}
+
+/**
+ * clutter_gst_media_get_playing:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves the state of @media.
+ *
+ * Return value: TRUE if playing, FALSE if stopped.
+ */
+gboolean
+clutter_gst_media_get_playing (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), FALSE);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_playing (media);
+}
+
+/**
+ * clutter_gst_media_set_position:
+ * @media: A #ClutterGstMedia object
+ * @position: The desired position.
+ *
+ * Sets the playback position of @media to @position.
+ */
+void
+clutter_gst_media_set_position (ClutterGstMedia *media,
+			        int              position)
+{
+  g_return_if_fail (CLUTTER_GST_IS_MEDIA(media));
+
+  CLUTTER_GST_MEDIA_GET_INTERFACE (media)->set_position (media, position);
+}
+
+/**
+ * clutter_gst_media_get_position:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves the position of @media.
+ *
+ * Return value: The playback position.
+ */
+int
+clutter_gst_media_get_position (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), 0);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_position (media);
+}
+
+/**
+ * clutter_gst_media_set_volume:
+ * @media: A #ClutterGstMedia object
+ * @volume: The volume as a double between 0.0 and 1.0
+ *
+ * Sets the playback volume of @media to @volume.
+ */
+void
+clutter_gst_media_set_volume (ClutterGstMedia *media,
+			      double           volume)
+{
+  g_return_if_fail (CLUTTER_GST_IS_MEDIA(media));
+
+  CLUTTER_GST_MEDIA_GET_INTERFACE (media)->set_volume (media, volume);
+}
+
+/** 
+ * clutter_gst_media_get_volume:
+ * @media: A #ClutterGstMedia object
+ * 
+ * Retrieves the playback volume of @media.
+ *
+ * Return value: The playback volume between 0.0 and 1.0
+ */
+double
+clutter_gst_media_get_volume (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), 0.0);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_volume (media);
+}
+
+/**
+ * clutter_gst_media_get_can_seek:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves whether @media is seekable or not.
+ *
+ * Return value: TRUE if @media can seek, FALSE otherwise.
+ */
+gboolean
+clutter_gst_media_get_can_seek (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), FALSE);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->can_seek (media);
+}
+
+/**
+ * clutter_gst_media_get_buffer_percent:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves the amount of the stream that is buffered.
+ *
+ * Return value: percentage value
+ */
+int
+clutter_gst_media_get_buffer_percent (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), 0);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_buffer_percent (media);
+}
+
+/**
+ * clutter_gst_media_get_duration:
+ * @media: A #ClutterGstMedia object
+ *
+ * Retrieves the duration of the media stream that @media represents.
+ *
+ * Return value: The length of the media stream.
+ */
+int
+clutter_gst_media_get_duration (ClutterGstMedia *media)
+{
+  g_return_val_if_fail (CLUTTER_GST_IS_MEDIA(media), 0);
+
+  return CLUTTER_GST_MEDIA_GET_INTERFACE (media)->get_duration (media);
+}
+
+/* helper funcs */
+
+/**
+ * clutter_gst_media_set_filename:
+ * @media: A #ClutterGstMedia object
+ * @filename: A filename to media file.
+ *
+ * Converts a filesystem path to a uri and calls clutter_gst_media_set_uri
+ */
+void
+clutter_gst_media_set_filename (ClutterGstMedia *media, const gchar *filename)
+{
+  gchar *uri;
+
+  if (filename[0] != '/')
+    uri = g_strdup_printf ("file://%s/%s", g_get_current_dir (), filename);
+  else 
+    uri = g_strdup_printf ("file://%s", filename);
+
+  clutter_gst_media_set_uri (media, uri);
+
+  g_free(uri);
+}
diff --git a/clutter-gst/clutter-gst-media.h b/clutter-gst/clutter-gst-media.h
new file mode 100644
index 0000000..ecdba5b
--- /dev/null
+++ b/clutter-gst/clutter-gst-media.h
@@ -0,0 +1,124 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _HAVE_CLUTTER_GST_MEDIA_H
+#define _HAVE_CLUTTER_GST_MEDIA_H
+
+#include <glib-object.h>
+#include <gst/gsttaglist.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_GST_TYPE_MEDIA clutter_gst_media_get_type()
+
+#define CLUTTER_GST_MEDIA(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  CLUTTER_GST_TYPE_MEDIA, ClutterGstMedia))
+
+#define CLUTTER_GST_IS_MEDIA(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  CLUTTER_GST_TYPE_MEDIA))
+
+#define CLUTTER_GST_MEDIA_GET_INTERFACE(obj) \
+  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), \
+  CLUTTER_GST_TYPE_MEDIA, ClutterGstMediaInterface))
+
+typedef struct _ClutterGstMedia           ClutterGstMedia;      
+typedef struct _ClutterGstMediaInterface  ClutterGstMediaInterface;
+
+struct _ClutterGstMediaInterface
+{
+  GTypeInterface	    base_iface;
+  void (*set_uri)           (ClutterGstMedia *media,
+			     const char      *uri);
+  const char *(*get_uri)    (ClutterGstMedia *media);
+  void (*set_playing)       (ClutterGstMedia *media,
+			     gboolean         playing);
+  gboolean (*get_playing)   (ClutterGstMedia *media);
+  void (*set_position)      (ClutterGstMedia *media,
+			     int              position);
+  int (*get_position)       (ClutterGstMedia *media);
+  void (*set_volume)        (ClutterGstMedia *media,
+			     double           volume);
+  double (*get_volume)      (ClutterGstMedia *media);
+  gboolean (*can_seek)      (ClutterGstMedia *media);
+  int (*get_buffer_percent) (ClutterGstMedia *media);
+  int (*get_duration)       (ClutterGstMedia *media);
+
+  /* signals */
+
+  void (* metadata_available) (ClutterGstMedia *media,
+			       GstTagList      *tag_list);
+  void (* eos)                (ClutterGstMedia *media);
+  void (* error)              (ClutterGstMedia *media,
+			       GError          *error);
+};
+
+
+GType clutter_gst_media_get_type     (void);
+
+void
+clutter_gst_media_set_uri            (ClutterGstMedia *media,
+				      const char      *uri);
+const char *
+clutter_gst_media_get_uri            (ClutterGstMedia *media);
+
+void
+clutter_gst_media_set_playing        (ClutterGstMedia *media,
+				      gboolean         playing);
+
+gboolean
+clutter_gst_media_get_playing        (ClutterGstMedia *media);
+
+void
+clutter_gst_media_set_position       (ClutterGstMedia *media,
+				      int              position);
+
+int
+clutter_gst_media_get_position       (ClutterGstMedia *media);
+
+void
+clutter_gst_media_set_volume         (ClutterGstMedia *media,
+				      double           volume);
+
+double
+clutter_gst_media_get_volume         (ClutterGstMedia *media);
+
+gboolean
+clutter_gst_media_get_can_seek       (ClutterGstMedia *media);
+
+int
+clutter_gst_media_get_buffer_percent (ClutterGstMedia *media);
+
+int
+clutter_gst_media_get_duration       (ClutterGstMedia *media);
+
+void
+clutter_gst_media_set_filename       (ClutterGstMedia *media, 
+				      const gchar     *filename);
+
+G_END_DECLS
+
+#endif
diff --git a/clutter-gst/clutter-gst-video-texture.c b/clutter-gst/clutter-gst-video-texture.c
new file mode 100644
index 0000000..f0e6d55
--- /dev/null
+++ b/clutter-gst/clutter-gst-video-texture.c
@@ -0,0 +1,892 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:clutter-video-texture
+ * @short_description: Actor for playback of video files.
+ *
+ * #ClutterGstVideoTexture is a #ClutterTexture that plays video files.
+ */
+
+#include "clutter-gst-video-texture.h"
+
+#include <gst/gst.h>
+#include <gst/video/gstvideosink.h>
+#include <gst/audio/gstbaseaudiosink.h>
+
+#include <GL/glx.h>
+#include <GL/gl.h>
+
+#include <glib.h>
+
+struct _ClutterGstVideoTexturePrivate
+{
+  GstElement *playbin;
+  char       *uri;
+  gboolean    can_seek;
+  int         buffer_percent;
+  int         duration;
+  gboolean    force_aspect_ratio;
+  guint       tick_timeout_id;
+};
+
+enum {
+  PROP_0,
+  /* ClutterGstMedia proprs */
+  PROP_URI,
+  PROP_PLAYING,
+  PROP_POSITION,
+  PROP_VOLUME,
+  PROP_CAN_SEEK,
+  PROP_BUFFER_PERCENT,
+  PROP_DURATION,
+
+  /* Extra texture props */
+  PROP_FORCE_ASPECT_RATIO
+};
+
+
+#define TICK_TIMEOUT 0.5
+
+static void clutter_gst_media_init (ClutterGstMediaInterface *iface);
+
+static gboolean tick_timeout (ClutterGstVideoTexture *video_texture);
+
+G_DEFINE_TYPE_EXTENDED (ClutterGstVideoTexture,                          \
+			clutter_gst_video_texture,                        \
+			CLUTTER_TYPE_TEXTURE,                         \
+			0,                                            \
+			G_IMPLEMENT_INTERFACE (CLUTTER_GST_TYPE_MEDIA,    \
+					       clutter_gst_media_init));
+
+/* Interface implementation */
+
+static void
+set_uri (ClutterGstMedia *media,
+	 const char      *uri)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+  GstState state, pending;
+
+  g_return_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture));
+
+  priv = video_texture->priv;
+
+  if (!priv->playbin)
+    return;
+
+  g_free (priv->uri);
+
+  if (uri) 
+    {
+      priv->uri = g_strdup (uri);
+    
+      /**
+       * Ensure the tick timeout is installed.
+       * 
+       * We also have it installed in PAUSED state, because
+       * seeks etc may have a delayed effect on the position.
+       **/
+    if (priv->tick_timeout_id == 0) 
+      {
+	priv->tick_timeout_id = g_timeout_add (TICK_TIMEOUT * 1000,
+					       (GSourceFunc) tick_timeout,
+					       video_texture);
+      }
+    } 
+  else 
+    {
+      priv->uri = NULL;
+    
+      if (priv->tick_timeout_id > 0) 
+	{
+	  g_source_remove (priv->tick_timeout_id);
+	  priv->tick_timeout_id = 0;
+	}
+    }
+  
+  priv->can_seek = FALSE;
+  priv->duration = 0;
+
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+
+  if (pending)
+    state = pending;
+  
+  gst_element_set_state (priv->playbin, GST_STATE_NULL);
+  
+  g_object_set (priv->playbin,
+		"uri", uri,
+		NULL);
+  
+  /**
+   * Restore state.
+   **/
+  if (uri) 
+    gst_element_set_state (priv->playbin, state);
+  
+  /*
+   * Emit notififications for all these to make sure UI is not showing
+   * any properties of the old URI.
+   */
+  g_object_notify (G_OBJECT (video_texture), "uri");
+  g_object_notify (G_OBJECT (video_texture), "can-seek");
+  g_object_notify (G_OBJECT (video_texture), "duration");
+  g_object_notify (G_OBJECT (video_texture), "position");
+  
+}
+
+static const char *
+get_uri (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), NULL);
+
+  priv = video_texture->priv;
+
+  return priv->uri;
+}
+
+static void
+set_playing (ClutterGstMedia *media,
+	     gboolean         playing)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+
+  g_return_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture));
+
+  priv = video_texture->priv;
+
+  if (!priv->playbin)
+    return;
+        
+  if (priv->uri) 
+    {
+      GstState state;
+    
+      if (playing)
+	state = GST_STATE_PLAYING;
+      else
+	state = GST_STATE_PAUSED;
+    
+      gst_element_set_state (video_texture->priv->playbin, state);
+    } 
+  else 
+    {
+      if (playing)
+	g_warning ("Tried to play, but no URI is loaded.");
+    }
+  
+  g_object_notify (G_OBJECT (video_texture), "playing");
+  g_object_notify (G_OBJECT (video_texture), "position");
+}
+
+static gboolean
+get_playing (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+  GstState state, pending;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), FALSE);
+	
+  priv = video_texture->priv;
+
+  if (!priv->playbin)
+    return FALSE;
+  
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+  
+  if (pending)
+    return (pending == GST_STATE_PLAYING);
+  else
+    return (state == GST_STATE_PLAYING);
+}
+
+static void
+set_position (ClutterGstMedia *media,
+	      int              position) /* seconds */
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+  GstState state, pending;
+
+  g_return_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture));
+
+  priv = video_texture->priv;
+
+  if (!priv->playbin)
+    return;
+
+  gst_element_get_state (priv->playbin, &state, &pending, 0);
+
+  if (pending)
+    state = pending;
+
+  gst_element_set_state (priv->playbin, GST_STATE_PAUSED);
+
+  gst_element_seek (priv->playbin,
+		    1.0,
+		    GST_FORMAT_TIME,
+		    GST_SEEK_FLAG_FLUSH,
+		    GST_SEEK_TYPE_SET,
+		    position * GST_SECOND,
+		    0, 0);
+
+  gst_element_set_state (priv->playbin, state);
+}
+
+static int
+get_position (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+  GstQuery *query;
+  gint64 position;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), -1);
+
+  priv = video_texture->priv;
+
+  if (!priv->playbin)
+    return -1;
+  
+  query = gst_query_new_position (GST_FORMAT_TIME);
+  
+  if (gst_element_query (priv->playbin, query)) 
+    gst_query_parse_position (query, NULL, &position);
+  else
+    position = 0;
+  
+  gst_query_unref (query);
+  
+  return (position / GST_SECOND);
+}
+
+static void
+set_volume (ClutterGstMedia *media,
+	    double           volume)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+
+  g_return_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture));
+  // g_return_if_fail (volume >= 0.0 && volume <= GST_VOL_MAX);
+
+  priv = video_texture->priv;
+  
+  if (!priv->playbin)
+    return;
+  
+  g_object_set (G_OBJECT (video_texture->priv->playbin),
+		"volume", volume,
+		NULL);
+  
+  g_object_notify (G_OBJECT (video_texture), "volume");
+}
+
+static double
+get_volume (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+  ClutterGstVideoTexturePrivate *priv; 
+  double volume;
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), 0.0);
+
+  priv = video_texture->priv;
+  
+  if (!priv->playbin)
+    return 0.0;
+
+  g_object_get (priv->playbin,
+		"volume", &volume,
+		NULL);
+  
+  return volume;
+}
+
+static gboolean
+can_seek (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), FALSE);
+  
+  return video_texture->priv->can_seek;
+}
+
+static int
+get_buffer_percent (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), -1);
+  
+  return video_texture->priv->buffer_percent;
+}
+
+static int
+get_duration (ClutterGstMedia *media)
+{
+  ClutterGstVideoTexture *video_texture = CLUTTER_GST_VIDEO_TEXTURE(media);
+
+  g_return_val_if_fail (CLUTTER_GST_IS_VIDEO_TEXTURE (video_texture), -1);
+
+  return video_texture->priv->duration;
+}
+
+static void
+clutter_gst_media_init (ClutterGstMediaInterface *iface)
+{
+  iface->set_uri            = set_uri;
+  iface->get_uri            = get_uri;
+  iface->set_playing        = set_playing;
+  iface->get_playing        = get_playing;
+  iface->set_position       = set_position;
+  iface->get_position       = get_position;
+  iface->set_volume         = set_volume;
+  iface->get_volume         = get_volume;
+  iface->can_seek           = can_seek;
+  iface->get_buffer_percent = get_buffer_percent;
+  iface->get_duration       = get_duration;
+}
+
+static void
+clutter_gst_video_texture_dispose (GObject *object)
+{
+  ClutterGstVideoTexture        *self;
+  ClutterGstVideoTexturePrivate *priv; 
+
+  self = CLUTTER_GST_VIDEO_TEXTURE(object); 
+  priv = self->priv;
+
+  /* FIXME: flush an errors off bus ? */
+  /* gst_bus_set_flushing (priv->bus, TRUE); */
+
+  if (priv->playbin) 
+    {
+      gst_element_set_state (priv->playbin, GST_STATE_NULL);
+      gst_object_unref (GST_OBJECT (priv->playbin));
+      priv->playbin = NULL;
+    }
+
+  if (priv->tick_timeout_id > 0) 
+    {
+      g_source_remove (priv->tick_timeout_id);
+      priv->tick_timeout_id = 0;
+    }
+
+  G_OBJECT_CLASS (clutter_gst_video_texture_parent_class)->dispose (object);
+}
+
+static void
+clutter_gst_video_texture_finalize (GObject *object)
+{
+  ClutterGstVideoTexture        *self;
+  ClutterGstVideoTexturePrivate *priv; 
+
+  self = CLUTTER_GST_VIDEO_TEXTURE(object); 
+  priv = self->priv;
+
+  if (priv->uri)
+    g_free(priv->uri);
+
+  G_OBJECT_CLASS (clutter_gst_video_texture_parent_class)->finalize (object);
+}
+
+static void
+clutter_gst_video_texture_set_property (GObject      *object, 
+				        guint         property_id,
+				        const GValue *value, 
+				        GParamSpec   *pspec)
+{
+  ClutterGstVideoTexture *video_texture;
+
+  video_texture = CLUTTER_GST_VIDEO_TEXTURE(object);
+
+  switch (property_id)
+    {
+    case PROP_URI:
+      clutter_gst_media_set_uri (CLUTTER_GST_MEDIA(video_texture), 
+			     g_value_get_string (value));
+      break;
+    case PROP_PLAYING:
+      clutter_gst_media_set_playing (CLUTTER_GST_MEDIA(video_texture),
+				 g_value_get_boolean (value));
+      break;
+    case PROP_POSITION:
+      clutter_gst_media_set_position (CLUTTER_GST_MEDIA(video_texture),
+				  g_value_get_int (value));
+      break;
+    case PROP_VOLUME:
+      clutter_gst_media_set_volume (CLUTTER_GST_MEDIA(video_texture),
+				g_value_get_double (value));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+clutter_gst_video_texture_get_property (GObject    *object, 
+				        guint       property_id,
+				        GValue     *value, 
+				        GParamSpec *pspec)
+{
+  ClutterGstVideoTexture *video_texture;
+  ClutterGstMedia        *media;
+
+  video_texture = CLUTTER_GST_VIDEO_TEXTURE (object);
+  media         = CLUTTER_GST_MEDIA (video_texture);
+
+  switch (property_id)
+    {
+    case PROP_URI:
+      g_value_set_string (value, clutter_gst_media_get_uri (media));
+      break;
+    case PROP_PLAYING:
+      g_value_set_boolean (value, clutter_gst_media_get_playing (media));
+      break;
+    case PROP_POSITION:
+      g_value_set_int (value, clutter_gst_media_get_position (media));
+      break;
+    case PROP_VOLUME:
+      g_value_set_double (value, clutter_gst_media_get_volume (media));
+      break;
+    case PROP_CAN_SEEK:
+      g_value_set_boolean (value, clutter_gst_media_get_can_seek (media));
+      break;
+    case PROP_BUFFER_PERCENT:
+      g_value_set_int (value, clutter_gst_media_get_buffer_percent (media));
+      break;
+    case PROP_DURATION:
+      g_value_set_int (value, clutter_gst_media_get_duration (media));
+      break;
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+    }
+}
+
+static void
+clutter_gst_video_texture_class_init (ClutterGstVideoTextureClass *klass)
+{
+  GObjectClass      *object_class;
+  ClutterActorClass *actor_class;
+
+  object_class = (GObjectClass*)klass;
+  actor_class = (ClutterActorClass*)klass;
+
+  object_class->dispose      = clutter_gst_video_texture_dispose;
+  object_class->finalize     = clutter_gst_video_texture_finalize;
+  object_class->set_property = clutter_gst_video_texture_set_property;
+  object_class->get_property = clutter_gst_video_texture_get_property;
+
+  /* Interface props */
+
+  g_object_class_override_property (object_class, PROP_URI, "uri");
+  g_object_class_override_property (object_class, PROP_PLAYING, "playing");
+  g_object_class_override_property (object_class, PROP_POSITION, "position");
+  g_object_class_override_property (object_class, PROP_VOLUME, "volume");
+  g_object_class_override_property (object_class, PROP_CAN_SEEK, "can-seek");
+  g_object_class_override_property (object_class, PROP_DURATION, "duration");
+  g_object_class_override_property (object_class, PROP_BUFFER_PERCENT, 
+				    "buffer-percent" );
+}
+
+static void
+bus_message_error_cb (GstBus                 *bus,
+                      GstMessage             *message,
+                      ClutterGstVideoTexture *video_texture)
+{
+  GError *error;
+
+  error = NULL;
+  gst_message_parse_error (message, &error, NULL);
+        
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(video_texture), "error", error);
+
+  g_error_free (error);
+}
+
+static void
+bus_message_eos_cb (GstBus                 *bus,
+                    GstMessage             *message,
+                    ClutterGstVideoTexture *video_texture)
+{
+  g_object_notify (G_OBJECT (video_texture), "position");
+
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(video_texture), "eos");
+}
+
+static void
+bus_message_tag_cb (GstBus                 *bus,
+                    GstMessage             *message,
+                    ClutterGstVideoTexture *video_texture)
+{
+  GstTagList *tag_list;
+
+  gst_message_parse_tag (message, &tag_list);
+
+  g_signal_emit_by_name (CLUTTER_GST_MEDIA(video_texture), 
+			 "metadata-available", 
+			 tag_list);
+  
+  gst_tag_list_free (tag_list);
+}
+
+static void
+bus_message_buffering_cb (GstBus                 *bus,
+                          GstMessage             *message,
+                          ClutterGstVideoTexture *video_texture)
+{
+  const GstStructure *str;
+  
+  str = gst_message_get_structure (message);
+  if (!str)
+    return;
+
+  if (!gst_structure_get_int (str,
+			      "buffer-percent",
+			      &video_texture->priv->buffer_percent))
+    return;
+        
+  g_object_notify (G_OBJECT (video_texture), "buffer-percent");
+}
+
+static void
+bus_message_duration_cb (GstBus                 *bus,
+                         GstMessage             *message,
+                         ClutterGstVideoTexture *video_texture)
+{
+  GstFormat format;
+  gint64 duration;
+
+  gst_message_parse_duration (message,
+			      &format,
+			      &duration);
+
+  if (format != GST_FORMAT_TIME)
+    return;
+  
+  video_texture->priv->duration = duration / GST_SECOND;
+
+  g_object_notify (G_OBJECT (video_texture), "duration");
+}
+
+static void
+bus_message_state_change_cb (GstBus                 *bus,
+                             GstMessage             *message,
+                             ClutterGstVideoTexture *video_texture)
+{
+  gpointer src;
+  GstState old_state, new_state;
+
+  src = GST_MESSAGE_SRC (message);
+        
+  if (src != video_texture->priv->playbin)
+    return;
+
+  gst_message_parse_state_changed (message, &old_state, &new_state, NULL);
+
+  if (old_state == GST_STATE_READY && 
+      new_state == GST_STATE_PAUSED) 
+    {
+      GstQuery *query;
+      
+      /**
+       * Determine whether we can seek.
+       **/
+      query = gst_query_new_seeking (GST_FORMAT_TIME);
+      
+      if (gst_element_query (video_texture->priv->playbin, query)) {
+	gst_query_parse_seeking (query,
+				 NULL,
+				 &video_texture->priv->can_seek,
+				 NULL,
+				 NULL);
+      } else {
+	/*
+	 * Could not query for ability to seek. Determine
+	 * using URI.
+	 */
+	
+	if (g_str_has_prefix (video_texture->priv->uri,
+			      "http://")) {
+	  video_texture->priv->can_seek = FALSE;
+	} else {
+	  video_texture->priv->can_seek = TRUE;
+	}
+      }
+      
+      gst_query_unref (query);
+      
+      g_object_notify (G_OBJECT (video_texture), "can-seek");
+      
+      /**
+       * Determine the duration.
+       **/
+      query = gst_query_new_duration (GST_FORMAT_TIME);
+      
+      if (gst_element_query (video_texture->priv->playbin, query)) 
+	{
+	  gint64 duration;
+	  
+	  gst_query_parse_duration (query, NULL, &duration);
+
+	  video_texture->priv->duration = duration / GST_SECOND;
+                        
+	  g_object_notify (G_OBJECT (video_texture), "duration");
+	}
+
+      gst_query_unref (query);
+    }
+}
+
+static gboolean
+tick_timeout (ClutterGstVideoTexture *video_texture)
+{
+  g_object_notify (G_OBJECT (video_texture), "position");
+
+  return TRUE;
+}
+
+static void
+fakesink_handoff_cb (GstElement *fakesrc, 
+		     GstBuffer  *buffer,
+		     GstPad     *pad, 
+		     gpointer    user_data)
+{
+  GstStructure  *structure;
+  int            width, height;
+  GdkPixbuf     *pixb;
+
+  structure = gst_caps_get_structure(GST_CAPS(buffer->caps), 0);
+  gst_structure_get_int(structure, "width", &width);
+  gst_structure_get_int(structure, "height", &height);
+
+  /* FIXME: We really dont want to do this every time as gobject creation
+   *        really need a clutter_texture_set_from_data call ?
+  */
+  pixb = gdk_pixbuf_new_from_data (GST_BUFFER_DATA (buffer),
+				   GDK_COLORSPACE_RGB, 
+				   FALSE, 
+				   8, 
+				   width, 
+				   height,
+				   (3 * width + 3) &~ 3,
+				   NULL,
+				   NULL);
+  
+  if (pixb)
+    {
+      clutter_texture_set_pixbuf (CLUTTER_TEXTURE(user_data), pixb);
+      g_object_unref(G_OBJECT(pixb));
+    }
+}
+
+static gboolean
+lay_pipeline (ClutterGstVideoTexture *video_texture)
+{
+  ClutterGstVideoTexturePrivate *priv;
+  GstElement                    *audio_sink = NULL;
+  GstElement                    *video_sink, *video_bin, *video_capsfilter;
+  GstCaps                       *video_filtercaps;
+  GstPad                        *video_ghost_pad;
+
+  priv = video_texture->priv;
+
+  priv->playbin = gst_element_factory_make ("playbin", "playbin");
+
+  if (!priv->playbin) 
+    {
+      g_warning ("Unable to create playbin GST actor.");
+      return FALSE;
+    }
+
+  audio_sink = gst_element_factory_make ("gconfaudiosink", "audio-sink");
+  if (!audio_sink) 
+    {
+      audio_sink = gst_element_factory_make ("autoaudiosink", "audio-sink");
+      if (!audio_sink) 
+	{
+	  audio_sink = gst_element_factory_make ("alsasink", "audio-sink");
+	  g_warning ("Could not create a GST audio_sink. "
+		     "Audio unavailable.");
+
+	  if (!audio_sink) 	/* Need to bother ? */
+	    audio_sink = gst_element_factory_make ("fakesink", "audio-sink");
+	}
+    }
+
+  video_sink = gst_element_factory_make ("fakesink", "fakesink");
+
+  if (video_sink == NULL) 
+    {
+      g_warning ("Could not create actor 'fakesink' for video playback");
+      priv->playbin = NULL;
+      return FALSE;
+    }
+
+  video_bin = gst_bin_new  ("video-bin");
+
+  video_capsfilter = gst_element_factory_make ("capsfilter", 
+					       "video-capsfilter");
+
+  video_filtercaps 
+    = gst_caps_new_simple("video/x-raw-rgb",
+			  "bpp", G_TYPE_INT, 24,
+			  "depth", G_TYPE_INT, 24,
+			  "endianness", G_TYPE_INT, G_BIG_ENDIAN, 
+			  /* >> 8 for 24bpp */ 
+			  "red_mask", G_TYPE_INT, 0xff0000,
+			  "green_mask", G_TYPE_INT, 0xff00,
+			  "blue_mask", G_TYPE_INT,  0xff,
+			  "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+			  "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
+			  "framerate", GST_TYPE_FRACTION_RANGE, 
+			  0, 1, G_MAXINT, 1, 
+			  NULL);
+
+  g_object_set(G_OBJECT(video_capsfilter), 
+	       "caps", video_filtercaps, 
+	       NULL);
+
+  gst_bin_add(GST_BIN(video_bin), video_capsfilter);
+  gst_bin_add(GST_BIN(video_bin), video_sink);
+
+  gst_element_link (video_capsfilter, video_sink);
+
+  video_ghost_pad = gst_ghost_pad_new ("sink", 
+				       gst_element_get_pad (video_capsfilter, 
+							    "sink"));
+  gst_element_add_pad (video_bin, video_ghost_pad);
+
+  g_object_set (G_OBJECT(video_sink), 
+		"signal-handoffs", TRUE, 
+		"sync", TRUE,
+		/* Enable frame drops. FIXME: export setting in API ? */
+		"qos",  TRUE, 
+		NULL);
+
+  g_signal_connect(G_OBJECT (video_sink), 
+		   "handoff",
+		   G_CALLBACK(fakesink_handoff_cb), 
+		   video_texture);
+
+  g_object_set (G_OBJECT (priv->playbin),
+		"video-sink", video_bin,
+		"audio-sink", audio_sink,
+		NULL);
+
+  return TRUE;
+}
+
+static void
+clutter_gst_video_texture_init (ClutterGstVideoTexture *video_texture)
+{
+  ClutterGstVideoTexturePrivate *priv;
+  GstBus                        *bus;
+
+  priv                 = g_new0 (ClutterGstVideoTexturePrivate, 1);
+  video_texture->priv  = priv;
+
+  if (!lay_pipeline(video_texture))
+    {
+      g_warning("Failed to initiate suitable playback pipeline.");
+      return;
+    }
+
+  bus = gst_pipeline_get_bus (GST_PIPELINE (priv->playbin));
+
+  gst_bus_add_signal_watch (bus);
+
+  g_signal_connect_object (bus,
+			   "message::error",
+			   G_CALLBACK (bus_message_error_cb),
+			   video_texture,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::eos",
+			   G_CALLBACK (bus_message_eos_cb),
+			   video_texture,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::tag",
+			   G_CALLBACK (bus_message_tag_cb),
+			   video_texture,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::buffering",
+			   G_CALLBACK (bus_message_buffering_cb),
+			   video_texture,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::duration",
+			   G_CALLBACK (bus_message_duration_cb),
+			   video_texture,
+			   0);
+
+  g_signal_connect_object (bus,
+			   "message::state-changed",
+			   G_CALLBACK (bus_message_state_change_cb),
+			   video_texture,
+			   0);
+
+  gst_object_unref (GST_OBJECT (bus));
+
+  return;
+}
+
+/**
+ * clutter_gst_video_texture_new:
+ *
+ * Creates a video texture.
+ *
+ * Return value: A #ClutterActor implementing a displaying a video texture.
+ */
+ClutterActor*
+clutter_gst_video_texture_new (void)
+{
+  ClutterGstVideoTexture        *video_texture;
+
+  video_texture = g_object_new (CLUTTER_GST_TYPE_VIDEO_TEXTURE, 
+				"tiled", FALSE, 
+				"pixel-format", GL_RGB,
+				/* As RGB below needed for Big Endian */
+				"pixel-type", GL_UNSIGNED_BYTE,
+				NULL);
+
+  return CLUTTER_ACTOR(video_texture);
+}
+
diff --git a/clutter-gst/clutter-gst-video-texture.h b/clutter-gst/clutter-gst-video-texture.h
new file mode 100644
index 0000000..eeb7567
--- /dev/null
+++ b/clutter-gst/clutter-gst-video-texture.h
@@ -0,0 +1,87 @@
+/*
+ * Clutter.
+ *
+ * An OpenGL based 'interactive canvas' library.
+ *
+ * Authored By Matthew Allum  <mallum@openedhand.com>
+ *
+ * Copyright (C) 2006 OpenedHand
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef _HAVE_CLUTTER_GST_VIDEO_TEXTURE_H
+#define _HAVE_CLUTTER_GST_VIDEO_TEXTURE_H
+
+#include <glib-object.h>
+#include <clutter/clutter-actor.h>
+#include <clutter/clutter-texture.h>
+#include <clutter-gst/clutter-gst-media.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+G_BEGIN_DECLS
+
+#define CLUTTER_GST_TYPE_VIDEO_TEXTURE clutter_gst_video_texture_get_type()
+
+#define CLUTTER_GST_VIDEO_TEXTURE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  CLUTTER_GST_TYPE_VIDEO_TEXTURE, ClutterGstVideoTexture))
+
+#define CLUTTER_GST_VIDEO_TEXTURE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  CLUTTER_GST_TYPE_VIDEO_TEXTURE, ClutterGstVideoTextureClass))
+
+#define CLUTTER_GST_IS_VIDEO_TEXTURE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  CLUTTER_GST_TYPE_VIDEO_TEXTURE))
+
+#define CLUTTER_GST_IS_VIDEO_TEXTURE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  CLUTTER_GST_TYPE_VIDEO_TEXTURE))
+
+#define CLUTTER_GST_VIDEO_TEXTURE_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  CLUTTER_GST_TYPE_VIDEO_TEXTURE, ClutterGstVideoTextureClass))
+
+typedef struct _ClutterGstVideoTexture        ClutterGstVideoTexture;
+typedef struct _ClutterGstVideoTextureClass   ClutterGstVideoTextureClass;
+typedef struct _ClutterGstVideoTexturePrivate ClutterGstVideoTexturePrivate;
+
+struct _ClutterGstVideoTexture
+{
+  ClutterTexture              parent;
+  ClutterGstVideoTexturePrivate *priv;
+}; 
+
+struct _ClutterGstVideoTextureClass 
+{
+  ClutterTextureClass parent_class;
+
+  /* Future padding */
+  void (* _clutter_reserved1) (void);
+  void (* _clutter_reserved2) (void);
+  void (* _clutter_reserved3) (void);
+  void (* _clutter_reserved4) (void);
+  void (* _clutter_reserved5) (void);
+  void (* _clutter_reserved6) (void);
+}; 
+
+GType         clutter_gst_video_texture_get_type (void) G_GNUC_CONST;
+ClutterActor *clutter_gst_video_texture_new      (void);
+
+G_END_DECLS
+
+#endif
diff --git a/clutter-gst/clutter-gst.h b/clutter-gst/clutter-gst.h
new file mode 100644
index 0000000..2c37d45
--- /dev/null
+++ b/clutter-gst/clutter-gst.h
@@ -0,0 +1,10 @@
+#ifndef _HAVE_CLUTTER_GST_H
+#define _HAVE_CLUTTER_GST_H
+
+#include <clutter/clutter.h>
+
+#include "clutter-gst-media.h"
+#include "clutter-gst-video-texture.h"
+#include "clutter-gst-audio.h"
+
+#endif
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..69dec01
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,107 @@
+AC_PREREQ(2.53)
+
+# clutter package version number, (as distinct from shared library version)
+# An odd micro number indicates in-progress development, (eg. from CVS)
+# An even micro number indicates a released version.
+m4_define(clutter_gst_version_major, 0)
+m4_define(clutter_gst_version_minor, 1)
+m4_define(clutter_gst_version_micro, 0)
+
+AC_INIT([clutter-gst], 
+       clutter_gst_version_major.clutter_gst_version_minor.clutter_gst_version_micro, 
+        [http://bugzilla.o-hand.com/enter_bug.cgi?product=Clutter-gst])
+AC_CONFIG_SRCDIR([clutter-gst/clutter-gst.h])
+AM_CONFIG_HEADER([config.h])
+
+AM_INIT_AUTOMAKE([1.7])
+
+CLUTTER_GST_MAJORMINOR=clutter_gst_version_major.clutter_gst_version_minor
+AC_SUBST(CLUTTER_GST_MAJORMINOR)
+
+# CURRENT, REVISION, AGE
+# - library source changed -> increment REVISION
+# - interfaces added/removed/changed -> increment CURRENT, REVISION = 0
+# - interfaces added -> increment AGE
+# - interfaces removed -> AGE = 0
+CLUTTER_GST_LT_CURRENT=1
+CLUTTER_GST_LT_REV=0
+CLUTTER_GST_LT_AGE=1
+CLUTTER_GST_LT_VERSION="$CLUTTER_GST_LT_CURRENT:$CLUTTER_GST_LT_REV:$CLUTTER_GST_LT_AGE"
+CLUTTER_GST_LT_LDFLAGS="-version-info $CLUTTER_GST_LT_VERSION"
+
+AC_SUBST(CLUTTER_GST_LT_VERSION)
+AC_SUBST(CLUTTER_GST_LT_LDFLAGS)
+
+dnl ========================================================================
+
+# Checks for programs.
+AC_PROG_CC
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([fcntl.h stdlib.h string.h unistd.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+
+# Checks for library functions.
+AC_FUNC_MALLOC
+AC_FUNC_MMAP
+AC_CHECK_FUNCS([memset munmap strcasecmp strdup])
+
+
+dnl ========================================================================
+
+pkg_modules="clutter-0.1"
+PKG_CHECK_MODULES(CLUTTER_GST, [$pkg_modules])
+
+dnl ========================================================================
+
+GST_MAJORMINOR=0.10
+
+pkg_modules="gstreamer-$GST_MAJORMINOR gstreamer-plugins-base-$GST_MAJORMINOR"
+PKG_CHECK_MODULES(GST, [$pkg_modules])
+
+GST_LIBS="$GST_LIBS -lgstinterfaces-$GST_MAJORMINOR -lgstvideo-$GST_MAJORMINOR -lgstaudio-$GST_MAJORMINOR"
+
+dnl ========================================================================
+
+if test "x$GCC" = "xyes"; then
+        GCC_FLAGS="-g -Wall"
+fi
+
+dnl ========================================================================
+
+GTK_DOC_CHECK([1.0])
+
+dnl ========================================================================
+
+AC_SUBST(GCC_FLAGS)
+AC_SUBST(GST_CFLAGS)
+AC_SUBST(GST_LIBS)
+
+AC_SUBST(CLUTTER_GST_CFLAGS)
+AC_SUBST(CLUTTER_GST_LIBS)
+
+AC_OUTPUT([Makefile
+clutter-gst/Makefile
+examples/Makefile
+doc/Makefile
+doc/reference/Makefile
+doc/reference/version.xml
+clutter-gst.pc
+])
+
+dnl ========================================================================
+
+echo ""
+echo "                    Clutter $VERSION"
+echo "                 ==================="
+echo ""
+echo "                   prefix:   ${prefix}"
+echo ""
+echo "              GTK+ Widget:   ${enable_gtk}"
+echo "            Documentation:   ${enable_gtk_doc}"
+echo ""
diff --git a/doc/Makefile.am b/doc/Makefile.am
new file mode 100644
index 0000000..b68c774
--- /dev/null
+++ b/doc/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS=reference
diff --git a/doc/reference/Makefile.am b/doc/reference/Makefile.am
new file mode 100644
index 0000000..b4d1ae5
--- /dev/null
+++ b/doc/reference/Makefile.am
@@ -0,0 +1,80 @@
+## Process this file with automake to produce Makefile.in
+
+# We require automake 1.6 at least.
+AUTOMAKE_OPTIONS = 1.6
+
+# This is a blank Makefile.am for using gtk-doc.
+# Copy this to your project's API docs directory and modify the variables to
+# suit your project. See the GTK+ Makefiles in gtk+/docs/reference for examples
+# of using the various options.
+
+# The name of the module, e.g. 'glib'.
+DOC_MODULE=clutter-gst
+
+# The top-level SGML file. You can change this if you want to.
+DOC_MAIN_SGML_FILE=clutter-gst-docs.sgml
+
+# The directory containing the source code. Relative to $(srcdir).
+# gtk-doc will search all .c & .h files beneath here for inline comments
+# documenting the functions and macros.
+# e.g. DOC_SOURCE_DIR=../../../gtk
+DOC_SOURCE_DIR=../../clutter-gst
+
+# Extra options to pass to gtkdoc-scangobj. Not normally needed.
+SCANGOBJ_OPTIONS=
+
+# Extra options to supply to gtkdoc-scan.
+# e.g. SCAN_OPTIONS=--deprecated-guards="GTK_DISABLE_DEPRECATED" 
+SCAN_OPTIONS=
+
+# Extra options to supply to gtkdoc-mkdb.
+# e.g. MKDB_OPTIONS=--sgml-mode --output-format=xml
+MKDB_OPTIONS=--sgml-mode --output-format=xml
+
+# Extra options to supply to gtkdoc-mktmpl
+# e.g. MKTMPL_OPTIONS=--only-section-tmpl
+MKTMPL_OPTIONS=
+
+# Extra options to supply to gtkdoc-fixref. Not normally needed.
+# e.g. FIXXREF_OPTIONS=--extra-dir=../gdk-pixbuf/html --extra-dir=../gdk/html
+FIXXREF_OPTIONS=
+
+# Used for dependencies. The docs will be rebuilt if any of these change.
+# e.g. HFILE_GLOB=$(top_srcdir)/gtk/*.h
+# e.g. CFILE_GLOB=$(top_srcdir)/gtk/*.c
+HFILE_GLOB=$(top_srcdir)/clutter-gst/*.h
+CFILE_GLOB=$(top_srcdir)/clutter-gst/*.c
+
+# Header files to ignore when scanning.
+# e.g. IGNORE_HFILES=gtkdebug.h gtkintl.h
+IGNORE_HFILES=
+
+# Images to copy into HTML directory.
+# e.g. HTML_IMAGES=$(top_srcdir)/gtk/stock-icons/stock_about_24.png
+HTML_IMAGES=
+
+# Extra SGML files that are included by $(DOC_MAIN_SGML_FILE).
+# e.g. content_files=running.sgml building.sgml changes-2.0.sgml
+content_files= version.xml
+
+# SGML files where gtk-doc abbrevations (#GtkWidget) are expanded
+# These files must be listed here *and* in content_files
+# e.g. expand_content_files=running.sgml
+expand_content_files=
+
+# CFLAGS and LDFLAGS for compiling gtkdoc-scangobj with your library.
+# Only needed if you are using gtkdoc-scangobj to dynamically query widget
+# signals and properties.
+# e.g. INCLUDES=-I$(top_srcdir) -I$(top_builddir) $(GTK_DEBUG_FLAGS)
+# e.g. GTKDOC_LIBS=$(top_builddir)/gtk/$(gtktargetlib)
+
+# FIXME:  $(GST_CFLAGS) needed for clutter_media metadata - togo..
+INCLUDES=-I$(top_srcdir) $(CLUTTER_GST_CFLAGS) $(GST_CFLAGS)
+GTKDOC_LIBS=$(top_builddir)/clutter-gst/libclutter-gst-@CLUTTER_MAJORMINOR@.la $(CLUTTER_GST_LIBS)
+
+# This includes the standard gtk-doc make rules, copied by gtkdocize.
+include $(top_srcdir)/gtk-doc.make
+
+# Other files to distribute
+# e.g. EXTRA_DIST += version.xml.in
+EXTRA_DIST += version.xml.in
diff --git a/examples/Makefile.am b/examples/Makefile.am
new file mode 100644
index 0000000..6afbf65
--- /dev/null
+++ b/examples/Makefile.am
@@ -0,0 +1,29 @@
+noinst_PROGRAMS = video-player video-cube audio
+
+INCLUDES = -I$(top_srcdir)/
+
+video_player_SOURCES = video-player.c
+video_player_CFLAGS = $(CLUTTER_GST_CFLAGS) $(GST_CFLAGS)
+video_player_LDFLAGS = \
+    $(CLUTTER_GST_LIBS) \
+    $(GST_LIBS)   \
+    $(top_builddir)/clutter-gst/libclutter-gst-@CLUTTER_GST_MAJORMINOR@.la 
+
+video_cube_SOURCES = video-cube.c
+video_cube_CFLAGS = $(CLUTTER_GST_CFLAGS) $(GST_CFLAGS)
+video_cube_LDFLAGS = \
+    $(CLUTTER_LIBS) \
+    $(GST_LIBS)   \
+    $(top_builddir)/clutter-gst/libclutter-gst-@CLUTTER_GST_MAJORMINOR@.la 
+
+audio_SOURCES = audio.c
+audio_CFLAGS = $(CLUTTER_GST_CFLAGS) $(GST_CFLAGS)
+audio_LDFLAGS = \
+    $(CLUTTER_GST_LIBS) \
+    $(GST_LIBS)   \
+    $(top_builddir)/clutter-gst/libclutter-gst-@CLUTTER_GST_MAJORMINOR@.la 
+
+EXTRA_DIST = media-actions-pause.png  \
+             media-actions-start.png  \
+             vid-panel.png            \
+             README 
diff --git a/examples/README b/examples/README
new file mode 100644
index 0000000..8169030
--- /dev/null
+++ b/examples/README
@@ -0,0 +1,21 @@
+examples/
+===
+
+This directory contains a number of simple hacks come tests come
+examples come clutter demos.
+
+There are:
+
+ o video-player.
+ 
+   Simple fullscreen video player. 
+
+   - Move mouse to see controls.
+   - Hit q or Esc to exit, p to toggle pause state.
+   - Has some useless cheesy effects built in.
+      - Hit e to flip the video. 
+
+ o video-cube.
+ 
+   Pure evil. A nasty hack to do a video cube with clutter.
+   Could be done much nicer.
diff --git a/examples/audio.c b/examples/audio.c
new file mode 100644
index 0000000..095cf07
--- /dev/null
+++ b/examples/audio.c
@@ -0,0 +1,46 @@
+#include <clutter-gst/clutter-gst.h>
+
+int
+main (int argc, char *argv[])
+{
+  ClutterTimeline  *timeline;
+  ClutterActor     *stage, *label;
+  ClutterColor      stage_color = { 0xcc, 0xcc, 0xcc, 0xff };
+  ClutterGstAudio  *audio;
+
+  if (argc < 2) {
+          g_error ("Usage: %s URI", argv[0]);
+          return 1;
+  }
+  
+  clutter_init (&argc, &argv);
+
+  stage = clutter_stage_get_default ();
+
+  clutter_stage_set_color (CLUTTER_STAGE (stage),
+		           &stage_color);
+
+  /* Make a label */
+  label = clutter_label_new ();
+  clutter_label_set_text (CLUTTER_LABEL (label), "Music");
+  clutter_actor_set_position (label, 100, 100);
+  clutter_group_add (CLUTTER_GROUP (stage), label);
+
+  /* Make a timeline */
+  timeline = clutter_timeline_new (100, 30); /* num frames, fps */
+  g_object_set(timeline, "loop", TRUE, 0);  
+
+  /* Set up audio player */
+  audio = clutter_gst_audio_new ();
+  clutter_gst_media_set_uri (CLUTTER_GST_MEDIA (audio), argv[1]);
+  clutter_gst_media_set_playing (CLUTTER_GST_MEDIA (audio), TRUE);
+
+  /* start the timeline */
+  clutter_timeline_start (timeline);
+
+  clutter_group_show_all (CLUTTER_GROUP (stage));
+
+  clutter_main();
+
+  return 0;
+}
diff --git a/examples/media-actions-pause.png b/examples/media-actions-pause.png
new file mode 100644
index 0000000..38614e1
--- /dev/null
+++ b/examples/media-actions-pause.png
diff --git a/examples/media-actions-start.png b/examples/media-actions-start.png
new file mode 100644
index 0000000..b3c6170
--- /dev/null
+++ b/examples/media-actions-start.png
diff --git a/examples/vid-panel.png b/examples/vid-panel.png
new file mode 100644
index 0000000..d7c3e18
--- /dev/null
+++ b/examples/vid-panel.png
diff --git a/examples/video-cube.c b/examples/video-cube.c
new file mode 100644
index 0000000..8157968
--- /dev/null
+++ b/examples/video-cube.c
@@ -0,0 +1,271 @@
+/* HACK HACK. HACK.  
+ * This is just a quick hack to see if a 3D type video cube
+ * would be possible with clutter. It needs many hacks cleaning.
+ */
+
+#include <clutter-gst/clutter-gst.h>
+
+#include <math.h> 		/* for M_PI */
+
+#define WINWIDTH 800
+#define WINHEIGHT 600
+
+/* lazy globals */
+static float xrot, yrot, zrot;
+
+/* Avoid needing GLUT perspective call */
+static void
+frustum (GLfloat left,
+	 GLfloat right,
+	 GLfloat bottom,
+	 GLfloat top,
+	 GLfloat nearval,
+	 GLfloat farval)
+{
+  GLfloat x, y, a, b, c, d;
+  GLfloat m[16];
+
+  x = (2.0 * nearval) / (right - left);
+  y = (2.0 * nearval) / (top - bottom);
+  a = (right + left) / (right - left);
+  b = (top + bottom) / (top - bottom);
+  c = -(farval + nearval) / ( farval - nearval);
+  d = -(2.0 * farval * nearval) / (farval - nearval);
+
+#define M(row,col)  m[col*4+row]
+  M(0,0) = x;     M(0,1) = 0.0F;  M(0,2) = a;      M(0,3) = 0.0F;
+  M(1,0) = 0.0F;  M(1,1) = y;     M(1,2) = b;      M(1,3) = 0.0F;
+  M(2,0) = 0.0F;  M(2,1) = 0.0F;  M(2,2) = c;      M(2,3) = d;
+  M(3,0) = 0.0F;  M(3,1) = 0.0F;  M(3,2) = -1.0F;  M(3,3) = 0.0F;
+#undef M
+
+  glMultMatrixf (m);
+}
+
+static void
+perspective (GLfloat fovy,
+	     GLfloat aspect,
+	     GLfloat zNear,
+	     GLfloat zFar)
+{
+  GLfloat xmin, xmax, ymin, ymax;
+
+  ymax = zNear * tan (fovy * M_PI / 360.0);
+  ymin = -ymax;
+  xmin = ymin * aspect;
+  xmax = ymax * aspect;
+
+  frustum (xmin, xmax, ymin, ymax, zNear, zFar);
+}
+
+
+/* video texture subclass */
+
+#define CLUTTER_TYPE_VIDEO_TEXTURE_CUBE clutter_video_texture_cube_get_type()
+
+#define CLUTTER_VIDEO_TEXTURE_CUBE(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+  CLUTTER_TYPE_VIDEO_TEXTURE_CUBE, ClutterVideoTextureCube))
+
+#define CLUTTER_VIDEO_TEXTURE_CUBE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+  CLUTTER_TYPE_VIDEO_TEXTURE_CUBE, ClutterVideoTextureCubeClass))
+
+#define CLUTTER_IS_VIDEO_TEXTURE_CUBE(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+  CLUTTER_TYPE_VIDEO_TEXTURE_CUBE))
+
+#define CLUTTER_IS_VIDEO_TEXTURE_CUBE_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+  CLUTTER_TYPE_VIDEO_TEXTURE_CUBE))
+
+#define CLUTTER_VIDEO_TEXTURE_CUBE_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+  CLUTTER_TYPE_VIDEO_TEXTURE_CUBE, ClutterVideoTextureCubeClass))
+
+typedef struct ClutterVideoTextureCubePrivate ClutterVideoTextureCubePrivate ;
+
+typedef struct ClutterVideoTextureCube
+{
+  ClutterGstVideoTexture          parent;
+  ClutterVideoTextureCubePrivate *priv;
+
+} 
+ClutterVideoTextureCube;
+
+typedef struct ClutterVideoTextureCubeClass 
+{
+  ClutterGstVideoTextureClass parent_class;
+} 
+ClutterVideoTextureCubeClass;
+
+GType clutter_video_texture_cube_get_type (void);
+
+G_DEFINE_TYPE (ClutterVideoTextureCube, clutter_video_texture_cube, CLUTTER_GST_TYPE_VIDEO_TEXTURE);
+
+
+static void
+clutter_video_texture_cube_paint (ClutterActor *self)
+{
+  if (clutter_texture_get_pixbuf (CLUTTER_TEXTURE(self)) == NULL)
+    return;
+
+  if (!CLUTTER_ACTOR_IS_REALIZED (CLUTTER_ACTOR(self)))
+      clutter_actor_realize (CLUTTER_ACTOR(self));
+
+  if (!clutter_texture_has_generated_tiles (CLUTTER_TEXTURE(self)))
+    return;
+
+  /* HACK: sets up a 3D tranform matrix other than regular 2D one */
+  /* FIXME: figure out how to nicely combine both within clutter */
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+
+  perspective (45.0f, 
+	       (GLfloat)WINWIDTH/(GLfloat)WINHEIGHT, 
+	       0.1f,
+	       100.0f);
+
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity();
+
+  /* back camera out a little */
+  glTranslatef(0.0f,0.0f,-3.0f);
+
+  glEnable(GL_DEPTH_TEST);
+  glEnable(GL_TEXTURE_2D);
+
+  glShadeModel(GL_SMOOTH);
+  glClearDepth(1.0f);
+  glDepthFunc(GL_LEQUAL);
+  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
+
+  glRotatef(xrot,1.0f,0.0f,0.0f);
+  glRotatef(yrot,0.0f,1.0f,0.0f);
+  glRotatef(zrot,0.0f,0.0f,1.0f);
+
+  /* HACK: Cheat as just bind to first tiled as squared   */
+  clutter_texture_bind_tile (CLUTTER_TEXTURE(self), 0);
+
+  glBegin(GL_QUADS);
+  // Front Face
+  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
+  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
+  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
+  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
+  // Back Face
+  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
+  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
+  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
+  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
+  // Top Face
+  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
+  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
+  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
+  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
+  // Bottom Face
+  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
+  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
+  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
+  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
+  // Right face
+  glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);
+  glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f,  1.0f, -1.0f);
+  glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f,  1.0f,  1.0f);
+  glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f,  1.0f);
+  // Left Face
+  glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);
+  glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f,  1.0f);
+  glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f,  1.0f,  1.0f);
+  glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f,  1.0f, -1.0f);
+  glEnd();
+
+
+  /* HACK: reset to regular transform */
+#if 0
+  glMatrixMode (GL_PROJECTION);
+  glLoadIdentity ();
+  glOrtho (0, WINWIDTH, WINHEIGHT, 0, -1, 1);
+  glMatrixMode (GL_MODELVIEW);
+  glLoadIdentity ();
+#endif
+
+  /* rotate */
+  xrot+=1.0f;
+  yrot+=1.0f;
+  zrot+=1.0f;
+}
+
+static void
+clutter_video_texture_cube_class_init (ClutterVideoTextureCubeClass *klass)
+{
+  GObjectClass        *gobject_class;
+  ClutterActorClass *actor_class;
+
+  gobject_class = (GObjectClass*)klass;
+  actor_class = (ClutterActorClass*)klass;
+
+  actor_class->paint = clutter_video_texture_cube_paint;
+}
+
+static void
+clutter_video_texture_cube_init (ClutterVideoTextureCube *self)
+{
+
+}
+
+ClutterActor*
+clutter_video_texture_cube_new (GError **err)
+{
+  return CLUTTER_ACTOR(g_object_new (CLUTTER_TYPE_VIDEO_TEXTURE_CUBE, 
+				       /* "tiled", FALSE, */
+				       NULL));
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  ClutterActor      *label, *texture, *vtexture; 
+  ClutterActor      *stage;
+  GdkPixbuf         *pixbuf;
+  GError            *err = NULL;
+
+  if (argc < 2)
+    g_error("%s <video file>", argv[0]);
+
+  clutter_init (&argc, &argv);
+
+  stage = clutter_stage_get_default ();
+  g_signal_connect (stage, "key-press-event",
+		    G_CALLBACK (clutter_main_quit), NULL);
+
+  pixbuf = gdk_pixbuf_new_from_file ("clutter-logo-800x600.png", NULL);
+
+  if (!pixbuf)
+    g_error("pixbuf load failed");
+
+  clutter_actor_set_size (stage, 
+			    WINWIDTH, WINHEIGHT);
+
+  texture = clutter_texture_new_from_pixbuf (pixbuf);
+
+  vtexture = clutter_video_texture_cube_new (&err);
+
+  if (vtexture == NULL || err != NULL)
+    {
+      g_error("failed to create vtexture, err: %s", err->message);
+    }
+
+  clutter_gst_media_set_filename (CLUTTER_GST_MEDIA(vtexture), argv[1]);
+
+  clutter_group_add (CLUTTER_GROUP (stage), texture);
+  clutter_group_add (CLUTTER_GROUP (stage), vtexture);
+  clutter_group_show_all (CLUTTER_GROUP (stage));
+
+  clutter_gst_media_set_playing(CLUTTER_GST_MEDIA(vtexture), TRUE);
+
+  clutter_main();
+
+  return 0;
+}
diff --git a/examples/video-player.c b/examples/video-player.c
new file mode 100644
index 0000000..3cdea78
--- /dev/null
+++ b/examples/video-player.c
@@ -0,0 +1,381 @@
+#include <clutter-gst/clutter-gst.h>
+
+#define SEEK_H 20
+#define SEEK_W 690
+
+typedef struct VideoApp
+{
+  ClutterActor *vtexture;
+
+  ClutterActor    *control, *control_bg, *control_play, *control_pause, 
+    *control_seek1, *control_seek2, *control_seekbar, *control_label;
+  gboolean         controls_showing, paused;
+  guint            controls_timeout;
+  ClutterTimeline *controls_tl, *effect1_tl;
+}
+VideoApp;
+
+static void
+show_controls (VideoApp *app, gboolean vis);
+
+void
+control_tl_cb (ClutterTimeline *timeline, 
+	       gint             frame_num, 
+	       VideoApp        *app)
+{
+  guint8 opacity;
+
+  clutter_group_show_all (CLUTTER_GROUP (app->control));
+  clutter_actor_hide (app->paused ? app->control_pause : app->control_play);
+  clutter_actor_show (app->paused ? app->control_play : app->control_pause);
+
+  opacity = ( frame_num * 0xde ) / clutter_timeline_get_n_frames(timeline);
+
+  if (!app->controls_showing)
+    opacity = 0xde - opacity;
+  
+  clutter_actor_set_opacity (app->control, opacity);
+}
+
+void
+control_tl_complete_cb (ClutterTimeline *timeline, 
+			VideoApp        *app)
+{
+  if (!app->controls_showing)
+      clutter_group_hide_all (CLUTTER_GROUP (app->control));
+
+  app->controls_timeout = 0;
+}
+
+static gboolean
+controls_timeout_cb (VideoApp *app)
+{
+  show_controls (app, FALSE);
+  return FALSE;
+}
+
+static void
+show_controls (VideoApp *app, gboolean vis)
+{
+  if (clutter_timeline_is_playing (app->controls_tl))
+    return;
+
+  if (vis == TRUE && app->controls_showing == FALSE)
+    {
+      app->controls_showing = TRUE;
+      clutter_timeline_start (app->controls_tl);
+
+      app->controls_timeout = g_timeout_add (5 * 1000,  
+					     (GSourceFunc)controls_timeout_cb,
+					     app);
+      return;
+    }
+
+  if (vis == TRUE && app->controls_showing == TRUE)
+    {
+      if (app->controls_timeout)
+	{
+	  g_source_remove (app->controls_timeout);
+
+	  app->controls_timeout 
+	    = g_timeout_add (5 * 1000,  
+			     (GSourceFunc)controls_timeout_cb,
+			     app);
+	}
+      return;
+    }
+
+  if (vis == FALSE && app->controls_showing == TRUE)
+    {
+      app->controls_showing = FALSE;
+      clutter_timeline_start (app->controls_tl);
+      return;
+    }
+}
+
+void
+toggle_pause_state (VideoApp *app)
+{
+  if (app->paused)
+    {
+      clutter_gst_media_set_playing (CLUTTER_GST_MEDIA(app->vtexture), 
+				     TRUE);
+      app->paused = FALSE;
+      clutter_actor_hide (app->control_play);
+      clutter_actor_show (app->control_pause);
+    }
+  else
+    {
+      clutter_gst_media_set_playing (CLUTTER_GST_MEDIA(app->vtexture), 
+				     FALSE);
+      app->paused = TRUE;
+      clutter_actor_hide (app->control_pause);
+      clutter_actor_show (app->control_play);
+    }
+}
+
+void 
+input_cb (ClutterStage *stage, 
+	  ClutterEvent *event,
+	  gpointer      user_data)
+{
+  VideoApp *app = (VideoApp*)user_data;
+
+  switch (event->type)
+    {
+    case CLUTTER_MOTION:
+      show_controls (app, TRUE);
+      break;
+    case CLUTTER_BUTTON_PRESS:
+      if (app->controls_showing)
+	{
+	  ClutterActor       *actor;
+	  ClutterButtonEvent *bev = (ClutterButtonEvent *) event;
+
+	  actor 
+	    = clutter_stage_get_actor_at_pos 
+	                         (CLUTTER_STAGE(clutter_stage_get_default()),
+				  bev->x, bev->y);
+
+	  if (actor == app->control_pause || actor == app->control_play)
+	    {
+	      toggle_pause_state (app);
+	      return;
+	    }
+
+	  if (actor == app->control_seek1 
+	      || actor == app->control_seek2
+	      || actor == app->control_seekbar)
+	    {
+	      gint x, y, dist, pos;
+
+	      clutter_actor_get_abs_position (app->control_seekbar, &x, &y);
+
+	      dist = bev->x - x;
+
+	      CLAMP(dist, 0, SEEK_W);
+
+	      pos = (dist * clutter_gst_media_get_duration 
+                               (CLUTTER_GST_MEDIA(app->vtexture))) / SEEK_W;
+
+	      clutter_gst_media_set_position (CLUTTER_GST_MEDIA(app->vtexture),
+					      pos);
+	    }
+	}
+      break;
+    case CLUTTER_KEY_RELEASE:
+      {
+	ClutterKeyEvent* kev = (ClutterKeyEvent *) event;
+	
+	switch (clutter_key_event_symbol (kev))
+	  {
+	  case CLUTTER_q:
+	  case CLUTTER_Escape:
+	    clutter_main_quit ();
+	    break;
+	  case CLUTTER_e:
+	    if (!clutter_timeline_is_playing (app->effect1_tl))
+	      clutter_timeline_start (app->effect1_tl);
+	    break;
+	  default:
+	    toggle_pause_state (app);
+	    break;
+	  }
+      }
+    default:
+      break;
+    }
+}
+
+void
+size_change (ClutterTexture *texture, 
+	     gint             width,
+	     gint             height,
+	     gpointer         user_data)
+{
+  ClutterActor  *stage;
+  ClutterGeometry  stage_geom;
+  gint             vid_width, vid_height, new_y, new_height;
+
+  clutter_texture_get_base_size (texture, &vid_width, &vid_height);
+
+  new_height = ( vid_height * CLUTTER_STAGE_WIDTH() ) / vid_width;
+  new_y      = ( (gint)CLUTTER_STAGE_HEIGHT() - new_height) / 2;
+
+  clutter_actor_set_position (CLUTTER_ACTOR (texture), 0, new_y);
+
+  clutter_actor_set_size (CLUTTER_ACTOR (texture),
+			  CLUTTER_STAGE_WIDTH(),
+			  new_height);
+}
+
+void 
+tick (GObject      *object,
+      GParamSpec   *pspec,
+      VideoApp     *app)
+{
+  ClutterGstVideoTexture *vtex;
+  gint                    w, h, position, duration, seek_w;
+  gchar                   buf[256];
+
+  vtex = CLUTTER_GST_VIDEO_TEXTURE(object);
+
+  position = clutter_gst_media_get_position (CLUTTER_GST_MEDIA(vtex));
+  duration = clutter_gst_media_get_duration (CLUTTER_GST_MEDIA(vtex));
+
+  if (duration == 0 || position == 0)
+    return;
+
+  clutter_actor_set_size (app->control_seekbar, 
+			  (position * SEEK_W) / duration, 
+			  SEEK_H);  
+}
+
+int
+effect1_tl_cb (ClutterTimeline *timeline, 
+	       gint             frame_num, 
+	       VideoApp        *app)
+{
+  clutter_actor_rotate_y (app->vtexture,
+			  frame_num * 12,
+			  CLUTTER_STAGE_WIDTH()/2,
+			  0);
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  VideoApp            *app = NULL;
+  ClutterActor        *stage;
+  ClutterColor         stage_color = { 0x00, 0x00, 0x00, 0x00 };
+  ClutterColor         control_color1 = { 73, 74, 77, 0xee };
+  ClutterColor         control_color2 = { 0xcc, 0xcc, 0xcc, 0xff };
+  GdkPixbuf           *pixb;
+  gint                 x,y;
+
+  if (argc < 2)
+    g_error("%s <video file>", argv[0]);
+
+  clutter_init (&argc, &argv);
+
+  stage = clutter_stage_get_default ();
+  g_object_set (stage, "fullscreen", TRUE, NULL);
+  clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); 
+
+  app = g_new0(VideoApp, 1);
+
+  app->vtexture = clutter_gst_video_texture_new ();
+
+  if (app->vtexture == NULL)
+    {
+      g_error("failed to create vtexture");
+    }
+
+  /* Dont let the underlying pixbuf dictate size */
+  g_object_set (G_OBJECT(app->vtexture), "sync-size", FALSE, NULL);
+
+  /* Handle it ourselves so can scale up for fullscreen better */
+  g_signal_connect (CLUTTER_TEXTURE(app->vtexture), 
+		    "size-change",
+		    G_CALLBACK (size_change), NULL);
+
+  /* Load up out video texture */
+  clutter_gst_media_set_filename(CLUTTER_GST_MEDIA(app->vtexture), argv[1]);
+
+  /* Create the control UI */
+  app->control = clutter_group_new ();
+
+  pixb = gdk_pixbuf_new_from_file ("vid-panel.png", NULL);
+
+  if (pixb == NULL)
+    g_error("Unable to load vid-panel.png");
+
+  app->control_bg = clutter_texture_new_from_pixbuf (pixb);
+  
+  pixb = gdk_pixbuf_new_from_file("media-actions-start.png", NULL);
+
+  if (pixb == NULL)
+    g_error("Unable to load media-actions-start.png");
+
+  app->control_play = clutter_texture_new_from_pixbuf (pixb);
+
+  pixb = gdk_pixbuf_new_from_file("media-actions-pause.png", NULL);
+
+  if (pixb == NULL)
+    g_error("Unable to load media-actions-pause.png");
+
+  app->control_pause = clutter_texture_new_from_pixbuf (pixb);
+
+  app->control_seek1   = clutter_rectangle_new_with_color (&control_color1);
+  app->control_seek2   = clutter_rectangle_new_with_color (&control_color2);
+  app->control_seekbar = clutter_rectangle_new_with_color (&control_color1);
+  clutter_actor_set_opacity (app->control_seekbar, 0x99);
+
+  app->control_label 
+    = clutter_label_new_with_text("Sans Bold 24", 
+				  g_path_get_basename(argv[1]));
+  clutter_label_set_color (CLUTTER_LABEL(app->control_label), &control_color1);
+  
+  clutter_group_add_many (CLUTTER_GROUP (app->control), 
+			  app->control_bg, 
+			  app->control_play, 
+			  app->control_pause,
+			  app->control_seek1,
+			  app->control_seek2,
+			  app->control_seekbar,
+			  app->control_label,
+			  NULL);
+
+  x = (CLUTTER_STAGE_WIDTH() - clutter_actor_get_width(app->control))/2;
+  y = CLUTTER_STAGE_HEIGHT() - (CLUTTER_STAGE_HEIGHT()/3);
+    
+  clutter_actor_set_position (app->control, x, y);
+  clutter_actor_set_opacity (app->control, 0xee);
+
+  clutter_actor_set_position (app->control_play, 30, 30);
+  clutter_actor_set_position (app->control_pause, 30, 30);
+
+  clutter_actor_set_size (app->control_seek1, SEEK_W+10, SEEK_H+10);
+  clutter_actor_set_position (app->control_seek1, 200, 100);
+  clutter_actor_set_size (app->control_seek2, SEEK_W, SEEK_H);
+  clutter_actor_set_position (app->control_seek2, 205, 105);
+  clutter_actor_set_size (app->control_seekbar, 0, SEEK_H);
+  clutter_actor_set_position (app->control_seekbar, 205, 105);
+
+  clutter_actor_set_position (app->control_label, 200, 40);
+
+  /* Add control UI to stage */
+  clutter_group_add_many (CLUTTER_GROUP (stage), 
+			  app->vtexture, app->control, NULL);
+
+  /* hook up a time line for fading controls */
+  app->controls_tl = clutter_timeline_new (10, 30);
+  g_signal_connect (app->controls_tl, "new-frame", 
+		    G_CALLBACK (control_tl_cb), app);
+  g_signal_connect (app->controls_tl, "completed", 
+		    G_CALLBACK (control_tl_complete_cb), app);
+
+
+  app->effect1_tl = clutter_timeline_new (30, 90);
+  g_signal_connect (app->effect1_tl, "new-frame", 
+		    G_CALLBACK (effect1_tl_cb), app);
+
+  /* Hook up other events */
+  g_signal_connect (stage, "input-event",
+		    G_CALLBACK (input_cb), 
+		    app);
+
+  g_signal_connect (app->vtexture,
+		    "notify::position",
+		    G_CALLBACK (tick),
+		    app);
+
+  clutter_gst_media_set_playing (CLUTTER_GST_MEDIA(app->vtexture), TRUE);
+
+  clutter_group_show_all (CLUTTER_GROUP (stage));
+
+  clutter_main();
+
+  return 0;
+}
diff --git a/gtk-doc.make b/gtk-doc.make
new file mode 120000
index 0000000..0870846
--- /dev/null
+++ b/gtk-doc.make
@@ -0,0 +1 @@
+/usr/share/gtk-doc/data/gtk-doc.make
\ No newline at end of file