diff --git a/Makefile.am b/Makefile.am
index 02eff273dec9e756cf5bdfd69fceb99d6670ce80..da47c8abea229f38d33b69ad11aaab63355ccdd6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -2,14 +2,7 @@
ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = libs src ringtones skins doc
+SUBDIRS = libs src ringtones skins
EXTRA_DIST = m4/*.m4 tools/*.sh platform/* images/* README.gentoo
-.PHONY: doc
-doc:
- $(MAKE) -C doc doc
-
-.PHONY: doxygen-trac
-doxygen-trac:
- $(MAKE) -C doc/doxygen doxygen-trac
\ No newline at end of file
diff --git a/configure.ac b/configure.ac
index cf2513853a1361e8937c760af422773a94e9eeb1..d8c0d430ac307de8679a34cc8cfc35ba2065c668 100644
--- a/configure.ac
+++ b/configure.ac
@@ -39,7 +39,12 @@ AC_CONFIG_FILES([src/Makefile \
src/audio/codecs/ilbc/Makefile \
src/config/Makefile \
src/dbus/Makefile \
- src/zeroconf/Makefile])
+ src/zeroconf/Makefile \
+ src/video/Makefile \
+ src/video/VideoCodec/Makefile \
+ src/video/V4L/Makefile \
+ src/memmanager/Makefile \
+ src/mixer/Makefile])
AC_CONFIG_FILES([skins/Makefile \
skins/metal/Makefile \
diff --git a/doc/sflphone_video/abstract.odt b/doc/sflphone_video/abstract.odt
new file mode 100644
index 0000000000000000000000000000000000000000..e9263f9cff27f087345e37418b363eba096349b0
Binary files /dev/null and b/doc/sflphone_video/abstract.odt differ
diff --git a/doc/sflphone_video/ressources.odt b/doc/sflphone_video/ressources.odt
new file mode 100644
index 0000000000000000000000000000000000000000..1c9cfed4cc410d060e1f4fc2bc4b959ccf66764b
Binary files /dev/null and b/doc/sflphone_video/ressources.odt differ
diff --git a/sflphone-gtk/configure.ac b/sflphone-gtk/configure.ac
index 79d3e6a4ea13beb787fccbe014f9c4f1180d9bcb..ea150b2d62bd30f12d73c16fb6c83eee1863a39b 100644
--- a/sflphone-gtk/configure.ac
+++ b/sflphone-gtk/configure.ac
@@ -26,6 +26,7 @@ PKG_CHECK_MODULES(DEPS, \
dbus-glib-1 >= 0.35 \
gtk+-2.0 >= 2.2 \
glib-2.0 >= 2.2 \
+ gtkglext-1.0 >= 1.0.0 \
)
diff --git a/sflphone-gtk/src/Makefile.am b/sflphone-gtk/src/Makefile.am
index cc6de1e5501e446e7825666ca942af64bd9d4061..9c2fc02c5fede5645dc0ec686b310e7beea4487d 100644
--- a/sflphone-gtk/src/Makefile.am
+++ b/sflphone-gtk/src/Makefile.am
@@ -16,7 +16,9 @@ sflphone_gtk_SOURCES = \
marshaller.c \
sliders.c \
statusicon.c \
- codeclist.c
+ codeclist.c \
+ glwidget.c \
+ MemManager.c
noinst_HEADERS = actions.h dbus.h mainwindow.h calllist.h dialpad.h codeclist.h\
callmanager-glue.h configurationmanager-glue.h instance-glue.h menus.h calltree.h screen.h configwindow.h \
diff --git a/sflphone-gtk/src/MemManager.c b/sflphone-gtk/src/MemManager.c
new file mode 100644
index 0000000000000000000000000000000000000000..e6f450ea4c88c9ffeaffa9c360bb9587e2c10252
--- /dev/null
+++ b/sflphone-gtk/src/MemManager.c
@@ -0,0 +1,21 @@
+#include "MemManager.h"
+
+MemKey* createMemKeyFromChar( char* key )
+{
+ return 0;
+}
+
+MemKey* initSpace( MemKey *key )
+{
+ return 0;
+}
+
+int fetchData( MemKey *key, MemData *data )
+{
+ return 0;
+}
+
+int putData( MemKey *key, MemData *data )
+{
+ return 0;
+}
\ No newline at end of file
diff --git a/sflphone-gtk/src/MemManager.h b/sflphone-gtk/src/MemManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..77091e9f02dfc446601a97903d2ea4fd0b5126f1
--- /dev/null
+++ b/sflphone-gtk/src/MemManager.h
@@ -0,0 +1,26 @@
+#ifndef MEMMANAGER_H_
+#define MEMMANAGER_H_
+
+typedef struct {
+ char* data;
+ int size;
+}MemData;
+
+typedef struct
+{
+ int key;
+ char* description;
+ int size;
+ char* BaseAdd;
+}MemKey;
+
+
+MemKey* createMemKeyFromChar( char* key );
+
+MemKey* initSpace( MemKey *key );
+
+int fetchData( MemKey *key, MemData *data );
+
+int putData( MemKey *key, MemData *data );
+
+#endif /*MEMMANAGER_H_*/
diff --git a/sflphone-gtk/src/glwidget.c b/sflphone-gtk/src/glwidget.c
new file mode 100644
index 0000000000000000000000000000000000000000..bdbda9f89eca7a54506f9239aa7c4ed3a16883cf
--- /dev/null
+++ b/sflphone-gtk/src/glwidget.c
@@ -0,0 +1,71 @@
+#include <glwidget.h>
+
+//! Callback Function to draw the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean draw(GtkWidget* widget, gpointer data)
+{
+ return TRUE;
+}
+
+//! Callback Function to reshape the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param ev a pointer to the event data
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean reshape(GtkWidget* widget, GdkEventConfigure* ev, gpointer data)
+{
+ return TRUE;
+}
+
+//! Callback Function to initialise the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean init(GtkWidget* widget, gpointer data)
+{
+ return TRUE;
+}
+
+//! Function to force a redraw of the widget
+void redraw(GtkWidget* widget)
+{
+}
+
+//! Function that creates the opengl widget with all the proper information
+/*!
+ * \return the created widget
+ */
+GtkWidget* createGLWidget()
+{ return NULL;
+}
+
+//! Draws the images from the local capture source
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean drawLocal(GtkWidget* widget, gpointer data)
+{
+ return TRUE;
+}
+
+
+//! Draws the images from the remote source
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean drawRemote(GtkWidget* widget, gpointer data)
+{
+ return TRUE;
+}
diff --git a/sflphone-gtk/src/glwidget.h b/sflphone-gtk/src/glwidget.h
new file mode 100644
index 0000000000000000000000000000000000000000..3f1bf496f4f606f25d768258b9718ecacec1b306
--- /dev/null
+++ b/sflphone-gtk/src/glwidget.h
@@ -0,0 +1,84 @@
+/* Generated by Together */
+
+#ifndef GLWIDGET_H
+#define GLWIDGET_H
+
+#include <gtk/gtkgl.h>
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+#include "MemManager.h"
+
+//! Memory manager
+//MemManager* sharedMemory;
+
+//! Key to access the shared Memory space that refers to the remote data
+MemKey* remoteKey;
+
+//! Key to access the shared Memory space that refers to the local data
+MemKey* localKey;
+
+//! Remote data buffer
+unsigned char * remoteBuff;
+
+//! Local data buffer
+unsigned char * localBuff;
+
+//! Configuration information for the gl widget
+GdkGLConfig* glconfig;
+
+//! The glwidget it self
+GtkWidget* drawing_area;
+
+//! Callback Function to draw the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean draw(GtkWidget* widget, gpointer data);
+
+//! Callback Function to reshape the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param ev a pointer to the event data
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean reshape(GtkWidget* widget, GdkEventConfigure* ev, gpointer data);
+
+//! Callback Function to initialise the content of the widget
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean init(GtkWidget* widget, gpointer data);
+
+//! Function to force a redraw of the widget
+void redraw(GtkWidget* widget);
+
+//! Function that creates the opengl widget with all the proper information
+/*!
+ * \return the created widget
+ */
+GtkWidget* createGLWidget();
+
+//! Draws the images from the local capture source
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean drawLocal(GtkWidget* widget, gpointer data);
+
+
+//! Draws the images from the remote source
+/*!
+ * \param widget a pointer to the widget being drawned
+ * \param data data on the call back
+ * \return the success of the operation
+ */
+gboolean drawRemote(GtkWidget* widget, gpointer data);
+
+#endif //GLWIDGET_H
diff --git a/src/Makefile.am b/src/Makefile.am
index bc9cb7aa7ec07fa55ee5093646baf71949c44198..9edb0e643d12d4be9e1be60a452ed4ea1c6454f9 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -28,7 +28,7 @@ IAXSOURCES =
IAXHEADERS =
endif
-SUBDIRS = audio config dbus $(ZEROCONFDIR)
+SUBDIRS = audio config dbus memmanager video mixer $(ZEROCONFDIR)
sflphoned_SOURCES = eventthread.cpp main.cpp voiplink.cpp \
managerimpl.cpp observer.cpp \
@@ -51,6 +51,9 @@ libsflphone_la_LIBADD = \
./audio/libaudio.la \
./dbus/libdbus.la \
./config/libconfig.la \
+ ./memmanager/libmemmanager.la \
+ ./mixer/libmixer.la \
+ ./video/libvideo.la \
$(IAX_LIBS)
libsflphone_la_SOURCES =
diff --git a/src/git.test b/src/git.test
new file mode 100644
index 0000000000000000000000000000000000000000..9766475a4185a151dc9d56d614ffb9aaea3bfd42
--- /dev/null
+++ b/src/git.test
@@ -0,0 +1 @@
+ok
diff --git a/src/memmanager/Makefile.am b/src/memmanager/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..6fb798d59da9911ab127bef909e72ad404cbf2f6
--- /dev/null
+++ b/src/memmanager/Makefile.am
@@ -0,0 +1,11 @@
+SUBDIRS =
+
+noinst_LTLIBRARIES = libmemmanager.la
+
+libmemmanager_la_SOURCES = MemData.cpp \
+ MemKey.cpp \
+ MemManager.cpp \
+ MemSorter.cpp \
+ MemSpace.cpp
+
+AM_CXXFLAGS = -I$(top_srcdir)/include $(libccext2_CFLAGS) $(USER_INCLUDES)
diff --git a/src/memmanager/MemData.cpp b/src/memmanager/MemData.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bf1bacb5edc51acda23497f603151443737ff99d
--- /dev/null
+++ b/src/memmanager/MemData.cpp
@@ -0,0 +1,29 @@
+/* Generated by Together */
+
+#include "MemData.h"
+MemData::MemData()
+{
+}
+
+MemData::~MemData()
+{
+ // TODO: Use memcpy to copy data
+}
+
+MemData::MemData(MemData* data)
+{
+ // TODO: Use memcpy to copy data
+}
+
+MemData::MemData(MemData& data)
+{
+}
+
+int MemData::fetchData(char * data)
+{
+ data= 0;
+ return 0;
+}
+void MemData::putData(char * data, int size)
+{
+}
diff --git a/src/memmanager/MemData.h b/src/memmanager/MemData.h
new file mode 100644
index 0000000000000000000000000000000000000000..3a547d0e48081e5d07c051ea530450e0ce6271bb
--- /dev/null
+++ b/src/memmanager/MemData.h
@@ -0,0 +1,63 @@
+/* Generated by Together */
+
+#ifndef MEMDATA_H
+#define MEMDATA_H
+
+//! Memmory data container
+/*!
+ * Contains a copy of the data in the shared memory. It contains the data it self and the size. This class acts like a container.
+ */
+class MemData {
+public:
+
+ //! Constructor
+ /*!
+ * Initialises the Container
+ */
+ MemData();
+
+ //! Pointer copy constructor
+ /*!
+ * Creates an independant copy of the source object
+ *
+ * \param data a pointer to a MemData object
+ */
+ MemData(MemData* data);
+
+ //! Reference copy constructor
+ /*!
+ * Creates an independant copy of the source object
+ *
+ * \param data a reference to a MemData object
+ */
+ MemData(MemData& data);
+
+ //! Destructor
+ /*!
+ * Disposes cleanly of the data pointer
+ */
+ ~MemData();
+
+ //! Method to access the data in the buffer
+ /*!
+ * \param data a pointer to where the data wil be copied
+ * \return the size of data
+ */
+ int fetchData(char * data);
+
+ //! Method to change the data in the buffer
+ /*!
+ * \param data a pointer to the new data
+ * \param size the size of data
+ */
+ void putData(char * data, int size);
+
+private:
+
+ //! Pointer to the data
+ char * data;
+
+ //! The current size of the data in the buffer
+ int size;
+};
+#endif //MEMDATA_H
diff --git a/src/memmanager/MemKey.cpp b/src/memmanager/MemKey.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f0ba9dd768cc48568f06f9842a63d8e03c9a0920
--- /dev/null
+++ b/src/memmanager/MemKey.cpp
@@ -0,0 +1,57 @@
+/* Generated by Together */
+
+#include "MemKey.h"
+
+MemKey::MemKey(int size, char* description)
+{
+}
+
+MemKey::~MemKey()
+{
+}
+
+int MemKey::getKey()
+{
+ return 0;
+}
+
+const char * MemKey::getDescription() const
+{
+ return 0;
+}
+
+int MemKey::getIndex()
+{
+ return 0;
+}
+
+void MemKey::setIndex(int index)
+{
+}
+
+MemKey::MemKey(MemKey* key)
+{
+}
+
+MemKey::MemKey(MemKey& key)
+{
+}
+
+int MemKey::getSize()
+{
+ return 0;
+}
+
+char * MemKey::serialize()
+{
+ return 0;
+}
+
+MemKey::MemKey()
+{
+
+}
+
+MemKey::MemKey(char* serializedData)
+{
+}
diff --git a/src/memmanager/MemKey.h b/src/memmanager/MemKey.h
new file mode 100644
index 0000000000000000000000000000000000000000..1dc13e00f37d233d50d61f962c3ef28577f9d212
--- /dev/null
+++ b/src/memmanager/MemKey.h
@@ -0,0 +1,107 @@
+/* Generated by Together */
+
+#ifndef MEMKEY_H
+#define MEMKEY_H
+
+//! Reprensent a unique key associated to a shared memory space
+/*!
+ * This class is a container for the information relative to a shared memory space
+ */
+class MemKey {
+public:
+
+ //! Constructor
+ /*!
+ * Initiate the object
+ *
+ * \param size the maximum size of the shared memory space
+ * \param description a description of the shared memory space
+ */
+ MemKey(int size, char* description = 0);
+
+ //! Pointer copy constructor
+ /*!
+ * Creates an independant copy of the source object
+ *
+ * \param key a pointer to a MemKey object
+ */
+ MemKey(MemKey* key);
+
+ //! Reference copy constructor
+ /*!
+ * Creates an independant copy of the source object
+ *
+ * \param key a reference to a MemKey object
+ */
+ MemKey(MemKey& key);
+
+ //! Constructor from serialized data
+ /*!
+ * \param serializedData a char pointer to the representation of a MemKey
+ */
+ MemKey(char* serializedData);
+
+ //! Destructor
+ /*!
+ * Disposes cleanly of object
+ */
+ ~MemKey();
+
+ //! Access method to the key of the shared memory space
+ /*!
+ * \return the key to the memory space
+ */
+ int getKey();
+
+ //! Access method to the description of the shared memory space
+ /*!
+ * \return a constant char pointer to the description
+ */
+ const char * getDescription() const;
+
+ //! Access method to the index of the memory space in the MemManager
+ /*!
+ * \return the index in the MemManager
+ */
+ int getIndex();
+
+ //! Modification method to the index of the memory space in the MemManager
+ /*!
+ * \param index the index in the MemManager
+ */
+ void setIndex(int index);
+
+ //! Access method to the maixmum size of shared memory space
+ /*!
+ * \return the maximum size of the shared memory space
+ */
+ int getSize();
+
+ //! Method to serialize the MemKeyObject
+ /*!
+ * \return a char pointer reprensenting the state of the key
+ */
+ char * serialize();
+
+private:
+
+ //! Default constructor
+ /*!
+ * The default constructor is declared private to prevent the decleratio of an MemKey without the proper information.
+ */
+ MemKey();
+
+ //! The key to access the shared memory space
+ int key;
+
+ //! The description of the shared memory space
+ char * description;
+
+ //! The index of the MemSpace in the MemManager
+ int index;
+
+ //! The maximum size of the shared memory space
+ int size;
+
+};
+#endif //MEMKEY_H
diff --git a/src/memmanager/MemManager.cpp b/src/memmanager/MemManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9d935f7b4bb6c3bd558761492835d79b13a64a2c
--- /dev/null
+++ b/src/memmanager/MemManager.cpp
@@ -0,0 +1,83 @@
+/* Generated by Together */
+
+#include "MemManager.h"
+
+MemManager* MemManager::instance= 0;
+
+MemManager* MemManager::getInstance()
+{
+ return 0;
+}
+
+MemManager::MemManager()
+{
+}
+
+MemManager::~MemManager()
+{
+}
+
+const MemKey* MemManager::initSpace(int key, int size)
+{
+ return 0;
+}
+
+const MemKey* MemManager::initSpace(MemKey* key, int size)
+{
+ return 0;
+}
+
+bool MemManager::setDefaultSpace(MemKey* key)
+{
+ return false;
+}
+
+void MemManager::nextSpace()
+{
+}
+
+void MemManager::previousSpace()
+{
+}
+
+MemData* MemManager::fetchData( )
+{
+}
+
+MemData* MemManager::fetchData(int key)
+{
+}
+
+MemData* MemManager::fetchData(MemKey* key)
+{
+}
+
+bool MemManager::putData(void * Data, int size)
+{
+ return false;
+}
+
+bool MemManager::putData(int key, void * Data, int size)
+{
+ return false;
+}
+
+bool MemManager::putData(MemKey* key, void * Data, int size)
+{
+ return false;
+}
+
+vector<MemKey*> MemManager::getAvailSpaces() const
+{
+ vector<MemKey*> tmp;
+ return tmp;
+}
+
+const MemKey* MemManager::initSpace(int size)
+{
+ return 0;
+}
+
+int MemManager::genKey()
+{
+}
diff --git a/src/memmanager/MemManager.h b/src/memmanager/MemManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..54532c171b2c9a75f68f587120587d1196dbcb9d
--- /dev/null
+++ b/src/memmanager/MemManager.h
@@ -0,0 +1,164 @@
+/* Generated by Together */
+
+#ifndef MEMMANAGER_H
+#define MEMMANAGER_H
+
+#include <vector>
+
+#include "MemSpace.h"
+#include "MemSorter.h"
+#include "MemData.h"
+#include "MemSpace.h"
+#include "MemKey.h"
+
+using namespace std;
+
+//! Shared memory pool manager
+/*!
+ * This class manages a pool of MemSpace, it make the link between the MemKey and the MemSpace. It also creates the MemKey Only one instance of the manager can exist at one time
+ */
+class MemManager {
+public:
+
+ //! Destructor
+ /*!
+ * Disposes cleanly of the manager
+ */
+ ~MemManager();
+
+ //! Method to get the instance of the Manager.
+ /*!
+ * If it does not exist, this method will create it
+ *
+ * \return an instance of the manager
+ */
+ MemManager* getInstance();
+
+ //! Initialise a shared memory space with the specified size
+ /*!
+ * This method creates a new shared memory space and a new key.
+ *
+ * \return a MemKey that identifies the MemSpace and is necessary for future access
+ */
+ const MemKey* initSpace(int size);
+
+ //! Initialise a shared memory space with the specified info
+ /*!
+ * This method creates a new shared memory space and create a new key or links to an existing one and returns the corresponding MemKey. To link 2 spaces, the size and the key muste be the same.
+ *
+ * \param key the key identifiying the shared memory space
+ * \param size the size of the shared memory space
+ * \return a MemKey linking to a MemSpace dans that is needed for future access
+ */
+ const MemKey* initSpace(int key, int size);
+
+ //! Initialise a shared memory space with the specified info
+ /*!
+ * This method creates a new shared memory space and create a new key or links to an existing one and returns the corresponding MemKey. To link 2 spaces, the size and the key muste be the same.
+ *
+ * \param key the key identifiying the shared memory space
+ * \param size the size of the shared memory space
+ * \return a MemKey linking to a MemSpace dans that is needed for future access
+ */
+ const MemKey* initSpace(MemKey* key, int size);
+
+
+ //! Sets the default MemSpace to work with
+ /*!
+ * \param key the key identifiying the MemSpace
+ * \return a bool representing the succes of the operation
+ */
+ bool setDefaultSpace(MemKey* key);
+
+ //! Sets the next MemSpace in the pool as the MemSpace to work with
+ /*!
+ * Works in a cirular maner, at the end of the pool the first one is referenced.
+ */
+ void nextSpace();
+
+ //! Sets the previous MemSpace in the pool as the MemSpace to work with
+ /*!
+ * Works in a cirular maner, at the begining of the pool the last one is referenced.
+ */
+ void previousSpace();
+
+ //! Returns the MemData from the current MemSpace
+ /*!
+ * \return the data from the MemSpace
+ */
+ MemData* fetchData( );
+
+ //! Returns the MemData from the MemSpace with the specifed key
+ /*!
+ * \param key the key of the MemSpace
+ * \return the data from the MemSpace
+ */
+ MemData* fetchData(int key);
+
+ //! Returns the MemData from the MemSpace with the specifed key
+ /*!
+ * \param key the key of the MemSpace
+ * \return the data from the MemSpace
+ */
+ MemData* fetchData(MemKey* key);
+
+ //! Changes the data in the current MemSpace
+ /*!
+ * \param Data a pointer to the new data
+ * \param size the size of Data
+ * \return the success of the operation
+ */
+ bool putData(void * Data, int size);
+
+ //! Changes the data in the MemSpace specified by the key
+ /*!
+ * \param key the key of the MemSpace
+ * \param Data a pointer to the new data
+ * \param size the size of Data
+ * \return the success of the operation
+ */
+ bool putData(int key, void * Data, int size);
+
+ //! Changes the data in the MemSpace specified by the key
+ /*!
+ * \param key the key of the MemSpace
+ * \param Data a pointer to the new data
+ * \param size the size of Data
+ * \return the success of the operation
+ */
+ bool putData(MemKey* key, void * Data, int size);
+
+ //! Gets a list of the available MemKeys
+ /*!
+ * \return a vector of available MemKey
+ */
+ vector<MemKey*> getAvailSpaces() const;
+
+
+private:
+
+ //! Generates a random key to access the MemSpace
+ /*!
+ * \return the generated key
+ */
+ int genKey();
+
+ //! The MemSpaces
+ vector<MemSpace*> spaces;
+
+ //! The instance of the manager
+ static MemManager* instance;
+
+ // The current index of the pool of MemSpace
+ int defaultIndex;
+
+protected:
+
+ //! Default consrtuctor
+ /*!
+ * Part of a singleton patern
+ */
+ MemManager();
+
+};
+#endif //MEMMANAGER_H
diff --git a/src/memmanager/MemSorter.cpp b/src/memmanager/MemSorter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..05b51479e5208eaaedb189d40d258f33959d4579
--- /dev/null
+++ b/src/memmanager/MemSorter.cpp
@@ -0,0 +1,9 @@
+/* Generated by Together */
+
+#include "MemSorter.h"
+bool MemSorter::operator()(MemKey* key1, MemKey* key2)
+{
+ return false;
+
+ //TODO: Ref.: http://en.wikipedia.org/wiki/Function_object#Functors_in_C_and_C.2B.2B
+}
diff --git a/src/memmanager/MemSorter.h b/src/memmanager/MemSorter.h
new file mode 100644
index 0000000000000000000000000000000000000000..b09d2b2d554b3ba47ab6eac30ea1743fcc274e91
--- /dev/null
+++ b/src/memmanager/MemSorter.h
@@ -0,0 +1,15 @@
+/* Generated by Together */
+
+#ifndef MEMSORTER_H
+#define MEMSORTER_H
+#include "MemKey.h"
+
+//! Acts as a functor to sort the MemKeys
+class MemSorter {
+public:
+
+ //! The comparaision operator
+ bool operator()(MemKey* key1, MemKey* key2);
+
+};
+#endif //MEMSORTER_H
diff --git a/src/memmanager/MemSpace.cpp b/src/memmanager/MemSpace.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eae56fca27f61a7571364380749e9f72c4bd71d0
--- /dev/null
+++ b/src/memmanager/MemSpace.cpp
@@ -0,0 +1,46 @@
+/* Generated by Together */
+
+#include "MemSpace.h"
+#include "MemKey.h"
+#include "MemData.h"
+
+MemSpace::MemSpace()
+{
+}
+
+MemSpace::MemSpace(MemKey* key)
+{
+}
+
+MemKey* MemSpace::getKey()
+{
+}
+
+bool MemSpace::putData(void * Data, int size)
+{
+ return false;
+}
+
+MemData* MemSpace::fetchData()
+{
+}
+
+MemSpace::MemSpace(MemSpace* space)
+{
+}
+
+MemSpace::MemSpace(MemSpace& space)
+{
+}
+
+MemSpace::~MemSpace()
+{
+}
+
+void MemSpace::readSpace(MemData* data)
+{
+}
+
+void MemSpace::writeSpace(char * data, int size)
+{
+}
diff --git a/src/memmanager/MemSpace.h b/src/memmanager/MemSpace.h
new file mode 100644
index 0000000000000000000000000000000000000000..2cdd091e931abb2a59697a389d356e949836de35
--- /dev/null
+++ b/src/memmanager/MemSpace.h
@@ -0,0 +1,98 @@
+/* Generated by Together */
+
+#ifndef MEMSPACE_H
+#define MEMSPACE_H
+
+#include "MemKey.h"
+#include "MemData.h"
+
+//! Shared memory space frontend
+/*
+ * This class hides the fucntionnalities of the shared memory management.
+ */
+class MemSpace {
+public:
+
+ //! Constructor
+ /*!
+ * Create a new shared memory space or links to an existing one
+ *
+ * \param key the key identifiying the shared memory space
+ */
+ MemSpace(MemKey* key);
+
+ //! Pointer copy constructor
+ /*!
+ * This constructor \b does \b not create a new MemSpace, it copie the base address dans the key.
+ *
+ * \param space a pointer to a reference MemSpace
+ */
+ MemSpace(MemSpace* space);
+
+ //! Reference copy constructor
+ /*!
+ * This constructor \b does \b not create a new MemSpace, it copie the base address dans the key.
+ *
+ * \param space a reference to a reference MemSpace
+ */
+ MemSpace(MemSpace& space);
+
+ //! Destructor
+ /*!
+ * Unlinks the shared memory space from this process.
+ */
+ ~MemSpace();
+
+ //! Returns the key associated with this MemSpace
+ /*!
+ * \return a MemKey containing the information for this MemSpace
+ */
+ MemKey* getKey();
+
+ //! Changes the data in the MemSpace
+ /*!
+ * \param Data a pointer to the new data
+ * \param size the size of the new data
+ * \return the success of the operation
+ */
+ bool putData(void * Data, int size);
+
+ //! Gets the data in the Shared Memory
+ /*!
+ * \return the data contained int the shared memory in the form of a MemData
+ */
+ MemData* fetchData( );
+
+private:
+
+ //! Writes data to the shared memory space
+ /*!
+ * The purpose of this fucntion is to concentrate os specific code
+ *
+ * \param data a pointer to the data to be written
+ * \param size the size of data
+ */
+ void writeSpace(char * data, int size);
+
+ //! Read from the shared memory space
+ /*!
+ * The purpose of this fucntion is to concentrate os specific code
+ *
+ * \param a pointer to a MemData object
+ */
+ void readSpace(MemData* data);
+
+ // Default constrcutor
+ /*!
+ * The default constrcutor is declared private to prevent the declaration of a MemSpace without a MemKey
+ */
+ MemSpace();
+
+ //! The base address of the shared memory space
+ char * baseAddress;
+
+ //! The Memkey Associated with this MemSpace
+ MemKey* theKey;
+
+};
+#endif //MEMSPACE_H
diff --git a/src/mixer/AudioInput.cpp b/src/mixer/AudioInput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4bb8554dc43073a8fa4f6ee8fa92dc016d662927
--- /dev/null
+++ b/src/mixer/AudioInput.cpp
@@ -0,0 +1,34 @@
+/* Generated by Together */
+
+#include "AudioInput.h"
+#include "TimeInfo.h"
+
+TimeInfo AudioInput::fetchTimeInfo() const
+{
+ TimeInfo tmp(0);
+ return tmp;
+}
+
+void AudioInput::putData(int16 *data, int size)
+{
+}
+
+int AudioInput::fetchData(int16 *data) const
+{
+ return 0;
+}
+
+AudioInput::AudioInput()
+{
+
+}
+
+AudioInput::~AudioInput()
+{
+
+}
+
+void AudioInput::putTimeInfo(TimeInfo* infos)
+{
+
+}
diff --git a/src/mixer/AudioInput.h b/src/mixer/AudioInput.h
new file mode 100644
index 0000000000000000000000000000000000000000..b2d0c36603ffc4d70431383f9785dbe8992ce3f3
--- /dev/null
+++ b/src/mixer/AudioInput.h
@@ -0,0 +1,68 @@
+/* Generated by Together */
+
+#ifndef AUDIOINPUT_H
+#define AUDIOINPUT_H
+
+#include <semaphore.h>
+#include "TimeInfo.h"
+
+#define int16 short int
+
+//! Audio input buffer
+/*!
+ This class is the audio input buffer of a mixer InputStreams
+*/
+
+class AudioInput {
+public:
+
+ //! Default constructor
+ /*!
+ * Initialise the buffer
+ */
+ AudioInput();
+
+ //! Destructor
+ /*
+ * Cleanly disposes of the buffer
+ */
+ virtual ~AudioInput();
+
+ //! Access the timing information
+ /*!
+ * This method returns the timestamp for the data contained in the buffer. The data is used by the synchonization manager to mix the streams
+ */
+ virtual TimeInfo fetchTimeInfo() const;
+
+ //! Changes the data contained in the buffer
+ /*!
+ * This method changes the data contained in the buffer. Buffer access is protected to prevent simultanious access.
+ *
+ * \param data a pointer to a data buffer
+ * \param size the size of the buffer
+ */
+ virtual void putData(int16 *data, int size);
+
+ //! Access the data contained the the buffer
+ /*!
+ * This method returns the data. Buffer access is protected to prevent simultanious access.
+ *
+ * \param data a pointer to where the data must be copied
+ * \return the size of the fetched data
+ */
+ virtual int fetchData(int16 *data) const;
+
+ void putTimeInfo(TimeInfo* infos);
+
+private:
+
+ //! Simultanious access protection semaphore
+ sem_t semaphore;
+
+ //! Internal data buffer
+
+ TimeInfo* infoTemps;
+ int16 * buffer;
+
+};
+#endif //AUDIOINPUT_H
diff --git a/src/mixer/AudioMixer.cpp b/src/mixer/AudioMixer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4c7dbf41c20dc94dc1135cfd728a50d70bf2bbc1
--- /dev/null
+++ b/src/mixer/AudioMixer.cpp
@@ -0,0 +1,13 @@
+/* Generated by Together */
+
+#include "AudioMixer.h"
+
+AudioMixer::AudioMixer()
+{
+
+}
+
+AudioMixer::~AudioMixer()
+{
+
+}
diff --git a/src/mixer/AudioMixer.h b/src/mixer/AudioMixer.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e443ed033f7abf818eaafa29693e7c5ed766618
--- /dev/null
+++ b/src/mixer/AudioMixer.h
@@ -0,0 +1,44 @@
+/* Generated by Together */
+
+#ifndef AUDIOMIXER_H
+#define AUDIOMIXER_H
+#include <cc++/thread.h>
+#include <vector>
+
+#include "InternalBuffer.h"
+#include "OutputStream.h"
+
+using namespace std;
+/** @interface */
+//! Audio mixer interface
+/*!
+ * Abstract class acting as an interface for multiple type of audio mixers. This class also acts as a thread once started.
+ */
+class AudioMixer : public ost::Thread
+{
+public:
+
+ AudioMixer();
+ ~AudioMixer();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. This method must be implemented in the child class.
+ */
+ virtual void run() =0;
+
+protected:
+
+ //! Output buffer(s) for the mixed data
+ /*!
+ * See OutputStream
+ */
+ vector<OutputStream*> audioOutput;
+
+ //! Input buffer(s) for the data
+ /*!
+ * See InternalBuffer
+ */
+ vector<InternalBuffer*> audioBuffer;
+};
+#endif //AUDIOMIXER_H
diff --git a/src/mixer/AudioMixer2Channels.cpp b/src/mixer/AudioMixer2Channels.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8497b5265ba2df255dc74bfa5368bc134fef1512
--- /dev/null
+++ b/src/mixer/AudioMixer2Channels.cpp
@@ -0,0 +1,20 @@
+/* Generated by Together */
+
+#include "AudioMixer2Channels.h"
+
+AudioMixer2Channels::~AudioMixer2Channels()
+{
+}
+
+void AudioMixer2Channels::run()
+{
+}
+
+AudioMixer2Channels::AudioMixer2Channels(InternalBuffer* input1, InternalBuffer* input2, OutputStream* output)
+{
+}
+
+AudioMixer2Channels::AudioMixer2Channels()
+{
+}
+
diff --git a/src/mixer/AudioMixer2Channels.h b/src/mixer/AudioMixer2Channels.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3fb63a4968662bc8585ff4608c91459d06213d9
--- /dev/null
+++ b/src/mixer/AudioMixer2Channels.h
@@ -0,0 +1,49 @@
+/* Generated by Together */
+
+#ifndef AUDIOMIXER2CHANNELS_H
+#define AUDIOMIXER2CHANNELS_H
+
+#include "AudioMixer.h"
+#include "InternalBuffer.h"
+#include "OutputStream.h"
+
+//! 2 Channel audio mixer implementation
+/*!
+ * This class implements a mixer that takes in 2 audio sources and outputs only one.
+ */
+class AudioMixer2Channels : public AudioMixer {
+public:
+
+ //! Contructor
+ /*!
+ * Assigns the input and output buffers
+ *
+ * \param input1 an input buffer see InternalBuffer
+ * \param input2 an input buffer see InternalBuffer
+ * \param output an output buffer see OutputStream
+ */
+ AudioMixer2Channels(InternalBuffer* input1, InternalBuffer* input2, OutputStream* output);
+
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~AudioMixer2Channels();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. It mixes the 2 inputs into one output.
+ */
+ virtual void run();
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent declaration without the proper buffers
+ */
+ AudioMixer2Channels();
+
+};
+#endif //AUDIOMIXER2CHANNELS_H
diff --git a/src/mixer/AudioOuput.cpp b/src/mixer/AudioOuput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..db9b53b9ed878934ba1102f76c970ea89464a5c0
--- /dev/null
+++ b/src/mixer/AudioOuput.cpp
@@ -0,0 +1,33 @@
+/* Generated by Together */
+
+#include "AudioOuput.h"
+
+
+int AudioOuput::fetchData(int16 *data)
+{
+ return 0;
+}
+
+void AudioOuput::putData(int16 * data, int size)
+{
+
+}
+
+AudioOuput::AudioOuput()
+{
+
+}
+
+AudioOuput::~AudioOuput()
+{
+
+}
+int AudioOuput::fetchData(char* data)
+{
+ return 0;
+}
+
+void AudioOuput::putData(char * data, int size)
+{
+
+}
diff --git a/src/mixer/AudioOuput.h b/src/mixer/AudioOuput.h
new file mode 100644
index 0000000000000000000000000000000000000000..7a8bd115f7d5b1474fbccd3a9ba360b461b96c8b
--- /dev/null
+++ b/src/mixer/AudioOuput.h
@@ -0,0 +1,61 @@
+/* Generated by Together */
+
+#ifndef AUDIOOUPUT_H
+#define AUDIOOUPUT_H
+
+#include "OutputStream.h"
+
+//! Audio Ouput Buffer
+/*!
+ * This class acts as an Audio output buffer. It implements the OutputStream interface
+ */
+class AudioOuput : public OutputStream {
+public:
+
+ //! Default constructor
+ /*!
+ * Initialises the internal buffer
+ */
+ AudioOuput();
+
+ //! Destructor
+ /*!
+ * Cleanly diposes of the buffer
+ */
+ ~AudioOuput();
+
+ //! Method to get the data contained by the buffer
+ /*!
+ * \param data a pointer to the where the data will be put
+ * \return the size of the buffer
+ */
+ virtual int fetchData(int16 *data);
+
+ //! Method to change the data contained in the buffer
+ /*!
+ * \param data a pointer to the data to copy
+ * \param size th size of the buffer
+ */
+ virtual void putData(int16 * data, int size);
+
+protected:
+
+ //! Data Buffer for the audio data
+ int16* buffer;
+
+private:
+
+ //! Method to change the data in the buffer
+ /*!
+ * This method is implemented as private and \b should \b not \b be \b used in AudioOutput. This method is inherited from OutputStream. putData(int16 * data, int size) instead.
+ */
+ virtual void putData(char * data, int size) __attribute__ ((deprecated));
+
+ //! Method to get the data in the buffer
+ /*!
+ * This method is implemented as private and \b should \b not \b be \b used in AudioOutput. This method is inherited from OutputStream. Use fetchData(int16 *data) instead.
+ */
+ virtual int fetchData(char* data) __attribute__ ((deprecated));
+
+};
+#endif //AUDIOOUPUT_H
diff --git a/src/mixer/AudioSynch.cpp b/src/mixer/AudioSynch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3fcc1c4821335a4816a9422821600dda27d399b
--- /dev/null
+++ b/src/mixer/AudioSynch.cpp
@@ -0,0 +1,24 @@
+/* Generated by Together */
+
+#include "AudioSynch.h"
+
+void AudioSynch::run()
+{
+
+}
+
+AudioSynch::~AudioSynch()
+{
+
+}
+
+AudioSynch::AudioSynch(InputStreams* inputStreams, InternalBuffer* video, InternalBuffer* audio)
+{
+
+}
+
+AudioSynch::AudioSynch()
+{
+
+}
+
diff --git a/src/mixer/AudioSynch.h b/src/mixer/AudioSynch.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2d26646dc081c4abf9a4f998121725e824da496
--- /dev/null
+++ b/src/mixer/AudioSynch.h
@@ -0,0 +1,46 @@
+/* Generated by Together */
+
+#ifndef AUDIOSYNCH_H
+#define AUDIOSYNCH_H
+#include "SynchManager.h"
+
+//! Synchonization manager that uses Audio data as reference
+/*!
+ * This class synchronizes a video stream with an audio stream using the timestamp information from the audio streams and creates a bottle neck on the video stream to create a synchonized output. This class also acts as a thread once started.
+ */
+class AudioSynch : public SynchManager {
+public:
+
+ //!Constructor
+ /*!
+ * Initializes the synchronaziation process.
+ *
+ * \param inputStreams a video and audio stream see InputStreams
+ * \param video a buffer to put the synchonized video data
+ * \param audio a buffer to put the synchonized audio data
+ */
+ AudioSynch(InputStreams* inputStreams, InternalBuffer* video, InternalBuffer* audio);
+
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~AudioSynch();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. It synchonizes the 2 inputs.
+ */
+ virtual void run();
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent a declaration without the proper buffers
+ */
+ AudioSynch();
+
+};
+#endif //AUDIOSYNCH_H
diff --git a/src/mixer/InputStreams.cpp b/src/mixer/InputStreams.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5293660b594550d47060a5155770c9a969cd72bd
--- /dev/null
+++ b/src/mixer/InputStreams.cpp
@@ -0,0 +1,25 @@
+/* Generated by Together */
+
+#include "InputStreams.h"
+#include "VideoInput.h"
+#include "AudioInput.h"
+
+InputStreams::InputStreams()
+{
+}
+
+InputStreams::InputStreams(VideoInput* videoData, AudioInput* audioData)
+{
+}
+
+InputStreams::~InputStreams()
+{
+}
+
+const VideoInput* InputStreams::fetchVideoStream() const
+{
+}
+
+const AudioInput* InputStreams::fetchAudioStream() const
+{
+}
diff --git a/src/mixer/InputStreams.h b/src/mixer/InputStreams.h
new file mode 100644
index 0000000000000000000000000000000000000000..20f4e3917e684ea580d1903c91672875852ec8b2
--- /dev/null
+++ b/src/mixer/InputStreams.h
@@ -0,0 +1,57 @@
+/* Generated by Together */
+
+#ifndef INPUTSTREAMS_H
+#define INPUTSTREAMS_H
+
+#include "VideoInput.h"
+#include "AudioInput.h"
+
+//! Video and audio streams container
+/*!
+ * This class acts as a container to link the audio feed to the wright video feed.
+ */
+class InputStreams {
+public:
+
+ //! Constructor
+ /*!
+ * Creates the container
+ *
+ * \param videoData a pointer to an VideoInput
+ * \param audioData a pointer to an AudioInput
+ */
+ InputStreams(VideoInput* videoData, AudioInput* audioData);
+
+ //! Descructors
+ /*!
+ * The destrcutor dos not destroy the input pointers
+ */
+ ~InputStreams();
+
+ //! Access the video stream
+ /*!
+ * \return the video stream
+ */
+ const VideoInput* fetchVideoStream() const;
+
+ //! Access the audio stream
+ /*!
+ * \return the audio stream
+ */
+ const AudioInput* fetchAudioStream() const;
+
+private:
+
+ //! Default constructor
+ /*!
+ * Implemented as privte to prevent a declaration with no streams
+ */
+ InputStreams();
+
+ //! VideoInput stream pointer
+ VideoInput* videoInput;
+
+ //! AudioInput stream pointer
+ AudioInput* audioInput;
+};
+#endif //INPUTSTREAMS_H
diff --git a/src/mixer/InternalBuffer.cpp b/src/mixer/InternalBuffer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5ea3f70a0a2ec876171769282e47da09fa640e72
--- /dev/null
+++ b/src/mixer/InternalBuffer.cpp
@@ -0,0 +1,28 @@
+/* Generated by Together */
+
+#include "InternalBuffer.h"
+
+bool InternalBuffer::putData(char * data, int size)
+{
+ return true;
+}
+
+int InternalBuffer::fetchData(char * data)
+{
+ return 0;
+}
+
+InternalBuffer::InternalBuffer()
+{
+
+}
+
+InternalBuffer::~InternalBuffer()
+{
+
+}
+
+void InternalBuffer::Init()
+{
+
+}
diff --git a/src/mixer/InternalBuffer.h b/src/mixer/InternalBuffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f1bb89d1e5e04b80b532cbffd8b9265c11b0cbe
--- /dev/null
+++ b/src/mixer/InternalBuffer.h
@@ -0,0 +1,57 @@
+/* Generated by Together */
+
+#ifndef INTERNALBUFFER_H
+#define INTERNALBUFFER_H
+
+#include <semaphore.h>
+
+//! Internal data sharing class
+/*!
+ * Acts as an Internal buffer that can be accessed from multiple source.
+ */
+class InternalBuffer {
+public:
+
+ //! Default constructor
+ /*!
+ * Initiates the internal buffer
+ */
+ InternalBuffer();
+
+ //! Destructor
+ /*!
+ * Disposes cleanly of the buffer
+ */
+ ~InternalBuffer();
+
+ //! Changes the data in the buffer
+ /*!
+ * \param data a pointer to the data to put in the buffer
+ * \param size the size of the data
+ * \return the success of the operation
+ */
+ bool putData(char * data, int size);
+
+ //! Gets the data contained in the buffer
+ /*!
+ * \param data a pointer to put the data
+ * \return the size of the data
+ */
+ int fetchData(char * data);
+
+ //! Intializes the buffer
+ void Init();
+
+private:
+
+ //! Internal buffer
+ char * data;
+
+ //! Size of the current buffer
+ int size;
+
+ //! Semaphore to protect from multiple simultaneous access
+ sem_t semaphore;
+
+};
+#endif //INTERNALBUFFER_H
diff --git a/src/mixer/LocalAudioOuput.cpp b/src/mixer/LocalAudioOuput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..349eeafb5361fe1f26c7bf84d084c0db087dd49f
--- /dev/null
+++ b/src/mixer/LocalAudioOuput.cpp
@@ -0,0 +1,24 @@
+/* Generated by Together */
+
+#include "LocalAudioOuput.h"
+
+
+int LocalAudioOuput::fetchData(int16 *data)
+{
+ return 0;
+}
+
+void LocalAudioOuput::putData(int16 * data, int size)
+{
+
+}
+
+LocalAudioOuput::LocalAudioOuput()
+{
+
+}
+
+LocalAudioOuput::~LocalAudioOuput()
+{
+
+}
diff --git a/src/mixer/LocalAudioOuput.h b/src/mixer/LocalAudioOuput.h
new file mode 100644
index 0000000000000000000000000000000000000000..d214b5c12b6ef3db3b07154c5a43e352bb8a3f0e
--- /dev/null
+++ b/src/mixer/LocalAudioOuput.h
@@ -0,0 +1,44 @@
+/* Generated by Together */
+
+#ifndef LOCALAUDIOOUPUT_H
+#define LOCALAUDIOOUPUT_H
+#include "AudioOuput.h"
+
+//! Local audio ouput
+/*!
+ * This class overloads the class AudioOuput to send the ouput directly to the sound device. This class is bound to change in a short future.
+ */
+class LocalAudioOuput : public AudioOuput {
+public:
+
+ //! Constructor
+ /*!
+ * Initalizes the ouput device
+ */
+ LocalAudioOuput();
+
+ //! Destructor
+ /*! Closes the device
+ */
+ virtual ~LocalAudioOuput();
+
+ //! Changes the data in the buffer
+ /*!
+ * Writes the data to the audio device
+ * \param data pointer to the new data
+ * \param size the size of data
+ */
+ virtual void putData(int16 * data, int size);
+
+private:
+
+ //! Gets the data in the buffer
+ /*!
+ * This method is not used in this class
+ */
+ virtual int fetchData(int16 *data);
+
+ //! Audio Device
+ //AudioLayer* device;
+};
+#endif //LOCALAUDIOOUPUT_H
diff --git a/src/mixer/LocalVideoOuput.cpp b/src/mixer/LocalVideoOuput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8fa360edbb8984ce409956673671d57096cb5e1
--- /dev/null
+++ b/src/mixer/LocalVideoOuput.cpp
@@ -0,0 +1,24 @@
+/* Generated by Together */
+
+#include "LocalVideoOuput.h"
+
+
+int LocalVideoOuput::fetchData(char* data)
+{
+ return 0;
+}
+
+void LocalVideoOuput::putData(char * data, int size)
+{
+
+}
+
+LocalVideoOuput::LocalVideoOuput()
+{
+
+}
+
+LocalVideoOuput::~LocalVideoOuput()
+{
+
+}
diff --git a/src/mixer/LocalVideoOuput.h b/src/mixer/LocalVideoOuput.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad4708d4917dd0087254f77d7f1a9ed4675b257b
--- /dev/null
+++ b/src/mixer/LocalVideoOuput.h
@@ -0,0 +1,47 @@
+/* Generated by Together */
+
+#ifndef LOCALVIDEOOUPUT_H
+#define LOCALVIDEOOUPUT_H
+
+#include "../memmanager/MemManager.h"
+#include "VideoOutput.h"
+
+//! Local video ouput
+/*!
+ * This class overloads the class VideoOuput to send the ouput directly to the MemManager and eventualy the GUI . This class is bound to change in a short future.
+ */
+class LocalVideoOuput : public VideoOutput {
+public:
+
+ //! Constructor
+ /*!
+ * Initalizes the MemManager
+ */
+ LocalVideoOuput();
+
+ //! Destructor
+ /*! Closes the MemManager
+ */
+ virtual ~LocalVideoOuput();
+
+ //! Changes the data in the buffer
+ /*!
+ * Writes the data to the audio device
+ * \param data pointer to the new data
+ * \param size the size of data
+ */
+ virtual void putData(char * data, int size);
+
+private:
+
+ //! Gets the data in the buffer
+ /*!
+ * This method is not used in this class
+ */
+ virtual int fetchData(char* data);
+
+ //! Shared memory manager
+ MemManager* manager;
+
+};
+#endif //LOCALVIDEOOUPUT_H
diff --git a/src/mixer/Makefile.am b/src/mixer/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..eb66270f6c2027dda0ddbd2b2610c70a7d76216b
--- /dev/null
+++ b/src/mixer/Makefile.am
@@ -0,0 +1,49 @@
+SUBDIRS =
+
+noinst_LTLIBRARIES = libmixer.la
+
+libmixer_la_SOURCES = AudioInput.cpp \
+ AudioMixer2Channels.cpp \
+ AudioMixer.cpp \
+ AudioOuput.cpp \
+ AudioSynch.cpp \
+ InputStreams.cpp \
+ InternalBuffer.cpp \
+ LocalAudioOuput.cpp \
+ LocalVideoOuput.cpp \
+ NoSynch.cpp \
+ StraightThrough_AT.cpp \
+ StraightThrough_VT.cpp \
+ VideoInput.cpp \
+ VideoMixer2Channels.cpp \
+ VideoMixer.cpp \
+ VideoOutput.cpp \
+ TimeInfo.cpp \
+ Mixer.cpp
+
+
+
+#AM_CXXFLAGS = -I$(top_srcdir)/include $(USER_INCLUDES)
+AM_CXXFLAGS = -I$(top_srcdir)/include -I$(top_srcdir)/libs $(libccext2_CFLAGS) $(libdbuscpp_CFLAGS) $(libccrtp1_CFLAGS) $(USER_INCLUDES)
+
+noinst_HEADERS = AudioInput.h \
+ AudioMixer2Channels.h \
+ AudioMixer.h \
+ AudioOuput.h \
+ AudioSynch.h \
+ InputStreams.h \
+ InternalBuffer.h \
+ LocalAudioOuput.h \
+ LocalVideoOuput.h \
+ Mixer.h \
+ NoSynch.h \
+ OutputStream.h \
+ StraightThrough_AT.h \
+ StraightThrough_VT.h \
+ SynchManager.h \
+ TimeInfo.h \
+ VideoInput.h \
+ VideoMixer2Channels.h \
+ VideoMixer.h \
+ VideoOutput.h
+
diff --git a/src/mixer/Mixer.cpp b/src/mixer/Mixer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0c331b4f3edf5df737d11dbcf09be843ad82aa97
--- /dev/null
+++ b/src/mixer/Mixer.cpp
@@ -0,0 +1,73 @@
+/* Generated by Together */
+
+#include "Mixer.h"
+
+Mixer::Mixer()
+{
+}
+
+Mixer::Mixer(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+}
+
+Mixer::~Mixer()
+{
+}
+
+
+void Mixer::init(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+}
+
+void Mixer::start()
+{
+}
+
+bool Mixer::changeCodecConfig(CodecInfo* infos)
+{
+ return true;
+}
+
+bool Mixer::changeOverallSettings(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+ return true;
+}
+
+void Mixer::terminateThreads()
+{
+}
+
+void Mixer::createAutoSense(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+}
+
+void Mixer::createStraightThrough(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+}
+
+void Mixer::createMixer2(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut)
+{
+}
+
+void Mixer::createAudio1()
+{
+}
+
+bool Mixer::addStream(InputStreams* input)
+{
+ return true;
+}
+
+bool Mixer::addStream(VideoInput* input)
+{
+ return true;
+}
+
+bool Mixer::addStream(AudioInput* input)
+{
+ return true;
+}
+
+void Mixer::updateState()
+{
+}
diff --git a/src/mixer/Mixer.h b/src/mixer/Mixer.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea222f97a93667f670f6fc28e67d3bab843ac817
--- /dev/null
+++ b/src/mixer/Mixer.h
@@ -0,0 +1,179 @@
+/* Generated by Together */
+
+#ifndef MIXER_H
+#define MIXER_H
+
+#include <vector>
+
+#include "OutputStream.h"
+#include "InputStreams.h"
+
+#include "NoSynch.h"
+#include "AudioSynch.h"
+
+#include "InternalBuffer.h"
+
+#include "StraightThrough_AT.h"
+#include "AudioMixer2Channels.h"
+
+#include "StraightThrough_VT.h"
+#include "VideoMixer2Channels.h"
+
+using namespace std;
+
+//! Mixer type
+/*!
+ * Enumerates the possible types of mixers.
+ */
+enum Tmixer { NOSYNCH_AV_STRAIGHTTHROUGH= 0x0, /*!No Synchronization Manager and audio-video straight Through mixer */
+ SYNCH_AV_STRAIGHTTHROUG= 0x01, /*!Synchronization Manager and audio-video straight Through mixer */
+ NOSYNCH_AV_MIXER2= 0x02, /*!No Synchronization Manager and audio-video 2 channels mixer */
+ SYNCH_AV_MIXER2= 0x03, /*!Synchronization Manager and audio-video 2 channels mixer */
+ NOSYNCH_AUTOSENSE= 0x04, /*!No Synchronization Manager and auto-detect mixer state from input */
+ SYNCH_AUTOSENSE= 0x05 /*!Synchronization Manager and auto-detect mixer stater from input */
+ };
+
+
+//! Audio and video mixer
+/*!
+ * This class implements a modular audio and video stream mixer that can take an arbitrairy number of InputStreams and converts them to 1 audio et 1 video OutputStreams.
+ */
+class Mixer {
+public:
+
+ //! Constructor
+ /*!
+ * Create a mixer from the type, inputs and ouput specified
+ *
+ * \param type the type of the mixer
+ * \param inputs the InputStreams of the mixer
+ * \param audioOut the audio output stream see OutputStream
+ * \param videoOut the cideo output stream see OutputStream
+ */
+ Mixer(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Destructor
+ /*
+ * Stops all the running threads
+ */
+ ~Mixer();
+
+ //! Start the mixers operation
+ /*!
+ * Starts all the thread that are needed.
+ */
+ void start();
+
+ //! Method to change the codec configuration
+ /*!
+ * This method changes the codec information for the video mixer.
+ *
+ * \param infos the codec information
+ * \return the success of the change
+ */
+ bool changeCodecConfig(CodecInfo* infos);
+
+ //! Method to completely change the mixers configuration.
+ /*!
+ * Effectively resets the mixer to change it's purpose.
+ *
+ * \param type the type of mixer see Tmixer
+ * \param inputs a vector of InputSteams
+ * \param audioOut the audio ouput buffer
+ * \param videoOut the video ouput buffer
+ * \return the success of the change
+ */
+ bool changeOverallSettings(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Method to add an input stream
+ /*!
+ * Adds if possible an InputStream
+ */
+ bool addStream(InputStreams* input);
+
+ //! Method to add a video input
+ /*!
+ * Adds the video input to the first available video buffer space in the InputStreams vector.
+ */
+ bool addStream(VideoInput* input);
+
+ //! Method to add a audio input
+ /*!
+ * Adds the audio input to the first available audio buffer space in the InputStreams vector.
+ */
+ bool addStream(AudioInput* input);
+
+
+private:
+
+ //! Default constructor
+ /*!
+ * Declared private to prevent the creation of an inputless or outputless mixer
+ */
+ Mixer();
+
+ //! Changes the current state of the mixer
+ /*!
+ * Changes the current state of the mixer to represent the addition of an input.
+ */
+ void updateState();
+
+ //! Creates a straight through audio mixer
+ void createAudio1();
+
+ //! Creates a 2 channel audio-video mixer
+ /*!
+ * \param type the type of mixer see Tmixer
+ * \param inputs a vector of InputSteams
+ * \param audioOut the audio ouput buffer
+ * \param videoOut the video ouput buffer
+ */
+ void createMixer2(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Creates a straight through audio-video mixer
+ /*!
+ * \param type the type of mixer see Tmixer
+ * \param inputs a vector of InputSteams
+ * \param audioOut the audio ouput buffer
+ * \param videoOut the video ouput buffer
+ */
+ void createStraightThrough(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Creates a mixer from the information it receives.
+ /*!
+ * \param type the type of mixer see Tmixer
+ * \param inputs a vector of InputSteams
+ * \param audioOut the audio ouput buffer
+ * \param videoOut the video ouput buffer
+ */
+ void createAutoSense(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Terminates the running threads
+ void terminateThreads();
+
+ //! Initializes the mixer
+ /*!
+ * Call the needed create method
+ *
+ * \param type the type of mixer see Tmixer
+ * \param inputs a vector of InputSteams
+ * \param audioOut the audio ouput buffer
+ * \param videoOut the video ouput buffer
+ *
+ * \sa createAudio1, createMixer2, createStraightThrough, createAutoSense
+ */
+ void init(Tmixer type, vector<InputStreams*> inputs, OutputStream* audioOut, OutputStream* videoOut);
+
+ //! Vector containing the synchronization managers
+ vector<SynchManager*> synchManagers;
+
+ //! The audio mixer in usage
+ AudioMixer* audioTranscoder;
+
+ //! The video mixer in usages
+ VideoMixer* videoTranscoder;
+
+ //! The current type of the mixer
+ Tmixer theType;
+};
+#endif //MIXER_H
diff --git a/src/mixer/NoSynch.cpp b/src/mixer/NoSynch.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..593b13543d4ba76a590e550d7b88463e390e39e1
--- /dev/null
+++ b/src/mixer/NoSynch.cpp
@@ -0,0 +1,24 @@
+/* Generated by Together */
+
+#include "NoSynch.h"
+
+
+void NoSynch::run()
+{
+
+}
+
+NoSynch::~NoSynch()
+{
+
+}
+
+NoSynch::NoSynch(InputStreams* inputStreams, InternalBuffer* video, InternalBuffer* audio)
+{
+
+}
+
+NoSynch::NoSynch()
+{
+
+}
diff --git a/src/mixer/NoSynch.h b/src/mixer/NoSynch.h
new file mode 100644
index 0000000000000000000000000000000000000000..f86d080b718574a174b644deb6dd084bbff06457
--- /dev/null
+++ b/src/mixer/NoSynch.h
@@ -0,0 +1,41 @@
+/* Generated by Together */
+
+#ifndef NOSYNCH_H
+#define NOSYNCH_H
+#include "SynchManager.h"
+
+//! Synchonization manager that does not synchronizes
+/*!
+ * Used when no synchronization is nedded. (ie: 1 input only)
+ */
+class NoSynch : public SynchManager {
+public:
+
+ //! Constructor
+ /*!
+ * Initialises the Synchronization Manager.
+ */
+ NoSynch(InputStreams* inputStreams, InternalBuffer* video, InternalBuffer* audio);
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~NoSynch();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread.
+ */
+ virtual void run();
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent a declaration without the proper buffers
+ */
+ NoSynch();
+
+};
+#endif //NOSYNCH_H
diff --git a/src/mixer/OutputStream.h b/src/mixer/OutputStream.h
new file mode 100644
index 0000000000000000000000000000000000000000..a5416092de95f5b89518446c6450e99f12a01c8b
--- /dev/null
+++ b/src/mixer/OutputStream.h
@@ -0,0 +1,63 @@
+/* Generated by Together */
+
+#ifndef OUTPUTSTREAM_H
+#define OUTPUTSTREAM_H
+
+#include <semaphore.h>
+
+//#include "../global.h"
+#include <cc++/config.h>
+
+/** @interface */
+//! Interface for the output buffers.
+/*
+ * Supplies all that is needed to use the ouput buffers.
+ */
+class OutputStream {
+public:
+
+ //! Method to get the data in the buffer
+ /*!
+ * Must be implemented in child class. This version is for the video buffer.
+ *
+ * \param data a pointer to where the data is to be copied
+ * \return the size of data
+ */
+ virtual int fetchData(char* data) =0;
+
+ //! Method to get the data in the buffer
+ /*!
+ * Must be implemented in child class. This version is for the audio buffer.
+ *
+ * \param data a pointer to where the data is to be copied
+ * \return the size of data
+ */
+ virtual int fetchData(int16* data) =0;
+
+ //! Method to change the data in the buffer
+ /*!
+ * Must be implemented in child class. This version is for the video buffer.
+ *
+ * \param data a pointer to the new data
+ * \param size the size of data
+ */
+ virtual void putData(char * data, int size) =0;
+
+ //! Method to change the data in the buffer
+ /*!
+ * Must be implemented in child class. This version is for the audio buffer.
+ *
+ * \param data a pointer to the new data
+ * \param size the size of data
+ */
+ virtual void putData(int16 * data, int size) =0;
+
+protected:
+
+ //! The size of the current buffer.
+ int size;
+
+ //! The semaphores that protects the buffer from multiple simultanious access.
+ sem_t semaphore;
+};
+#endif //OUTPUTSTREAM_H
diff --git a/src/mixer/StraightThrough_AT.cpp b/src/mixer/StraightThrough_AT.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7c18f33f4a9c5e7e786f85f0057626b41bb95a50
--- /dev/null
+++ b/src/mixer/StraightThrough_AT.cpp
@@ -0,0 +1,20 @@
+/* Generated by Together */
+
+#include "StraightThrough_AT.h"
+
+StraightThrough_AT::StraightThrough_AT(InternalBuffer* input, OutputStream* output)
+{
+}
+
+StraightThrough_AT::~StraightThrough_AT()
+{
+}
+
+void StraightThrough_AT::run()
+{
+}
+
+StraightThrough_AT::StraightThrough_AT()
+{
+}
+
diff --git a/src/mixer/StraightThrough_AT.h b/src/mixer/StraightThrough_AT.h
new file mode 100644
index 0000000000000000000000000000000000000000..8521bf31d36ce9f3959cc2f8e2efc1693035340b
--- /dev/null
+++ b/src/mixer/StraightThrough_AT.h
@@ -0,0 +1,45 @@
+/* Generated by Together */
+
+#ifndef STRAIGHTTHROUGH_AT_H
+#define STRAIGHTTHROUGH_AT_H
+#include "AudioMixer.h"
+
+//! Straight Through audio mixer
+/*!
+ * Used when only one input is specified to the mixer
+ */
+class StraightThrough_AT : public AudioMixer {
+public:
+
+ //! Constructor
+ /*!
+ * Initializes the audio mixer
+ *
+ * \param input a pointer to the InternalBuffer acting as input.
+ * \param output a pointer to where the ouput is to be placed.
+ */
+ StraightThrough_AT(InternalBuffer* input, OutputStream* output);
+
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~StraightThrough_AT();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. It essentially copies the input to the ouput.
+ */
+ virtual void run();
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent declaration without the proper buffers
+ */
+ StraightThrough_AT();
+
+};
+#endif //STRAIGHTTHROUGH_AT_H
diff --git a/src/mixer/StraightThrough_VT.cpp b/src/mixer/StraightThrough_VT.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e6666b41edb916def1cc59b4e52bdbe7abf22649
--- /dev/null
+++ b/src/mixer/StraightThrough_VT.cpp
@@ -0,0 +1,30 @@
+/* Generated by Together */
+
+#include "StraightThrough_VT.h"
+#include "InternalBuffer.h"
+#include "OutputStream.h"
+
+StraightThrough_VT::~StraightThrough_VT()
+{
+}
+
+void StraightThrough_VT::run()
+{
+}
+
+void StraightThrough_VT::pause()
+{
+}
+
+void StraightThrough_VT::restart()
+{
+}
+
+StraightThrough_VT::StraightThrough_VT(InternalBuffer* video, OutputStream* output, CodecInfo* infos)
+{
+}
+
+StraightThrough_VT::StraightThrough_VT()
+{
+}
+
diff --git a/src/mixer/StraightThrough_VT.h b/src/mixer/StraightThrough_VT.h
new file mode 100644
index 0000000000000000000000000000000000000000..45bfebd840d529483946f5a36d0028b020abfa42
--- /dev/null
+++ b/src/mixer/StraightThrough_VT.h
@@ -0,0 +1,54 @@
+/* Generated by Together */
+
+#ifndef STRAIGHTTHROUGH_VT_H
+#define STRAIGHTTHROUGH_VT_H
+#include "VideoMixer.h"
+
+//! Straight Through video mixer
+/*!
+ * Used when only one input is specifed to the mixer
+ */
+class StraightThrough_VT : public VideoMixer {
+public:
+
+ //! Constructor
+ /*!
+ * Initalizes the video mixer with the proper information
+ *
+ * \param video a pointer to an InternalBuffer acting as input
+ * \param output a pointer to an OutputStream
+ * \param infos a pointer to the CodecInfo
+ */
+ StraightThrough_VT(InternalBuffer* video, OutputStream* output, CodecInfo* infos);
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~StraightThrough_VT();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. It essentially copies the input to the ouput.
+ */
+ virtual void run();
+
+ //! Pauses the work done by the run method
+ virtual void pause();
+
+ //! Resumes the work done by the run method
+ /*!
+ * Normally used after a pause.
+ */
+ virtual void restart();
+
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent declaration without the proper buffers
+ */
+ StraightThrough_VT();
+};
+#endif //STRAIGHTTHROUGH_VT_H
diff --git a/src/mixer/SynchManager.h b/src/mixer/SynchManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..251980739bdf581dfca3f5c6b81c87bdcb218211
--- /dev/null
+++ b/src/mixer/SynchManager.h
@@ -0,0 +1,35 @@
+/* Generated by Together */
+
+#ifndef SYNCHMANAGER_H
+#define SYNCHMANAGER_H
+
+#include <cc++/thread.h>
+#include "InternalBuffer.h"
+#include "InputStreams.h"
+
+/** @interface */
+//! Synchronization manager interface
+/*!
+ * Supplies all the methods and attributes needed for a sychmanager
+ */
+class SynchManager : public ost::Thread {
+public:
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. Must be implemeted by the child class.
+ */
+ virtual void run() = 0;
+
+protected:
+
+ //! The inputs to the synchronization manager
+ InputStreams* input;
+
+ //! The InternalBuffer corresponding to the video ouput of this sychmanager
+ InternalBuffer* videoBuffer;
+
+ //! The InternalBuffer corresponding to the audio ouput of this sychmanager
+ InternalBuffer* audioBuffer;
+};
+#endif //SYNCHMANAGER_H
diff --git a/src/mixer/TimeInfo.cpp b/src/mixer/TimeInfo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b5465ecfd4656e5a8605c8d02639f1a35ac0b75
--- /dev/null
+++ b/src/mixer/TimeInfo.cpp
@@ -0,0 +1,19 @@
+/* Generated by Together */
+
+#include "TimeInfo.h"
+
+
+TimeInfo::TimeInfo()
+{
+
+}
+
+TimeInfo::TimeInfo(int infos)
+{
+
+}
+
+int TimeInfo::getTemps()
+{
+ return 0;
+}
diff --git a/src/mixer/TimeInfo.h b/src/mixer/TimeInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ddb9b36c0718f1403a3d754066b01d1b78b530e
--- /dev/null
+++ b/src/mixer/TimeInfo.h
@@ -0,0 +1,20 @@
+/* Generated by Together */
+
+#ifndef TIMEINFO_H
+#define TIMEINFO_H
+class TimeInfo {
+public:
+
+
+ TimeInfo(int infos);
+
+private:
+ TimeInfo();
+public:
+
+ int getTemps();
+
+private:
+ int temps;
+};
+#endif //TIMEINFO_H
diff --git a/src/mixer/VideoInput.cpp b/src/mixer/VideoInput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..387665ef03fdbee73ec0799dd64a9ba1b144170e
--- /dev/null
+++ b/src/mixer/VideoInput.cpp
@@ -0,0 +1,36 @@
+/* Generated by Together */
+
+#include "VideoInput.h"
+#include "TimeInfo.h"
+
+
+int VideoInput::fetchData(char* data) const
+{
+ return 0;
+}
+
+TimeInfo VideoInput::fetchTimeInfo() const
+{
+ TimeInfo tmp(0);
+ return tmp;
+}
+
+void VideoInput::putData(char * data, int size)
+{
+
+}
+
+VideoInput::VideoInput()
+{
+
+}
+
+VideoInput::~VideoInput()
+{
+
+}
+
+void VideoInput::putTimeInfo(TimeInfo* infos)
+{
+
+}
diff --git a/src/mixer/VideoInput.h b/src/mixer/VideoInput.h
new file mode 100644
index 0000000000000000000000000000000000000000..8100c5b8900b00cb551f2ba54a34271dadf8d507
--- /dev/null
+++ b/src/mixer/VideoInput.h
@@ -0,0 +1,64 @@
+/* Generated by Together */
+
+#ifndef VIDEOINPUT_H
+#define VIDEOINPUT_H
+
+#include <semaphore.h>
+#include "TimeInfo.h"
+
+//! Video input buffer
+/*!
+ * This class is the video input buffer of a mixer InputStreams
+ */
+
+class VideoInput {
+public:
+
+ //! Default Constructor
+ /*!
+ * Initialise the buffer
+ */
+ VideoInput();
+
+ //! Destructor
+ /*
+ * Cleanly disposes of the buffer
+ */
+ ~VideoInput();
+
+ //! Access the data contained the the buffer
+ /*!
+ * This method returns the data. Buffer access is protected to prevent simultanious access.
+ *
+ * \param data a pointer to where the data must be copied
+ * \return the size of the fetched data
+ */
+ virtual int fetchData(char* data) const;
+
+ //! Access the timing information
+ /*!
+ * This method returns the timestamp for the data contained in the buffer. The data is used by the synchonization manager to mix the streams
+ */
+ virtual TimeInfo fetchTimeInfo() const;
+
+ //! Changes the data contained in the buffer
+ /*!
+ * This method changes the data contained in the buffer. Buffer access is protected to prevent simultanious access.
+ *
+ * \param data a pointer to a data buffer
+ * \param size the size of the buffer
+ */
+ virtual void putData(char * data, int size);
+
+ void putTimeInfo(TimeInfo* infos);
+
+private:
+
+ //! Simultanious access protection semaphore
+ sem_t semaphore;
+
+ //! Internal data buffer
+ char * buffer;
+ TimeInfo* infoTemps;
+};
+#endif //VIDEOINPUT_H
diff --git a/src/mixer/VideoMixer.cpp b/src/mixer/VideoMixer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9083f9d516297976f7e3b17f567296f233ee19bd
--- /dev/null
+++ b/src/mixer/VideoMixer.cpp
@@ -0,0 +1,8 @@
+/* Generated by Together */
+
+#include "VideoMixer.h"
+#include "InternalBuffer.h"
+#include "OutputStream.h"
+void VideoMixer::initBuffer(){ }
+void VideoMixer::setCodecInfo(CodecInfo* infos){ }
+void VideoMixer::resetBuffer(){ }
diff --git a/src/mixer/VideoMixer.h b/src/mixer/VideoMixer.h
new file mode 100644
index 0000000000000000000000000000000000000000..576d1fc7fd42bb7892258ebcf5c7ef91d8199a41
--- /dev/null
+++ b/src/mixer/VideoMixer.h
@@ -0,0 +1,71 @@
+/* Generated by Together */
+
+#ifndef VIDEOMIXER_H
+#define VIDEOMIXER_H
+
+#include "InternalBuffer.h"
+#include "OutputStream.h"
+#include <cc++/thread.h>
+
+//TODO Ã enlever et corriger
+class CodecInfo{
+public:
+ int i;
+};
+
+//! Video mixer interface
+/*!
+ * Abstract class acting as an interface for multiple type of video mixers. This class also acts as a thread once started.
+ */
+class VideoMixer : public ost::Thread {
+public:
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. This method must be implemented in the child class.
+ */
+ virtual void run() = 0;
+
+ //! Method tu set the codec information
+ /*!
+ * \param infos a pointer to a CodecInfo object
+ */
+ virtual void setCodecInfo(CodecInfo* infos);
+
+ //! Pauses the work done by the run method
+ /*!
+ * Must be implemented by the child class
+ */
+ virtual void pause() = 0;
+
+ //! Resumes the work done by the run method
+ /*!
+ * Normally used after a pause. Must be implemented by the child class.
+ */
+ virtual void restart() = 0;
+
+protected:
+
+ //! Resets the buffer
+ /*!
+ * Sets th� buffer to 0 (black background)
+ */
+ virtual void resetBuffer();
+
+ //! Initiates the buffer
+ virtual void initBuffer();
+
+ //! Internal Buffer
+ char * buffer;
+
+ //! Current codec information for ouput format needed
+ CodecInfo* infos;
+
+ //! Input video buffer
+ InternalBuffer* videoBuffer;
+
+ //! Output buffer
+ OutputStream* videoOuput;
+
+};
+#endif //VIDEOMIXER_H
diff --git a/src/mixer/VideoMixer2Channels.cpp b/src/mixer/VideoMixer2Channels.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..27a573c5ec7c41e11cb08d3902235503aac3e692
--- /dev/null
+++ b/src/mixer/VideoMixer2Channels.cpp
@@ -0,0 +1,28 @@
+/* Generated by Together */
+
+#include "VideoMixer2Channels.h"
+#include "OutputStream.h"
+
+VideoMixer2Channels::~VideoMixer2Channels()
+{
+}
+
+void VideoMixer2Channels::run()
+{
+}
+
+void VideoMixer2Channels::pause()
+{
+}
+
+void VideoMixer2Channels::restart()
+{
+}
+
+VideoMixer2Channels::VideoMixer2Channels(InternalBuffer* video1, InternalBuffer* video2, OutputStream* output, CodecInfo* infos)
+{
+}
+
+VideoMixer2Channels::VideoMixer2Channels()
+{
+}
diff --git a/src/mixer/VideoMixer2Channels.h b/src/mixer/VideoMixer2Channels.h
new file mode 100644
index 0000000000000000000000000000000000000000..754219908a81d3eb6c2ee11e70ee458eab45daf2
--- /dev/null
+++ b/src/mixer/VideoMixer2Channels.h
@@ -0,0 +1,55 @@
+/* Generated by Together */
+
+#ifndef VIDEOMIXER2CHANNELS_H
+#define VIDEOMIXER2CHANNELS_H
+#include "VideoMixer.h"
+
+//! 2 Channel video mixer implementation
+/*!
+ * This class implement a mixer that takes in 2 video sources and outputs only one.
+ */
+class VideoMixer2Channels : public VideoMixer {
+public:
+
+ //! Contructor
+ /*!
+ * Assigns the input and output buffers
+ *
+ * \param video1 an input buffer see InternalBuffer
+ * \param video2 an input buffer see InternalBuffer
+ * \param output an output buffer see OutputStream
+ * \param infos a pointer to a CodecInfo object
+ */
+ VideoMixer2Channels(InternalBuffer* video1, InternalBuffer* video2, OutputStream* output, CodecInfo* infos);
+
+ //! Destructor
+ /*!
+ * Terminates the thread, you can also call the terminate method explicitly
+ */
+ ~VideoMixer2Channels();
+
+ //! Thread main method
+ /*!
+ * Actually does the work in the thread. It mixes the 2 inputs into one output.
+ */
+ virtual void run();
+
+ //! Pauses the work done by the run method
+ virtual void pause();
+
+ //! Resumes the work done by the run method
+ /*!
+ * Normally used after a pause.
+ */
+ virtual void restart();
+
+private:
+
+ //! Default Constructor
+ /*!
+ * Implemented as private to prevent declaration without the proper buffers
+ */
+ VideoMixer2Channels();
+
+};
+#endif //VIDEOMIXER2CHANNELS_H
diff --git a/src/mixer/VideoOutput.cpp b/src/mixer/VideoOutput.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..450fa8b6df6a29177d8c349e0eedbb4ab09bfb3e
--- /dev/null
+++ b/src/mixer/VideoOutput.cpp
@@ -0,0 +1,35 @@
+/* Generated by Together */
+
+#include "VideoOutput.h"
+
+
+int VideoOutput::fetchData(char* data)
+{
+ return 0;
+}
+
+void VideoOutput::putData(char * data, int size)
+{
+
+}
+
+VideoOutput::VideoOutput()
+{
+
+}
+
+VideoOutput::~VideoOutput()
+{
+
+}
+
+int VideoOutput::fetchData(int16 *data)
+{
+ return 0;
+}
+
+void VideoOutput::putData(int16 * data, int size)
+{
+
+}
+
diff --git a/src/mixer/VideoOutput.h b/src/mixer/VideoOutput.h
new file mode 100644
index 0000000000000000000000000000000000000000..400248666c65698ffbea2d45dffba77d8e4128bc
--- /dev/null
+++ b/src/mixer/VideoOutput.h
@@ -0,0 +1,61 @@
+/* Generated by Together */
+
+#ifndef VIDEOOUTPUT_H
+#define VIDEOOUTPUT_H
+#include "OutputStream.h"
+
+//! Video Ouput Buffer
+/*!
+ * This class acts as an Video output buffer. It implements the OutputStream interface
+ */
+class VideoOutput : public OutputStream {
+public:
+
+ //! Default constructor
+ /*!
+ * Initialises the internal buffer
+ */
+ VideoOutput();
+
+ //! Destructor
+ /*!
+ * Cleanly diposes of the buffer
+ */
+ ~VideoOutput();
+
+ //! Method to get the data contained by the buffer
+ /*!
+ * \param data a pointer to the where the data will be put
+ * \return the size of the buffer
+ */
+ virtual int fetchData(char* data);
+
+ //! Method to change the data contained in the buffer
+ /*!
+ * \param data a pointer to the data to copy
+ * \param size th size of the buffer
+ */
+ virtual void putData(char * data, int size);
+
+
+protected:
+
+ //! Data Buffer for the video data
+ char * buffer;
+
+private:
+
+ //! Method to change the data in the buffer
+ /*!
+ * This method is implemented as private and \b should \b not \b be \b used in VideoOutput. This method is inherited from OutputStream. putData(char * data, int size) instead.
+ */
+ virtual void putData(int16 * data, int size) __attribute__ ((deprecated));
+
+ //! Method to get the data in the buffer
+ /*!
+ * This method is implemented as private and \b should \b not \b be \b used in VideoOutput. This method is inherited from OutputStream. Use fetchData(char* data) instead.
+ */
+ virtual int fetchData(int16 *data) __attribute__ ((deprecated));
+
+};
+#endif //VIDEOOUTPUT_H
diff --git a/src/video/Makefile.am b/src/video/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..6453570334b209496214d8cc6866b571faa1f4b6
--- /dev/null
+++ b/src/video/Makefile.am
@@ -0,0 +1,10 @@
+SUBDIRS = VideoCodec V4L
+
+noinst_LTLIBRARIES = libvideo.la
+
+libvideo_la_SOURCES = VideoCodecDescriptor.cpp \
+ VideoCodecDescriptor.cpp \
+ VideoRtp.cpp \
+ VideoRtpRTX.cpp
+
+AM_CXXFLAGS = -I$(top_srcdir)/include $(libccext2_CFLAGS) $(LIBAVCODEC_CFLAGS) "/usr/include/ffmpeg" $(USER_INCLUDES)
diff --git a/src/video/V4L/Brightness.cpp b/src/video/V4L/Brightness.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e3737ff5a143bb0d2bca8e248b8cdfb6c613eab
--- /dev/null
+++ b/src/video/V4L/Brightness.cpp
@@ -0,0 +1,34 @@
+/* Generated by Together */
+
+#include "Brightness.h"
+
+
+ Brightness::Brightness(){}
+
+ Brightness::~Brightness(){}
+
+ bool Brightness::increase(int value){
+
+ return true;
+ }
+
+ bool Brightness::decrease(int value){
+
+ return true;
+ }
+
+ bool Brightness::setTo(int value){
+
+ return true;
+ }
+
+ bool Brightness::reset(){
+
+ return true;
+ }
+
+ char* Brightness::GetBrightness(){
+
+ return 0;
+ }
+
diff --git a/src/video/V4L/Brightness.h b/src/video/V4L/Brightness.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad605701318412f8c14127efd34aec29c185c697
--- /dev/null
+++ b/src/video/V4L/Brightness.h
@@ -0,0 +1,60 @@
+/* Generated by Together */
+
+#ifndef BRIGHTNESS_H
+#define BRIGHTNESS_H
+#include "Command.h"
+
+//! Brightness
+/*!
+ * This class is used to set and get the brightness of the video device
+ */
+class Brightness : public Command {
+public:
+
+ //! Constructor
+ Brightness();
+
+
+ //! Destructor
+ ~Brightness();
+
+
+ //! Method to increase the value of the brightness
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool increase(int value);
+
+
+ //! Method to decrease the value of the brightness
+ /*!
+ * \param value that will be subtracted (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool decrease(int value);
+
+
+ //! Method to set the brightness to an exact value
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool setTo(int value);
+
+
+ //! Method to reset the brightness to its initial value
+ /*!
+ * \return a bool representing the success of the operation
+ */
+ virtual bool reset();
+
+
+ //! Method to get the brightness value
+ /*!
+ * \return a string representing the value of the brightness
+ */
+ char* GetBrightness();
+};
+#endif //BRIGHTNESS_H
+
diff --git a/src/video/V4L/Capture.cpp b/src/video/V4L/Capture.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b0dcaf29e4e41954a91f942f34eaed5c29ebbc92
--- /dev/null
+++ b/src/video/V4L/Capture.cpp
@@ -0,0 +1,45 @@
+/* Generated by Together */
+
+#include "Capture.h"
+#include "CaptureMode.h"
+
+ Capture::Capture(){}
+
+ Capture::~Capture(){}
+
+ bool Capture::nextCaptureMode(){}
+
+ bool Capture::forceCaptureMode(int captModePos){
+
+ return true;
+ }
+
+ void Capture::createCaptureModesVector(){}
+
+ bool Capture::decrease(int value){
+
+ return true;
+ }
+
+ bool Capture::setTo(int value){
+
+ return true;
+ }
+
+ bool Capture::reset(){
+
+ return true;
+ }
+
+ char* Capture::GetCapture(){
+ char* test;
+
+ *test = 't';
+
+ return test;
+ }
+
+ bool Capture::increase(int value){
+
+ return true;
+ }
diff --git a/src/video/V4L/Capture.h b/src/video/V4L/Capture.h
new file mode 100644
index 0000000000000000000000000000000000000000..e67445cd406e04ac316dda185e2f416ce7188a22
--- /dev/null
+++ b/src/video/V4L/Capture.h
@@ -0,0 +1,91 @@
+/* Generated by Together */
+
+#ifndef CAPTURE_H
+#define CAPTURE_H
+
+#include <vector>
+
+#include "CaptureMode.h"
+#include "Command.h"
+
+using namespace std;
+//! Capture
+/*!
+ * This class is used to get a capture from the video device
+ */
+class Capture : public Command {
+public:
+
+ //! Constructor
+ Capture();
+
+ //! Destructor
+ ~Capture();
+
+
+ //! Method to switch to the next CaptureMode in the vector
+ /*!
+ * \return a bool representing the success of the operation
+ */
+ bool nextCaptureMode();
+
+
+ //! Method to force the class to use a specific CaptureMode in the vector
+ /*!
+ * \param captModePos the position of the CaptureMode in the vector
+ * \return a bool representing the success of the operation
+ */
+ bool forceCaptureMode(int captModePos);
+
+
+ //! Method to create and initialise the captureModes vector
+ /*!
+ * Create the captureMode objects and then create the vector
+ */
+ void createCaptureModesVector();
+
+
+ //! Method to capture from the video source
+ /*!
+ * \return a pointer to the captured data
+ */
+ char* GetCapture();
+
+private:
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool setTo(int value);
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool reset();
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool decrease(int value);
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool increase(int value);
+
+ //! The position of the CaptureMode to use in the CaptrueMode vector
+ int currentCaptureMode;
+
+ /**
+ * @supplierCardinality 1..*
+ */
+ //! Vector of pointers to the CaptureModes to use
+ vector<CaptureMode*> captureModesVector;
+
+};
+#endif //CAPTURE_H
+
diff --git a/src/video/V4L/CaptureMode.cpp b/src/video/V4L/CaptureMode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4ca74a46d2cc79260e5436877a1db752a25c8b3d
--- /dev/null
+++ b/src/video/V4L/CaptureMode.cpp
@@ -0,0 +1,7 @@
+/* Generated by Together */
+
+#include "CaptureMode.h"
+
+CaptureMode::CaptureMode(){}
+
+CaptureMode::~CaptureMode(){}
diff --git a/src/video/V4L/CaptureMode.h b/src/video/V4L/CaptureMode.h
new file mode 100644
index 0000000000000000000000000000000000000000..0015e8ebca14dbb83971d82b73835ebff03fcf9b
--- /dev/null
+++ b/src/video/V4L/CaptureMode.h
@@ -0,0 +1,27 @@
+/* Generated by Together */
+
+#ifndef CAPTUREMODE_H
+#define CAPTUREMODE_H
+
+
+//! CaptureMode
+/*!
+ * This abstract class acts as an interface for multiple types of capture mode
+ */
+class CaptureMode {
+public:
+
+ //! Constructor
+ CaptureMode();
+
+ //! Destructor
+ ~CaptureMode();
+
+ //! The capture method
+ /*!
+ * Must be implemented by the child class
+ */
+ virtual char* capture()=0;
+};
+#endif //CAPTUREMODE_H
+
diff --git a/src/video/V4L/Colour.cpp b/src/video/V4L/Colour.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c553bc96b405f92422e41c60306daac2ea8bf47e
--- /dev/null
+++ b/src/video/V4L/Colour.cpp
@@ -0,0 +1,32 @@
+/* Generated by Together */
+
+#include "Colour.h"
+
+ Colour::Colour(){}
+
+ Colour::~Colour(){}
+
+ bool Colour::increase(int value){
+
+ return true;
+ }
+
+ bool Colour::decrease(int value){
+
+ return true;
+ }
+
+ bool Colour::setTo(int value){
+
+ return true;
+ }
+
+ bool Colour::reset(){
+
+ return true;
+ }
+
+ char* Colour::GetColour(){
+
+ return 0;
+ }
diff --git a/src/video/V4L/Colour.h b/src/video/V4L/Colour.h
new file mode 100644
index 0000000000000000000000000000000000000000..1118e313ad0bee10724b8f5f8c8cf5c091c7873c
--- /dev/null
+++ b/src/video/V4L/Colour.h
@@ -0,0 +1,57 @@
+/* Generated by Together */
+
+#ifndef COLOUR_H
+#define COLOUR_H
+#include "Command.h"
+
+//! Luminosity
+/*!
+ * This class is used to set and get the colour value of the video device
+ */
+class Colour : public Command {
+public:
+
+ //! Constructor
+ Colour();
+
+ //! Destructor
+ ~Colour();
+
+ //! Method to increase the value of the colour
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool increase(int value);
+
+
+ //! Method to decrease the value of the colour
+ /*!
+ * \param value that will be subtracted (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool decrease(int value);
+
+
+ //! Method to set the colour to an exact value
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool setTo(int value);
+
+
+ //! Method to reset the colour to its initial value
+ /*!
+ * \return a bool representing the success of the operation
+ */
+ virtual bool reset();
+
+
+ //! Method to get the colour value
+ /*!
+ * \return a string representing the value of the colour
+ */
+ char* GetColour();
+};
+#endif //COLOUR_H
diff --git a/src/video/V4L/Command.cpp b/src/video/V4L/Command.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fffa486fc617a7041601b4c428c89891b98769c5
--- /dev/null
+++ b/src/video/V4L/Command.cpp
@@ -0,0 +1,11 @@
+/* Generated by Together */
+
+#include "Command.h"
+#include "VideoDevice.h"
+
+ //! A static pointer to access to the actual VideoDevice
+// VideoDevice* Command::videoDev = 0;
+
+ Command::Command(){}
+
+ Command::~Command(){}
diff --git a/src/video/V4L/Command.h b/src/video/V4L/Command.h
new file mode 100644
index 0000000000000000000000000000000000000000..e98430d8d5a57c1e6b3f65f916f44e192efd6e68
--- /dev/null
+++ b/src/video/V4L/Command.h
@@ -0,0 +1,66 @@
+/* Generated by Together */
+
+#ifndef COMMAND_H
+#define COMMAND_H
+#include "VideoDevice.h"
+
+
+//! Command
+/*!
+ * This abstract class acts as an interface for multiple types of commands (to set and get proprieties of the video device)
+ */
+class Command {
+public:
+
+ //! Constructor
+ Command();
+
+
+ //! Destructor
+ ~Command();
+
+
+ //! Method to increase the value of the propriety
+ /*!
+ * Must be implemented by the child class
+ * \return a bool representing the success of the operation
+ */
+ virtual bool increase(int value) =0;
+
+
+ //! Method to decrease the value of the propriety
+ /*!
+ * Must be implemented by the child class
+ * \return a bool representing the success of the operation
+ */
+ virtual bool decrease(int value) =0;
+
+
+ //! Method to set the propriety to an exact value
+ /*!
+ * Must be implemented by the child class
+ * \return a bool representing the success of the operation
+ */
+ virtual bool setTo(int value) =0;
+
+
+ //! Method to reset the propriety to its initial value
+ /*!
+ * Must be implemented by the child class
+ * \return a bool representing the success of the operation
+ */
+ virtual bool reset() =0;
+
+
+private:
+
+ /**
+ * @clientCardinality 0..*
+ * @supplierCardinality 1
+ */
+
+ //! A static pointer to access to the actual VideoDevice
+ static VideoDevice* videoDev;
+};
+#endif //COMMAND_H
+
diff --git a/src/video/V4L/Contrast.cpp b/src/video/V4L/Contrast.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3573125e58b37068ae597bcfb278cf27529f61c8
--- /dev/null
+++ b/src/video/V4L/Contrast.cpp
@@ -0,0 +1,32 @@
+/* Generated by Together */
+
+#include "Contrast.h"
+
+ Contrast::Contrast(){}
+
+ Contrast::~Contrast(){}
+
+ bool Contrast::increase(int){
+
+ return true;
+ }
+
+ bool Contrast::decrease(int){
+
+ return true;
+ }
+
+ bool Contrast::setTo(int){
+
+ return true;
+ }
+
+ bool Contrast::reset(){
+
+ return true;
+ }
+
+ char* Contrast::GetContrast(){
+
+ return 0;
+ }
diff --git a/src/video/V4L/Contrast.h b/src/video/V4L/Contrast.h
new file mode 100644
index 0000000000000000000000000000000000000000..1135f78f58eb137c1d6e5e1a67a8f88f5aea113f
--- /dev/null
+++ b/src/video/V4L/Contrast.h
@@ -0,0 +1,62 @@
+/* Generated by Together */
+
+#ifndef CONTRAST_H
+#define CONTRAST_H
+#include "Command.h"
+#include <string>
+
+using namespace std;
+
+//! Contrast
+/*!
+ * This class is used to set and get the contrast value of the video device
+ */
+class Contrast : public Command {
+public:
+
+ //! Constructor
+ Contrast();
+
+
+ //! Destructor
+ ~Contrast();
+
+
+ //! Method to increase the value of the contrast
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool increase(int value);
+
+
+ //! Method to decrease the value of the contrast
+ /*!
+ * \param value that will be subtracted (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool decrease(int value);
+
+
+ //! Method to set the contrast to an exact value
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool setTo(int value);
+
+
+ //! Method to reset the contrast to its initial value
+ /*!
+ * \return a bool representing the success of the operation
+ */
+ virtual bool reset();
+
+
+ //! Method to get the contrast value
+ /*!
+ * \return a string representing the value of the contrast
+ */
+ char* GetContrast();
+};
+#endif //CONTRAST_H
diff --git a/src/video/V4L/CopyMode.cpp b/src/video/V4L/CopyMode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..eed3f132f3f3f4665ca4985db25feb6f802f75ab
--- /dev/null
+++ b/src/video/V4L/CopyMode.cpp
@@ -0,0 +1,16 @@
+/* Generated by Together */
+
+#include "CopyMode.h"
+
+ CopyMode::CopyMode(){}
+
+ CopyMode::~CopyMode(){}
+
+ char* CopyMode::capture(){
+ char* test;
+
+ *test = 't';
+
+ return test;
+ }
+
diff --git a/src/video/V4L/CopyMode.h b/src/video/V4L/CopyMode.h
new file mode 100644
index 0000000000000000000000000000000000000000..1600ea03657149b67e2850d5178a0dab251e2a95
--- /dev/null
+++ b/src/video/V4L/CopyMode.h
@@ -0,0 +1,26 @@
+/* Generated by Together */
+
+#ifndef COPYMODE_H
+#define COPYMODE_H
+#include "CaptureMode.h"
+
+//! CopyMode
+/*!
+ * This class capture from the video source using a copy mode
+ */
+class CopyMode : public CaptureMode {
+public:
+
+ //! Constructor
+ CopyMode();
+
+ //! Destructor
+ ~CopyMode();
+
+ //! Method to capture from the video source
+ /*!
+ * \return a pointer to the captured data
+ */
+ char* capture();
+};
+#endif //COPYMODE_H
diff --git a/src/video/V4L/Makefile.am b/src/video/V4L/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..895fc646b87220f2e6fb314996c2f36afd8c029e
--- /dev/null
+++ b/src/video/V4L/Makefile.am
@@ -0,0 +1,18 @@
+SUBDIRS =
+
+noinst_LTLIBRARIES = libV4L.la
+
+libV4L_la_SOURCES = Brightness.cpp \
+ Capture.cpp \
+ CaptureMode.cpp \
+ Colour.cpp \
+ Command.cpp \
+ Contrast.cpp \
+ CopyMode.cpp \
+ ReadMode.cpp \
+ Resolution.cpp \
+ VideoDevice.cpp \
+ VideoDeviceManager.cpp
+
+
+AM_CXXFLAGS = -I$(top_srcdir)/include $(libccext2_CFLAGS) $(USER_INCLUDES)
diff --git a/src/video/V4L/ReadMode.cpp b/src/video/V4L/ReadMode.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..707471dfdc2e7a4b7f9540c997495df64b7f0c8f
--- /dev/null
+++ b/src/video/V4L/ReadMode.cpp
@@ -0,0 +1,15 @@
+/* Generated by Together */
+
+#include "ReadMode.h"
+
+ ReadMode::ReadMode(){}
+
+ ReadMode::~ReadMode(){}
+
+ char* ReadMode::capture(){
+ char* test;
+
+ *test = 't';
+
+ return test;
+ }
diff --git a/src/video/V4L/ReadMode.h b/src/video/V4L/ReadMode.h
new file mode 100644
index 0000000000000000000000000000000000000000..e05140cba8c884a4460382e40f43ccf6d8f68822
--- /dev/null
+++ b/src/video/V4L/ReadMode.h
@@ -0,0 +1,26 @@
+/* Generated by Together */
+
+#ifndef READMODE_H
+#define READMODE_H
+#include "CaptureMode.h"
+
+//! CopyMode
+/*!
+ * This class capture from the video source using a read mode
+ */
+class ReadMode : public CaptureMode {
+public:
+
+ //! Constructor
+ ReadMode();
+
+ //! Destructor
+ ~ReadMode();
+
+ //! Method to capture from the video source
+ /*!
+ * \return a pointer to the captured data
+ */
+ char* capture();
+};
+#endif //READMODE_H
diff --git a/src/video/V4L/Resolution.cpp b/src/video/V4L/Resolution.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..33f23ff925ab6056651ddd3c2b3ffe7cd39b7bcb
--- /dev/null
+++ b/src/video/V4L/Resolution.cpp
@@ -0,0 +1,32 @@
+/* Generated by Together */
+
+#include "Resolution.h"
+
+ Resolution::Resolution(){}
+
+ Resolution::~Resolution(){}
+
+ bool Resolution::increase(int value){
+
+ return true;
+ }
+
+ bool Resolution::decrease(int value){
+
+ return true;
+ }
+
+ bool Resolution::setTo(int valueX, int valueY){
+
+ return true;
+ }
+
+ bool Resolution::reset(){
+
+ return true;
+ }
+
+ char* Resolution::GetResolution(){
+
+ return 0;
+ }
diff --git a/src/video/V4L/Resolution.h b/src/video/V4L/Resolution.h
new file mode 100644
index 0000000000000000000000000000000000000000..10b788dda05a4b5ed6ace8dbfb14599d9f3867db
--- /dev/null
+++ b/src/video/V4L/Resolution.h
@@ -0,0 +1,62 @@
+/* Generated by Together */
+
+#ifndef RESOLUTION_H
+#define RESOLUTION_H
+#include "Command.h"
+#include <string>
+
+using namespace std;
+
+//! Resolution
+/*!
+ * This class is used to set and get the resolution of the video device
+ */
+class Resolution : public Command {
+public:
+
+ //! Constructor
+ Resolution();
+
+
+ //! Destructor
+ ~Resolution();
+
+ //! Method to get the resolution value
+ /*!
+ * \return a string representing the value of the resolution (i.e. 320X180)
+ */
+ char* GetResolution();
+
+
+ //! Method to set the resolution to an exact value
+ /*!
+ * \param value that will be added (step value)
+ * \return a bool representing the success of the operation
+ */
+ virtual bool setTo(int valueX, int valueY);
+
+
+ //! Method to reset the resolution to its initial value
+ /*!
+ * \return a bool representing the success of the operation
+ */
+ virtual bool reset();
+
+
+private:
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool increase(int value);
+
+
+ //! This method is not applicable to this class
+ /*!
+ * It is declared as a void methode because it's an abstract methode in the parent class
+ */
+ virtual bool decrease(int value);
+
+};
+#endif //RESOLUTION_H
diff --git a/src/video/V4L/VideoDevice.cpp b/src/video/V4L/VideoDevice.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b8c36c93a0eefb850b66c0e2c783b293e1a46f1
--- /dev/null
+++ b/src/video/V4L/VideoDevice.cpp
@@ -0,0 +1,66 @@
+/* Generated by Together */
+
+#include "VideoDevice.h"
+
+ VideoDevice::VideoDevice(){}
+
+ VideoDevice::~VideoDevice(){}
+
+ bool VideoDevice::CloseDevice(){
+
+ return true;
+ }
+
+ bool VideoDevice::OpenDevice(){
+
+ return true;
+ }
+
+ v4l2_format VideoDevice::getVideoFormat(){
+ v4l2_format vF;
+
+ return vF;
+ }
+
+ v4l2_capability VideoDevice::getVideoCapability(){
+ v4l2_capability vC;
+
+ return vC;
+ }
+
+ video_picture VideoDevice::getVideoPicture(){
+ video_picture vP;
+
+ return vP;
+ }
+
+ bool VideoDevice::setVideoFormat(v4l2_format& videoFormat){
+
+ this->videoFormat = videoFormat;
+
+ return true;
+ }
+
+ bool VideoDevice::setVideoCapability(v4l2_capability& videoCapability){
+
+ this->videoCapability = videoCapability;
+
+ return true;
+ }
+
+ bool VideoDevice::setVideoPicture(video_picture& videoPicture){
+
+ this->videoPicture = videoPicture;
+
+ return true;
+ }
+
+ char* VideoDevice::getName(){
+
+ return 0;
+ }
+
+ int VideoDevice::getFileDescript(){
+
+ return 0;
+ }
diff --git a/src/video/V4L/VideoDevice.h b/src/video/V4L/VideoDevice.h
new file mode 100644
index 0000000000000000000000000000000000000000..52d8af77a7bdef9c1299ef8f01b6f0bb879d0522
--- /dev/null
+++ b/src/video/V4L/VideoDevice.h
@@ -0,0 +1,120 @@
+/* Generated by Together */
+
+#ifndef VIDEODEVICE_H
+#define VIDEODEVICE_H
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/videodev.h>
+#include <string>
+
+
+//! VideoDevice
+/*!
+ * This class uses V4L to mange the webcam: capture, access to webcam proprieties...
+ */
+class VideoDevice {
+public:
+
+
+ //! Constructor
+ VideoDevice();
+
+
+ //! Destructor
+ ~VideoDevice();
+
+
+ //! Method to get the name of the video source.
+ /*!
+ * \return the name of the video source
+ */
+ char* getName();
+
+
+ //! Method to get file descriptor
+ /*!
+ * \return the file descriptor int
+ */
+ int getFileDescript();
+
+
+ //! Method to open the video source
+ /*!
+ * \return a bool representing the success of the opening of the video source
+ */
+ bool OpenDevice();
+
+
+ //! Method to close the video source
+ /*!
+ * \return a bool representing the success of the closing of the video source
+ */
+ bool CloseDevice();
+
+
+ //! Method to get all video capabilities
+ /*!
+ * \return structure representing the video capabilities
+ */
+ v4l2_capability getVideoCapability();
+
+
+ //! Method to get all video capabilities
+ /*!
+ * \param videoCapability the attribute to change
+ * \return a bool representing the success of parameters changing
+ */
+ bool setVideoCapability(v4l2_capability& videoCapability);
+
+
+ //! Method to get video picture parameters
+ /*!
+ * \return structure representing the video capabilities
+ */
+ video_picture getVideoPicture();
+
+
+ //! Method to set video picture parameters
+ /*!
+ * \param videoPicture the attribute to change
+ * \return a bool representing the success of parameters changing
+ */
+ bool setVideoPicture(video_picture& videoPicture);
+
+
+ //! Method to get video formats
+ /*!
+ * \return structure representing the video formats
+ */
+ v4l2_format getVideoFormat();
+
+
+ //! Method to set video formats
+ /*!
+ * \param videoFormat the attribute to change
+ * \return a bool representing the success of parameters changing
+ */
+ bool setVideoFormat(v4l2_format& videoFormat);
+
+private:
+
+ //! The name of the actual video source
+ char* name;
+
+ //! The actual file descriptor of the video source
+ int fileDescript;
+
+ //! The actual video formats (contains width and height)
+ v4l2_format videoFormat;
+
+ //! The actual videoCapability (contains ..)
+ v4l2_capability videoCapability;
+
+ //! The actual videoPicture parameters (contains ..)
+ video_picture videoPicture;
+
+};
+#endif //VIDEODEVICE_H
+
diff --git a/src/video/V4L/VideoDeviceManager.cpp b/src/video/V4L/VideoDeviceManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..724023e6d002b2d4e4e6975a6fe01734dcccb114
--- /dev/null
+++ b/src/video/V4L/VideoDeviceManager.cpp
@@ -0,0 +1,38 @@
+/* Generated by Together */
+
+#include "VideoDeviceManager.h"
+#include "VideoDevice.h"
+
+ VideoDeviceManager* VideoDeviceManager::instance = 0;
+
+ VideoDeviceManager* VideoDeviceManager::getInstance(){
+
+ return instance;
+ }
+
+ VideoDeviceManager::VideoDeviceManager(){}
+
+ VideoDeviceManager::~VideoDeviceManager(){}
+
+ bool VideoDeviceManager::changeDevice(VideoDevice* videoDev){
+
+ return true;
+ }
+
+ VideoDevice* VideoDeviceManager::createDevice(char* srcName){
+
+ return 0;
+ }
+
+ VideoDevice* VideoDeviceManager::getDevice(){
+
+ return 0;
+ }
+
+ Command* VideoDeviceManager::getCommand(char* ref){
+
+ return 0;
+ }
+
+
+
diff --git a/src/video/V4L/VideoDeviceManager.h b/src/video/V4L/VideoDeviceManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..31590814d87a9cc54248629c2383967949fe6ae3
--- /dev/null
+++ b/src/video/V4L/VideoDeviceManager.h
@@ -0,0 +1,76 @@
+/* Generated by Together */
+
+#ifndef VIDEODEVICEMANAGER_H
+#define VIDEODEVICEMANAGER_H
+#include "Command.h"
+#include "VideoDevice.h"
+
+//! VideoDeviceManager
+/*!
+ * This class manages the video device, it make the link between the device and his properties objects (brightness, luminosity...). It also creates the DeviceManger object and it can change it too. Only one instance of the manager can exist at one time
+ */
+class VideoDeviceManager {
+public:
+
+
+ //! Constructor.
+ VideoDeviceManager();
+
+
+ //! Destructor
+ ~VideoDeviceManager();
+
+
+ //! Method to get a new command (propriety)
+ /*!
+ * This method creates a new command (a propriety of the video device) and returns a pointer to this command
+ *
+ * \param ref the reference of the command
+ * \return a pointer to the created command
+ */
+ Command* getCommand(char* ref);
+
+
+ //! Method to get the instance of the actual VideoDevice.
+ /*!
+ * \return an instance of the actual VideoDevice
+ */
+ VideoDevice* getDevice();
+
+
+ //! Method to create a new VideoDevice.
+ /*!
+ * \param srcName the name of the camera that the new VideoDevice will use as a source.
+ * \return a pointer to the new VideoDevice (needed to change the device)
+ */
+ VideoDevice* createDevice(char* srcName);
+
+
+ //! Method to change the VideoDevice.
+ /*!
+ * \param videoDev the pointer to the new VideoDevice
+ * \return a bool representing the success of the VideoDevice change
+ */
+ bool changeDevice(VideoDevice* videoDev);
+
+
+ //! Method to get the instance of the VideoDeviceManager.
+ /*!
+ * If it does not exist, this method will create it
+ *
+ * \return an instance of the VideoDeviceManager
+ */
+ static VideoDeviceManager* getInstance();
+
+private:
+
+ /** @link dependency */
+ /*# Command lnkCommand; */
+ //! The instance of the VideoDeviceManager
+ static VideoDeviceManager* instance;
+
+ //! The pointer of the actual VideoDevice
+ static VideoDevice* actualVideoDevice;
+
+};
+#endif //VIDEODEVICEMANAGER_H
diff --git a/src/video/V4L/videodev.h b/src/video/V4L/videodev.h
new file mode 100644
index 0000000000000000000000000000000000000000..f912a1d751617535465036d1feccc8bf8625bcef
--- /dev/null
+++ b/src/video/V4L/videodev.h
@@ -0,0 +1,347 @@
+/*
+ * Video for Linux version 1 - OBSOLETE
+ *
+ * Header file for v4l1 drivers and applications, for
+ * Linux kernels 2.2.x or 2.4.x.
+ *
+ * Provides header for legacy drivers and applications
+ *
+ * See http://linuxtv.org for more info
+ *
+ */
+#ifndef __LINUX_VIDEODEV_H
+#define __LINUX_VIDEODEV_H
+
+#include <linux/videodev2.h>
+
+#if defined(CONFIG_VIDEO_V4L1_COMPAT) || !defined (__KERNEL__)
+
+struct video_capability
+{
+ char name[32];
+ int type;
+ int channels; /* Num channels */
+ int audios; /* Num audio devices */
+ int maxwidth; /* Supported width */
+ int maxheight; /* And height */
+ int minwidth; /* Supported width */
+ int minheight; /* And height */
+};
+
+
+struct video_channel
+{
+ int channel;
+ char name[32];
+ int tuners;
+ __u32 flags;
+#define VIDEO_VC_TUNER 1 /* Channel has a tuner */
+#define VIDEO_VC_AUDIO 2 /* Channel has audio */
+ __u16 type;
+#define VIDEO_TYPE_TV 1
+#define VIDEO_TYPE_CAMERA 2
+ __u16 norm; /* Norm set by channel */
+};
+
+struct video_tuner
+{
+ int tuner;
+ char name[32];
+ unsigned long rangelow, rangehigh; /* Tuner range */
+ __u32 flags;
+#define VIDEO_TUNER_PAL 1
+#define VIDEO_TUNER_NTSC 2
+#define VIDEO_TUNER_SECAM 4
+#define VIDEO_TUNER_LOW 8 /* Uses KHz not MHz */
+#define VIDEO_TUNER_NORM 16 /* Tuner can set norm */
+#define VIDEO_TUNER_STEREO_ON 128 /* Tuner is seeing stereo */
+#define VIDEO_TUNER_RDS_ON 256 /* Tuner is seeing an RDS datastream */
+#define VIDEO_TUNER_MBS_ON 512 /* Tuner is seeing an MBS datastream */
+ __u16 mode; /* PAL/NTSC/SECAM/OTHER */
+#define VIDEO_MODE_PAL 0
+#define VIDEO_MODE_NTSC 1
+#define VIDEO_MODE_SECAM 2
+#define VIDEO_MODE_AUTO 3
+ __u16 signal; /* Signal strength 16bit scale */
+};
+
+struct video_picture
+{
+ __u16 brightness;
+ __u16 hue;
+ __u16 colour;
+ __u16 contrast;
+ __u16 whiteness; /* Black and white only */
+ __u16 depth; /* Capture depth */
+ __u16 palette; /* Palette in use */
+#define VIDEO_PALETTE_GREY 1 /* Linear greyscale */
+#define VIDEO_PALETTE_HI240 2 /* High 240 cube (BT848) */
+#define VIDEO_PALETTE_RGB565 3 /* 565 16 bit RGB */
+#define VIDEO_PALETTE_RGB24 4 /* 24bit RGB */
+#define VIDEO_PALETTE_RGB32 5 /* 32bit RGB */
+#define VIDEO_PALETTE_RGB555 6 /* 555 15bit RGB */
+#define VIDEO_PALETTE_YUV422 7 /* YUV422 capture */
+#define VIDEO_PALETTE_YUYV 8
+#define VIDEO_PALETTE_UYVY 9 /* The great thing about standards is ... */
+#define VIDEO_PALETTE_YUV420 10
+#define VIDEO_PALETTE_YUV411 11 /* YUV411 capture */
+#define VIDEO_PALETTE_RAW 12 /* RAW capture (BT848) */
+#define VIDEO_PALETTE_YUV422P 13 /* YUV 4:2:2 Planar */
+#define VIDEO_PALETTE_YUV411P 14 /* YUV 4:1:1 Planar */
+#define VIDEO_PALETTE_YUV420P 15 /* YUV 4:2:0 Planar */
+#define VIDEO_PALETTE_YUV410P 16 /* YUV 4:1:0 Planar */
+#define VIDEO_PALETTE_PLANAR 13 /* start of planar entries */
+#define VIDEO_PALETTE_COMPONENT 7 /* start of component entries */
+};
+
+struct video_audio
+{
+ int audio; /* Audio channel */
+ __u16 volume; /* If settable */
+ __u16 bass, treble;
+ __u32 flags;
+#define VIDEO_AUDIO_MUTE 1
+#define VIDEO_AUDIO_MUTABLE 2
+#define VIDEO_AUDIO_VOLUME 4
+#define VIDEO_AUDIO_BASS 8
+#define VIDEO_AUDIO_TREBLE 16
+#define VIDEO_AUDIO_BALANCE 32
+ char name[16];
+#define VIDEO_SOUND_MONO 1
+#define VIDEO_SOUND_STEREO 2
+#define VIDEO_SOUND_LANG1 4
+#define VIDEO_SOUND_LANG2 8
+ __u16 mode;
+ __u16 balance; /* Stereo balance */
+ __u16 step; /* Step actual volume uses */
+};
+
+struct video_clip
+{
+ __s32 x,y;
+ __s32 width, height;
+ struct video_clip *next; /* For user use/driver use only */
+};
+
+struct video_window
+{
+ __u32 x,y; /* Position of window */
+ __u32 width,height; /* Its size */
+ __u32 chromakey;
+ __u32 flags;
+ struct video_clip *clips; /* Set only */
+ int clipcount;
+#define VIDEO_WINDOW_INTERLACE 1
+#define VIDEO_WINDOW_CHROMAKEY 16 /* Overlay by chromakey */
+#define VIDEO_CLIP_BITMAP -1
+/* bitmap is 1024x625, a '1' bit represents a clipped pixel */
+#define VIDEO_CLIPMAP_SIZE (128 * 625)
+};
+
+struct video_capture
+{
+ __u32 x,y; /* Offsets into image */
+ __u32 width, height; /* Area to capture */
+ __u16 decimation; /* Decimation divider */
+ __u16 flags; /* Flags for capture */
+#define VIDEO_CAPTURE_ODD 0 /* Temporal */
+#define VIDEO_CAPTURE_EVEN 1
+};
+
+struct video_buffer
+{
+ void *base;
+ int height,width;
+ int depth;
+ int bytesperline;
+};
+
+struct video_mmap
+{
+ unsigned int frame; /* Frame (0 - n) for double buffer */
+ int height,width;
+ unsigned int format; /* should be VIDEO_PALETTE_* */
+};
+
+struct video_key
+{
+ __u8 key[8];
+ __u32 flags;
+};
+
+struct video_mbuf
+{
+ int size; /* Total memory to map */
+ int frames; /* Frames */
+ int offsets[VIDEO_MAX_FRAME];
+};
+
+#define VIDEO_NO_UNIT (-1)
+
+struct video_unit
+{
+ int video; /* Video minor */
+ int vbi; /* VBI minor */
+ int radio; /* Radio minor */
+ int audio; /* Audio minor */
+ int teletext; /* Teletext minor */
+};
+
+struct vbi_format {
+ __u32 sampling_rate; /* in Hz */
+ __u32 samples_per_line;
+ __u32 sample_format; /* VIDEO_PALETTE_RAW only (1 byte) */
+ __s32 start[2]; /* starting line for each frame */
+ __u32 count[2]; /* count of lines for each frame */
+ __u32 flags;
+#define VBI_UNSYNC 1 /* can distingues between top/bottom field */
+#define VBI_INTERLACED 2 /* lines are interlaced */
+};
+
+/* video_info is biased towards hardware mpeg encode/decode */
+/* but it could apply generically to any hardware compressor/decompressor */
+struct video_info
+{
+ __u32 frame_count; /* frames output since decode/encode began */
+ __u32 h_size; /* current unscaled horizontal size */
+ __u32 v_size; /* current unscaled veritcal size */
+ __u32 smpte_timecode; /* current SMPTE timecode (for current GOP) */
+ __u32 picture_type; /* current picture type */
+ __u32 temporal_reference; /* current temporal reference */
+ __u8 user_data[256]; /* user data last found in compressed stream */
+ /* user_data[0] contains user data flags, user_data[1] has count */
+};
+
+/* generic structure for setting playback modes */
+struct video_play_mode
+{
+ int mode;
+ int p1;
+ int p2;
+};
+
+/* for loading microcode / fpga programming */
+struct video_code
+{
+ char loadwhat[16]; /* name or tag of file being passed */
+ int datasize;
+ __u8 *data;
+};
+
+#define VIDIOCGCAP _IOR('v',1,struct video_capability) /* Get capabilities */
+#define VIDIOCGCHAN _IOWR('v',2,struct video_channel) /* Get channel info (sources) */
+#define VIDIOCSCHAN _IOW('v',3,struct video_channel) /* Set channel */
+#define VIDIOCGTUNER _IOWR('v',4,struct video_tuner) /* Get tuner abilities */
+#define VIDIOCSTUNER _IOW('v',5,struct video_tuner) /* Tune the tuner for the current channel */
+#define VIDIOCGPICT _IOR('v',6,struct video_picture) /* Get picture properties */
+#define VIDIOCSPICT _IOW('v',7,struct video_picture) /* Set picture properties */
+#define VIDIOCCAPTURE _IOW('v',8,int) /* Start, end capture */
+#define VIDIOCGWIN _IOR('v',9, struct video_window) /* Get the video overlay window */
+#define VIDIOCSWIN _IOW('v',10, struct video_window) /* Set the video overlay window - passes clip list for hardware smarts , chromakey etc */
+#define VIDIOCGFBUF _IOR('v',11, struct video_buffer) /* Get frame buffer */
+#define VIDIOCSFBUF _IOW('v',12, struct video_buffer) /* Set frame buffer - root only */
+#define VIDIOCKEY _IOR('v',13, struct video_key) /* Video key event - to dev 255 is to all - cuts capture on all DMA windows with this key (0xFFFFFFFF == all) */
+#define VIDIOCGFREQ _IOR('v',14, unsigned long) /* Set tuner */
+#define VIDIOCSFREQ _IOW('v',15, unsigned long) /* Set tuner */
+#define VIDIOCGAUDIO _IOR('v',16, struct video_audio) /* Get audio info */
+#define VIDIOCSAUDIO _IOW('v',17, struct video_audio) /* Audio source, mute etc */
+#define VIDIOCSYNC _IOW('v',18, int) /* Sync with mmap grabbing */
+#define VIDIOCMCAPTURE _IOW('v',19, struct video_mmap) /* Grab frames */
+#define VIDIOCGMBUF _IOR('v',20, struct video_mbuf) /* Memory map buffer info */
+#define VIDIOCGUNIT _IOR('v',21, struct video_unit) /* Get attached units */
+#define VIDIOCGCAPTURE _IOR('v',22, struct video_capture) /* Get subcapture */
+#define VIDIOCSCAPTURE _IOW('v',23, struct video_capture) /* Set subcapture */
+#define VIDIOCSPLAYMODE _IOW('v',24, struct video_play_mode) /* Set output video mode/feature */
+#define VIDIOCSWRITEMODE _IOW('v',25, int) /* Set write mode */
+#define VIDIOCGPLAYINFO _IOR('v',26, struct video_info) /* Get current playback info from hardware */
+#define VIDIOCSMICROCODE _IOW('v',27, struct video_code) /* Load microcode into hardware */
+#define VIDIOCGVBIFMT _IOR('v',28, struct vbi_format) /* Get VBI information */
+#define VIDIOCSVBIFMT _IOW('v',29, struct vbi_format) /* Set VBI information */
+
+
+#define BASE_VIDIOCPRIVATE 192 /* 192-255 are private */
+
+/* VIDIOCSWRITEMODE */
+#define VID_WRITE_MPEG_AUD 0
+#define VID_WRITE_MPEG_VID 1
+#define VID_WRITE_OSD 2
+#define VID_WRITE_TTX 3
+#define VID_WRITE_CC 4
+#define VID_WRITE_MJPEG 5
+
+/* VIDIOCSPLAYMODE */
+#define VID_PLAY_VID_OUT_MODE 0
+ /* p1: = VIDEO_MODE_PAL, VIDEO_MODE_NTSC, etc ... */
+#define VID_PLAY_GENLOCK 1
+ /* p1: 0 = OFF, 1 = ON */
+ /* p2: GENLOCK FINE DELAY value */
+#define VID_PLAY_NORMAL 2
+#define VID_PLAY_PAUSE 3
+#define VID_PLAY_SINGLE_FRAME 4
+#define VID_PLAY_FAST_FORWARD 5
+#define VID_PLAY_SLOW_MOTION 6
+#define VID_PLAY_IMMEDIATE_NORMAL 7
+#define VID_PLAY_SWITCH_CHANNELS 8
+#define VID_PLAY_FREEZE_FRAME 9
+#define VID_PLAY_STILL_MODE 10
+#define VID_PLAY_MASTER_MODE 11
+ /* p1: see below */
+#define VID_PLAY_MASTER_NONE 1
+#define VID_PLAY_MASTER_VIDEO 2
+#define VID_PLAY_MASTER_AUDIO 3
+#define VID_PLAY_ACTIVE_SCANLINES 12
+ /* p1 = first active; p2 = last active */
+#define VID_PLAY_RESET 13
+#define VID_PLAY_END_MARK 14
+
+
+
+#define VID_HARDWARE_BT848 1
+#define VID_HARDWARE_QCAM_BW 2
+#define VID_HARDWARE_PMS 3
+#define VID_HARDWARE_QCAM_C 4
+#define VID_HARDWARE_PSEUDO 5
+#define VID_HARDWARE_SAA5249 6
+#define VID_HARDWARE_AZTECH 7
+#define VID_HARDWARE_SF16MI 8
+#define VID_HARDWARE_RTRACK 9
+#define VID_HARDWARE_ZOLTRIX 10
+#define VID_HARDWARE_SAA7146 11
+#define VID_HARDWARE_VIDEUM 12 /* Reserved for Winnov videum */
+#define VID_HARDWARE_RTRACK2 13
+#define VID_HARDWARE_PERMEDIA2 14 /* Reserved for Permedia2 */
+#define VID_HARDWARE_RIVA128 15 /* Reserved for RIVA 128 */
+#define VID_HARDWARE_PLANB 16 /* PowerMac motherboard video-in */
+#define VID_HARDWARE_BROADWAY 17 /* Broadway project */
+#define VID_HARDWARE_GEMTEK 18
+#define VID_HARDWARE_TYPHOON 19
+#define VID_HARDWARE_VINO 20 /* SGI Indy Vino */
+#define VID_HARDWARE_CADET 21 /* Cadet radio */
+#define VID_HARDWARE_TRUST 22 /* Trust FM Radio */
+#define VID_HARDWARE_TERRATEC 23 /* TerraTec ActiveRadio */
+#define VID_HARDWARE_CPIA 24
+#define VID_HARDWARE_ZR36120 25 /* Zoran ZR36120/ZR36125 */
+#define VID_HARDWARE_ZR36067 26 /* Zoran ZR36067/36060 */
+#define VID_HARDWARE_OV511 27
+#define VID_HARDWARE_ZR356700 28 /* Zoran 36700 series */
+#define VID_HARDWARE_W9966 29
+#define VID_HARDWARE_SE401 30 /* SE401 USB webcams */
+#define VID_HARDWARE_PWC 31 /* Philips webcams */
+#define VID_HARDWARE_MEYE 32 /* Sony Vaio MotionEye cameras */
+#define VID_HARDWARE_CPIA2 33
+#define VID_HARDWARE_VICAM 34
+#define VID_HARDWARE_SF16FMR2 35
+#define VID_HARDWARE_W9968CF 36
+#define VID_HARDWARE_SAA7114H 37
+#define VID_HARDWARE_SN9C102 38
+#define VID_HARDWARE_ARV 39
+
+#endif /* CONFIG_VIDEO_V4L1_COMPAT */
+
+#endif /* __LINUX_VIDEODEV_H */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/video/V4L/videodev2.h b/src/video/V4L/videodev2.h
new file mode 100644
index 0000000000000000000000000000000000000000..02fbfc66453260dd251bee13799de1363c04d3fb
--- /dev/null
+++ b/src/video/V4L/videodev2.h
@@ -0,0 +1,1409 @@
+/*
+ * Video for Linux Two header file
+ *
+ * Copyright (C) 1999-2007 the contributors
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * Alternatively you can redistribute this file under the terms of the
+ * BSD license as stated below:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in
+ * the documentation and/or other materials provided with the
+ * distribution.
+ * 3. The names of its contributors may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+ * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Header file for v4l or V4L2 drivers and applications
+ * with public API.
+ * All kernel-specific stuff were moved to media/v4l2-dev.h, so
+ * no #if __KERNEL tests are allowed here
+ *
+ * See http://linuxtv.org for more info
+ *
+ * Author: Bill Dirks <bill@thedirks.org>
+ * Justin Schoeman
+ * Hans Verkuil <hverkuil@xs4all.nl>
+ * et al.
+ */
+#ifndef __LINUX_VIDEODEV2_H
+#define __LINUX_VIDEODEV2_H
+#define __user
+#include <linux/types.h>
+
+/*
+ * Common stuff for both V4L1 and V4L2
+ * Moved from videodev.h
+ */
+#define VIDEO_MAX_FRAME 32
+
+#define VID_TYPE_CAPTURE 1 /* Can capture */
+#define VID_TYPE_TUNER 2 /* Can tune */
+#define VID_TYPE_TELETEXT 4 /* Does teletext */
+#define VID_TYPE_OVERLAY 8 /* Overlay onto frame buffer */
+#define VID_TYPE_CHROMAKEY 16 /* Overlay by chromakey */
+#define VID_TYPE_CLIPPING 32 /* Can clip */
+#define VID_TYPE_FRAMERAM 64 /* Uses the frame buffer memory */
+#define VID_TYPE_SCALES 128 /* Scalable */
+#define VID_TYPE_MONOCHROME 256 /* Monochrome only */
+#define VID_TYPE_SUBCAPTURE 512 /* Can capture subareas of the image */
+#define VID_TYPE_MPEG_DECODER 1024 /* Can decode MPEG streams */
+#define VID_TYPE_MPEG_ENCODER 2048 /* Can encode MPEG streams */
+#define VID_TYPE_MJPEG_DECODER 4096 /* Can decode MJPEG streams */
+#define VID_TYPE_MJPEG_ENCODER 8192 /* Can encode MJPEG streams */
+
+/*
+ * M I S C E L L A N E O U S
+ */
+
+/* Four-character-code (FOURCC) */
+#define v4l2_fourcc(a,b,c,d)\
+ (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24))
+
+/*
+ * E N U M S
+ */
+enum v4l2_field {
+ V4L2_FIELD_ANY = 0, /* driver can choose from none,
+ top, bottom, interlaced
+ depending on whatever it thinks
+ is approximate ... */
+ V4L2_FIELD_NONE = 1, /* this device has no fields ... */
+ V4L2_FIELD_TOP = 2, /* top field only */
+ V4L2_FIELD_BOTTOM = 3, /* bottom field only */
+ V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */
+ V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one
+ buffer, top-bottom order */
+ V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */
+ V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into
+ separate buffers */
+ V4L2_FIELD_INTERLACED_TB = 8, /* both fields interlaced, top field
+ first and the top field is
+ transmitted first */
+ V4L2_FIELD_INTERLACED_BT = 9, /* both fields interlaced, top field
+ first and the bottom field is
+ transmitted first */
+};
+#define V4L2_FIELD_HAS_TOP(field) \
+ ((field) == V4L2_FIELD_TOP ||\
+ (field) == V4L2_FIELD_INTERLACED ||\
+ (field) == V4L2_FIELD_INTERLACED_TB ||\
+ (field) == V4L2_FIELD_INTERLACED_BT ||\
+ (field) == V4L2_FIELD_SEQ_TB ||\
+ (field) == V4L2_FIELD_SEQ_BT)
+#define V4L2_FIELD_HAS_BOTTOM(field) \
+ ((field) == V4L2_FIELD_BOTTOM ||\
+ (field) == V4L2_FIELD_INTERLACED ||\
+ (field) == V4L2_FIELD_INTERLACED_TB ||\
+ (field) == V4L2_FIELD_INTERLACED_BT ||\
+ (field) == V4L2_FIELD_SEQ_TB ||\
+ (field) == V4L2_FIELD_SEQ_BT)
+#define V4L2_FIELD_HAS_BOTH(field) \
+ ((field) == V4L2_FIELD_INTERLACED ||\
+ (field) == V4L2_FIELD_INTERLACED_TB ||\
+ (field) == V4L2_FIELD_INTERLACED_BT ||\
+ (field) == V4L2_FIELD_SEQ_TB ||\
+ (field) == V4L2_FIELD_SEQ_BT)
+
+enum v4l2_buf_type {
+ V4L2_BUF_TYPE_VIDEO_CAPTURE = 1,
+ V4L2_BUF_TYPE_VIDEO_OUTPUT = 2,
+ V4L2_BUF_TYPE_VIDEO_OVERLAY = 3,
+ V4L2_BUF_TYPE_VBI_CAPTURE = 4,
+ V4L2_BUF_TYPE_VBI_OUTPUT = 5,
+ V4L2_BUF_TYPE_SLICED_VBI_CAPTURE = 6,
+ V4L2_BUF_TYPE_SLICED_VBI_OUTPUT = 7,
+#if 1
+ /* Experimental */
+ V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
+#endif
+ V4L2_BUF_TYPE_PRIVATE = 0x80,
+};
+
+enum v4l2_ctrl_type {
+ V4L2_CTRL_TYPE_INTEGER = 1,
+ V4L2_CTRL_TYPE_BOOLEAN = 2,
+ V4L2_CTRL_TYPE_MENU = 3,
+ V4L2_CTRL_TYPE_BUTTON = 4,
+ V4L2_CTRL_TYPE_INTEGER64 = 5,
+ V4L2_CTRL_TYPE_CTRL_CLASS = 6,
+};
+
+enum v4l2_tuner_type {
+ V4L2_TUNER_RADIO = 1,
+ V4L2_TUNER_ANALOG_TV = 2,
+ V4L2_TUNER_DIGITAL_TV = 3,
+};
+
+enum v4l2_memory {
+ V4L2_MEMORY_MMAP = 1,
+ V4L2_MEMORY_USERPTR = 2,
+ V4L2_MEMORY_OVERLAY = 3,
+};
+
+/* see also http://vektor.theorem.ca/graphics/ycbcr/ */
+enum v4l2_colorspace {
+ /* ITU-R 601 -- broadcast NTSC/PAL */
+ V4L2_COLORSPACE_SMPTE170M = 1,
+
+ /* 1125-Line (US) HDTV */
+ V4L2_COLORSPACE_SMPTE240M = 2,
+
+ /* HD and modern captures. */
+ V4L2_COLORSPACE_REC709 = 3,
+
+ /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */
+ V4L2_COLORSPACE_BT878 = 4,
+
+ /* These should be useful. Assume 601 extents. */
+ V4L2_COLORSPACE_470_SYSTEM_M = 5,
+ V4L2_COLORSPACE_470_SYSTEM_BG = 6,
+
+ /* I know there will be cameras that send this. So, this is
+ * unspecified chromaticities and full 0-255 on each of the
+ * Y'CbCr components
+ */
+ V4L2_COLORSPACE_JPEG = 7,
+
+ /* For RGB colourspaces, this is probably a good start. */
+ V4L2_COLORSPACE_SRGB = 8,
+};
+
+enum v4l2_priority {
+ V4L2_PRIORITY_UNSET = 0, /* not initialized */
+ V4L2_PRIORITY_BACKGROUND = 1,
+ V4L2_PRIORITY_INTERACTIVE = 2,
+ V4L2_PRIORITY_RECORD = 3,
+ V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE,
+};
+
+struct v4l2_rect {
+ __s32 left;
+ __s32 top;
+ __s32 width;
+ __s32 height;
+};
+
+struct v4l2_fract {
+ __u32 numerator;
+ __u32 denominator;
+};
+
+/*
+ * D R I V E R C A P A B I L I T I E S
+ */
+struct v4l2_capability
+{
+ __u8 driver[16]; /* i.e. "bttv" */
+ __u8 card[32]; /* i.e. "Hauppauge WinTV" */
+ __u8 bus_info[32]; /* "PCI:" + pci_name(pci_dev) */
+ __u32 version; /* should use KERNEL_VERSION() */
+ __u32 capabilities; /* Device capabilities */
+ __u32 reserved[4];
+};
+
+/* Values for 'capabilities' field */
+#define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */
+#define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */
+#define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */
+#define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a raw VBI capture device */
+#define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a raw VBI output device */
+#define V4L2_CAP_SLICED_VBI_CAPTURE 0x00000040 /* Is a sliced VBI capture device */
+#define V4L2_CAP_SLICED_VBI_OUTPUT 0x00000080 /* Is a sliced VBI output device */
+#define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */
+#define V4L2_CAP_VIDEO_OUTPUT_OVERLAY 0x00000200 /* Can do video output overlay */
+
+#define V4L2_CAP_TUNER 0x00010000 /* has a tuner */
+#define V4L2_CAP_AUDIO 0x00020000 /* has audio support */
+#define V4L2_CAP_RADIO 0x00040000 /* is a radio device */
+
+#define V4L2_CAP_READWRITE 0x01000000 /* read/write systemcalls */
+#define V4L2_CAP_ASYNCIO 0x02000000 /* async I/O */
+#define V4L2_CAP_STREAMING 0x04000000 /* streaming I/O ioctls */
+
+/*
+ * V I D E O I M A G E F O R M A T
+ */
+struct v4l2_pix_format
+{
+ __u32 width;
+ __u32 height;
+ __u32 pixelformat;
+ enum v4l2_field field;
+ __u32 bytesperline; /* for padding, zero if unused */
+ __u32 sizeimage;
+ enum v4l2_colorspace colorspace;
+ __u32 priv; /* private data, depends on pixelformat */
+};
+
+/* Pixel format FOURCC depth Description */
+#define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R','G','B','1') /* 8 RGB-3-3-2 */
+#define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R','G','B','O') /* 16 RGB-5-5-5 */
+#define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R','G','B','P') /* 16 RGB-5-6-5 */
+#define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16 RGB-5-5-5 BE */
+#define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16 RGB-5-6-5 BE */
+#define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B','G','R','3') /* 24 BGR-8-8-8 */
+#define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R','G','B','3') /* 24 RGB-8-8-8 */
+#define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B','G','R','4') /* 32 BGR-8-8-8-8 */
+#define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R','G','B','4') /* 32 RGB-8-8-8-8 */
+#define V4L2_PIX_FMT_GREY v4l2_fourcc('G','R','E','Y') /* 8 Greyscale */
+#define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y','V','U','9') /* 9 YVU 4:1:0 */
+#define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y','V','1','2') /* 12 YVU 4:2:0 */
+#define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y','U','Y','V') /* 16 YUV 4:2:2 */
+#define V4L2_PIX_FMT_UYVY v4l2_fourcc('U','Y','V','Y') /* 16 YUV 4:2:2 */
+#define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16 YVU422 planar */
+#define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16 YVU411 planar */
+#define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y','4','1','P') /* 12 YUV 4:1:1 */
+
+/* two planes -- one Y, one Cr + Cb interleaved */
+#define V4L2_PIX_FMT_NV12 v4l2_fourcc('N','V','1','2') /* 12 Y/CbCr 4:2:0 */
+#define V4L2_PIX_FMT_NV21 v4l2_fourcc('N','V','2','1') /* 12 Y/CrCb 4:2:0 */
+
+/* The following formats are not defined in the V4L2 specification */
+#define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y','U','V','9') /* 9 YUV 4:1:0 */
+#define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y','U','1','2') /* 12 YUV 4:2:0 */
+#define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y','Y','U','V') /* 16 YUV 4:2:2 */
+#define V4L2_PIX_FMT_HI240 v4l2_fourcc('H','I','2','4') /* 8 8-bit color */
+#define V4L2_PIX_FMT_HM12 v4l2_fourcc('H','M','1','2') /* 8 YUV 4:2:0 16x16 macroblocks */
+#define V4L2_PIX_FMT_RGB444 v4l2_fourcc('R','4','4','4') /* 16 xxxxrrrr ggggbbbb */
+
+/* see http://www.siliconimaging.com/RGB%20Bayer.htm */
+#define V4L2_PIX_FMT_SBGGR8 v4l2_fourcc('B','A','8','1') /* 8 BGBG.. GRGR.. */
+
+/* compressed formats */
+#define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M','J','P','G') /* Motion-JPEG */
+#define V4L2_PIX_FMT_JPEG v4l2_fourcc('J','P','E','G') /* JFIF JPEG */
+#define V4L2_PIX_FMT_DV v4l2_fourcc('d','v','s','d') /* 1394 */
+#define V4L2_PIX_FMT_MPEG v4l2_fourcc('M','P','E','G') /* MPEG-1/2/4 */
+
+/* Vendor-specific formats */
+#define V4L2_PIX_FMT_WNVA v4l2_fourcc('W','N','V','A') /* Winnov hw compress */
+#define V4L2_PIX_FMT_SN9C10X v4l2_fourcc('S','9','1','0') /* SN9C10x compression */
+#define V4L2_PIX_FMT_PWC1 v4l2_fourcc('P','W','C','1') /* pwc older webcam */
+#define V4L2_PIX_FMT_PWC2 v4l2_fourcc('P','W','C','2') /* pwc newer webcam */
+#define V4L2_PIX_FMT_ET61X251 v4l2_fourcc('E','6','2','5') /* ET61X251 compression */
+
+/*
+ * F O R M A T E N U M E R A T I O N
+ */
+struct v4l2_fmtdesc
+{
+ __u32 index; /* Format number */
+ enum v4l2_buf_type type; /* buffer type */
+ __u32 flags;
+ __u8 description[32]; /* Description string */
+ __u32 pixelformat; /* Format fourcc */
+ __u32 reserved[4];
+};
+
+#define V4L2_FMT_FLAG_COMPRESSED 0x0001
+
+#if 1
+ /* Experimental Frame Size and frame rate enumeration */
+/*
+ * F R A M E S I Z E E N U M E R A T I O N
+ */
+enum v4l2_frmsizetypes
+{
+ V4L2_FRMSIZE_TYPE_DISCRETE = 1,
+ V4L2_FRMSIZE_TYPE_CONTINUOUS = 2,
+ V4L2_FRMSIZE_TYPE_STEPWISE = 3,
+};
+
+struct v4l2_frmsize_discrete
+{
+ __u32 width; /* Frame width [pixel] */
+ __u32 height; /* Frame height [pixel] */
+};
+
+struct v4l2_frmsize_stepwise
+{
+ __u32 min_width; /* Minimum frame width [pixel] */
+ __u32 max_width; /* Maximum frame width [pixel] */
+ __u32 step_width; /* Frame width step size [pixel] */
+ __u32 min_height; /* Minimum frame height [pixel] */
+ __u32 max_height; /* Maximum frame height [pixel] */
+ __u32 step_height; /* Frame height step size [pixel] */
+};
+
+struct v4l2_frmsizeenum
+{
+ __u32 index; /* Frame size number */
+ __u32 pixel_format; /* Pixel format */
+ __u32 type; /* Frame size type the device supports. */
+
+ union { /* Frame size */
+ struct v4l2_frmsize_discrete discrete;
+ struct v4l2_frmsize_stepwise stepwise;
+ };
+
+ __u32 reserved[2]; /* Reserved space for future use */
+};
+
+/*
+ * F R A M E R A T E E N U M E R A T I O N
+ */
+enum v4l2_frmivaltypes
+{
+ V4L2_FRMIVAL_TYPE_DISCRETE = 1,
+ V4L2_FRMIVAL_TYPE_CONTINUOUS = 2,
+ V4L2_FRMIVAL_TYPE_STEPWISE = 3,
+};
+
+struct v4l2_frmival_stepwise
+{
+ struct v4l2_fract min; /* Minimum frame interval [s] */
+ struct v4l2_fract max; /* Maximum frame interval [s] */
+ struct v4l2_fract step; /* Frame interval step size [s] */
+};
+
+struct v4l2_frmivalenum
+{
+ __u32 index; /* Frame format index */
+ __u32 pixel_format; /* Pixel format */
+ __u32 width; /* Frame width */
+ __u32 height; /* Frame height */
+ __u32 type; /* Frame interval type the device supports. */
+
+ union { /* Frame interval */
+ struct v4l2_fract discrete;
+ struct v4l2_frmival_stepwise stepwise;
+ };
+
+ __u32 reserved[2]; /* Reserved space for future use */
+};
+#endif
+
+/*
+ * T I M E C O D E
+ */
+struct v4l2_timecode
+{
+ __u32 type;
+ __u32 flags;
+ __u8 frames;
+ __u8 seconds;
+ __u8 minutes;
+ __u8 hours;
+ __u8 userbits[4];
+};
+
+/* Type */
+#define V4L2_TC_TYPE_24FPS 1
+#define V4L2_TC_TYPE_25FPS 2
+#define V4L2_TC_TYPE_30FPS 3
+#define V4L2_TC_TYPE_50FPS 4
+#define V4L2_TC_TYPE_60FPS 5
+
+/* Flags */
+#define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */
+#define V4L2_TC_FLAG_COLORFRAME 0x0002
+#define V4L2_TC_USERBITS_field 0x000C
+#define V4L2_TC_USERBITS_USERDEFINED 0x0000
+#define V4L2_TC_USERBITS_8BITCHARS 0x0008
+/* The above is based on SMPTE timecodes */
+
+
+struct v4l2_jpegcompression
+{
+ int quality;
+
+ int APPn; /* Number of APP segment to be written,
+ * must be 0..15 */
+ int APP_len; /* Length of data in JPEG APPn segment */
+ char APP_data[60]; /* Data in the JPEG APPn segment. */
+
+ int COM_len; /* Length of data in JPEG COM segment */
+ char COM_data[60]; /* Data in JPEG COM segment */
+
+ __u32 jpeg_markers; /* Which markers should go into the JPEG
+ * output. Unless you exactly know what
+ * you do, leave them untouched.
+ * Inluding less markers will make the
+ * resulting code smaller, but there will
+ * be fewer aplications which can read it.
+ * The presence of the APP and COM marker
+ * is influenced by APP_len and COM_len
+ * ONLY, not by this property! */
+
+#define V4L2_JPEG_MARKER_DHT (1<<3) /* Define Huffman Tables */
+#define V4L2_JPEG_MARKER_DQT (1<<4) /* Define Quantization Tables */
+#define V4L2_JPEG_MARKER_DRI (1<<5) /* Define Restart Interval */
+#define V4L2_JPEG_MARKER_COM (1<<6) /* Comment segment */
+#define V4L2_JPEG_MARKER_APP (1<<7) /* App segment, driver will
+ * allways use APP0 */
+};
+
+/*
+ * M E M O R Y - M A P P I N G B U F F E R S
+ */
+struct v4l2_requestbuffers
+{
+ __u32 count;
+ enum v4l2_buf_type type;
+ enum v4l2_memory memory;
+ __u32 reserved[2];
+};
+
+struct v4l2_buffer
+{
+ __u32 index;
+ enum v4l2_buf_type type;
+ __u32 bytesused;
+ __u32 flags;
+ enum v4l2_field field;
+ struct timeval timestamp;
+ struct v4l2_timecode timecode;
+ __u32 sequence;
+
+ /* memory location */
+ enum v4l2_memory memory;
+ union {
+ __u32 offset;
+ unsigned long userptr;
+ } m;
+ __u32 length;
+ __u32 input;
+ __u32 reserved;
+};
+
+/* Flags for 'flags' field */
+#define V4L2_BUF_FLAG_MAPPED 0x0001 /* Buffer is mapped (flag) */
+#define V4L2_BUF_FLAG_QUEUED 0x0002 /* Buffer is queued for processing */
+#define V4L2_BUF_FLAG_DONE 0x0004 /* Buffer is ready */
+#define V4L2_BUF_FLAG_KEYFRAME 0x0008 /* Image is a keyframe (I-frame) */
+#define V4L2_BUF_FLAG_PFRAME 0x0010 /* Image is a P-frame */
+#define V4L2_BUF_FLAG_BFRAME 0x0020 /* Image is a B-frame */
+#define V4L2_BUF_FLAG_TIMECODE 0x0100 /* timecode field is valid */
+#define V4L2_BUF_FLAG_INPUT 0x0200 /* input field is valid */
+
+/*
+ * O V E R L A Y P R E V I E W
+ */
+struct v4l2_framebuffer
+{
+ __u32 capability;
+ __u32 flags;
+/* FIXME: in theory we should pass something like PCI device + memory
+ * region + offset instead of some physical address */
+ void* base;
+ struct v4l2_pix_format fmt;
+};
+/* Flags for the 'capability' field. Read only */
+#define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001
+#define V4L2_FBUF_CAP_CHROMAKEY 0x0002
+#define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004
+#define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008
+#define V4L2_FBUF_CAP_LOCAL_ALPHA 0x0010
+#define V4L2_FBUF_CAP_GLOBAL_ALPHA 0x0020
+#define V4L2_FBUF_CAP_LOCAL_INV_ALPHA 0x0040
+#define V4L2_FBUF_CAP_GLOBAL_INV_ALPHA 0x0080
+/* Flags for the 'flags' field. */
+#define V4L2_FBUF_FLAG_PRIMARY 0x0001
+#define V4L2_FBUF_FLAG_OVERLAY 0x0002
+#define V4L2_FBUF_FLAG_CHROMAKEY 0x0004
+#define V4L2_FBUF_FLAG_LOCAL_ALPHA 0x0008
+#define V4L2_FBUF_FLAG_GLOBAL_ALPHA 0x0010
+#define V4L2_FBUF_FLAG_LOCAL_INV_ALPHA 0x0020
+#define V4L2_FBUF_FLAG_GLOBAL_INV_ALPHA 0x0040
+
+struct v4l2_clip
+{
+ struct v4l2_rect c;
+ struct v4l2_clip *next;
+};
+
+struct v4l2_window
+{
+ struct v4l2_rect w;
+ enum v4l2_field field;
+ __u32 chromakey;
+ struct v4l2_clip *clips;
+ __u32 clipcount;
+ void *bitmap;
+ __u8 global_alpha;
+};
+
+/*
+ * C A P T U R E P A R A M E T E R S
+ */
+struct v4l2_captureparm
+{
+ __u32 capability; /* Supported modes */
+ __u32 capturemode; /* Current mode */
+ struct v4l2_fract timeperframe; /* Time per frame in .1us units */
+ __u32 extendedmode; /* Driver-specific extensions */
+ __u32 readbuffers; /* # of buffers for read */
+ __u32 reserved[4];
+};
+
+/* Flags for 'capability' and 'capturemode' fields */
+#define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode */
+#define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported */
+
+struct v4l2_outputparm
+{
+ __u32 capability; /* Supported modes */
+ __u32 outputmode; /* Current mode */
+ struct v4l2_fract timeperframe; /* Time per frame in seconds */
+ __u32 extendedmode; /* Driver-specific extensions */
+ __u32 writebuffers; /* # of buffers for write */
+ __u32 reserved[4];
+};
+
+/*
+ * I N P U T I M A G E C R O P P I N G
+ */
+struct v4l2_cropcap {
+ enum v4l2_buf_type type;
+ struct v4l2_rect bounds;
+ struct v4l2_rect defrect;
+ struct v4l2_fract pixelaspect;
+};
+
+struct v4l2_crop {
+ enum v4l2_buf_type type;
+ struct v4l2_rect c;
+};
+
+/*
+ * A N A L O G V I D E O S T A N D A R D
+ */
+
+typedef __u64 v4l2_std_id;
+
+/* one bit for each */
+#define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001)
+#define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002)
+#define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004)
+#define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008)
+#define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010)
+#define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020)
+#define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040)
+#define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080)
+
+#define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100)
+#define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200)
+#define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400)
+#define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800)
+
+#define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000)
+#define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000)
+#define V4L2_STD_NTSC_443 ((v4l2_std_id)0x00004000)
+#define V4L2_STD_NTSC_M_KR ((v4l2_std_id)0x00008000)
+
+#define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000)
+#define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000)
+#define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000)
+#define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000)
+#define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000)
+#define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000)
+#define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000)
+#define V4L2_STD_SECAM_LC ((v4l2_std_id)0x00800000)
+
+/* ATSC/HDTV */
+#define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000)
+#define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000)
+
+/* FIXME:
+ Although std_id is 64 bits, there is an issue on PPC32 architecture that
+ makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
+ this value to 32 bits.
+ As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
+ it should work fine. However, if needed to add more than two standards,
+ v4l2-common.c should be fixed.
+ */
+
+/* some merged standards */
+#define V4L2_STD_MN (V4L2_STD_PAL_M|V4L2_STD_PAL_N|V4L2_STD_PAL_Nc|V4L2_STD_NTSC)
+#define V4L2_STD_B (V4L2_STD_PAL_B|V4L2_STD_PAL_B1|V4L2_STD_SECAM_B)
+#define V4L2_STD_GH (V4L2_STD_PAL_G|V4L2_STD_PAL_H|V4L2_STD_SECAM_G|V4L2_STD_SECAM_H)
+#define V4L2_STD_DK (V4L2_STD_PAL_DK|V4L2_STD_SECAM_DK)
+
+/* some common needed stuff */
+#define V4L2_STD_PAL_BG (V4L2_STD_PAL_B |\
+ V4L2_STD_PAL_B1 |\
+ V4L2_STD_PAL_G)
+#define V4L2_STD_PAL_DK (V4L2_STD_PAL_D |\
+ V4L2_STD_PAL_D1 |\
+ V4L2_STD_PAL_K)
+#define V4L2_STD_PAL (V4L2_STD_PAL_BG |\
+ V4L2_STD_PAL_DK |\
+ V4L2_STD_PAL_H |\
+ V4L2_STD_PAL_I)
+#define V4L2_STD_NTSC (V4L2_STD_NTSC_M |\
+ V4L2_STD_NTSC_M_JP |\
+ V4L2_STD_NTSC_M_KR)
+#define V4L2_STD_SECAM_DK (V4L2_STD_SECAM_D |\
+ V4L2_STD_SECAM_K |\
+ V4L2_STD_SECAM_K1)
+#define V4L2_STD_SECAM (V4L2_STD_SECAM_B |\
+ V4L2_STD_SECAM_G |\
+ V4L2_STD_SECAM_H |\
+ V4L2_STD_SECAM_DK |\
+ V4L2_STD_SECAM_L |\
+ V4L2_STD_SECAM_LC)
+
+#define V4L2_STD_525_60 (V4L2_STD_PAL_M |\
+ V4L2_STD_PAL_60 |\
+ V4L2_STD_NTSC |\
+ V4L2_STD_NTSC_443)
+#define V4L2_STD_625_50 (V4L2_STD_PAL |\
+ V4L2_STD_PAL_N |\
+ V4L2_STD_PAL_Nc |\
+ V4L2_STD_SECAM)
+#define V4L2_STD_ATSC (V4L2_STD_ATSC_8_VSB |\
+ V4L2_STD_ATSC_16_VSB)
+
+#define V4L2_STD_UNKNOWN 0
+#define V4L2_STD_ALL (V4L2_STD_525_60 |\
+ V4L2_STD_625_50)
+
+struct v4l2_standard
+{
+ __u32 index;
+ v4l2_std_id id;
+ __u8 name[24];
+ struct v4l2_fract frameperiod; /* Frames, not fields */
+ __u32 framelines;
+ __u32 reserved[4];
+};
+
+/*
+ * V I D E O I N P U T S
+ */
+struct v4l2_input
+{
+ __u32 index; /* Which input */
+ __u8 name[32]; /* Label */
+ __u32 type; /* Type of input */
+ __u32 audioset; /* Associated audios (bitfield) */
+ __u32 tuner; /* Associated tuner */
+ v4l2_std_id std;
+ __u32 status;
+ __u32 reserved[4];
+};
+
+/* Values for the 'type' field */
+#define V4L2_INPUT_TYPE_TUNER 1
+#define V4L2_INPUT_TYPE_CAMERA 2
+
+/* field 'status' - general */
+#define V4L2_IN_ST_NO_POWER 0x00000001 /* Attached device is off */
+#define V4L2_IN_ST_NO_SIGNAL 0x00000002
+#define V4L2_IN_ST_NO_COLOR 0x00000004
+
+/* field 'status' - analog */
+#define V4L2_IN_ST_NO_H_LOCK 0x00000100 /* No horizontal sync lock */
+#define V4L2_IN_ST_COLOR_KILL 0x00000200 /* Color killer is active */
+
+/* field 'status' - digital */
+#define V4L2_IN_ST_NO_SYNC 0x00010000 /* No synchronization lock */
+#define V4L2_IN_ST_NO_EQU 0x00020000 /* No equalizer lock */
+#define V4L2_IN_ST_NO_CARRIER 0x00040000 /* Carrier recovery failed */
+
+/* field 'status' - VCR and set-top box */
+#define V4L2_IN_ST_MACROVISION 0x01000000 /* Macrovision detected */
+#define V4L2_IN_ST_NO_ACCESS 0x02000000 /* Conditional access denied */
+#define V4L2_IN_ST_VTR 0x04000000 /* VTR time constant */
+
+/*
+ * V I D E O O U T P U T S
+ */
+struct v4l2_output
+{
+ __u32 index; /* Which output */
+ __u8 name[32]; /* Label */
+ __u32 type; /* Type of output */
+ __u32 audioset; /* Associated audios (bitfield) */
+ __u32 modulator; /* Associated modulator */
+ v4l2_std_id std;
+ __u32 reserved[4];
+};
+/* Values for the 'type' field */
+#define V4L2_OUTPUT_TYPE_MODULATOR 1
+#define V4L2_OUTPUT_TYPE_ANALOG 2
+#define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3
+
+/*
+ * C O N T R O L S
+ */
+struct v4l2_control
+{
+ __u32 id;
+ __s32 value;
+};
+
+struct v4l2_ext_control
+{
+ __u32 id;
+ __u32 reserved2[2];
+ union {
+ __s32 value;
+ __s64 value64;
+ void *reserved;
+ };
+} __attribute__ ((packed));
+
+struct v4l2_ext_controls
+{
+ __u32 ctrl_class;
+ __u32 count;
+ __u32 error_idx;
+ __u32 reserved[2];
+ struct v4l2_ext_control *controls;
+};
+
+/* Values for ctrl_class field */
+#define V4L2_CTRL_CLASS_USER 0x00980000 /* Old-style 'user' controls */
+#define V4L2_CTRL_CLASS_MPEG 0x00990000 /* MPEG-compression controls */
+
+#define V4L2_CTRL_ID_MASK (0x0fffffff)
+#define V4L2_CTRL_ID2CLASS(id) ((id) & 0x0fff0000UL)
+#define V4L2_CTRL_DRIVER_PRIV(id) (((id) & 0xffff) >= 0x1000)
+
+/* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
+struct v4l2_queryctrl
+{
+ __u32 id;
+ enum v4l2_ctrl_type type;
+ __u8 name[32]; /* Whatever */
+ __s32 minimum; /* Note signedness */
+ __s32 maximum;
+ __s32 step;
+ __s32 default_value;
+ __u32 flags;
+ __u32 reserved[2];
+};
+
+/* Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
+struct v4l2_querymenu
+{
+ __u32 id;
+ __u32 index;
+ __u8 name[32]; /* Whatever */
+ __u32 reserved;
+};
+
+/* Control flags */
+#define V4L2_CTRL_FLAG_DISABLED 0x0001
+#define V4L2_CTRL_FLAG_GRABBED 0x0002
+#define V4L2_CTRL_FLAG_READ_ONLY 0x0004
+#define V4L2_CTRL_FLAG_UPDATE 0x0008
+#define V4L2_CTRL_FLAG_INACTIVE 0x0010
+#define V4L2_CTRL_FLAG_SLIDER 0x0020
+
+/* Query flag, to be ORed with the control ID */
+#define V4L2_CTRL_FLAG_NEXT_CTRL 0x80000000
+
+/* User-class control IDs defined by V4L2 */
+#define V4L2_CID_BASE (V4L2_CTRL_CLASS_USER | 0x900)
+#define V4L2_CID_USER_BASE V4L2_CID_BASE
+/* IDs reserved for driver specific controls */
+#define V4L2_CID_PRIVATE_BASE 0x08000000
+
+#define V4L2_CID_USER_CLASS (V4L2_CTRL_CLASS_USER | 1)
+#define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE+0)
+#define V4L2_CID_CONTRAST (V4L2_CID_BASE+1)
+#define V4L2_CID_SATURATION (V4L2_CID_BASE+2)
+#define V4L2_CID_HUE (V4L2_CID_BASE+3)
+#define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5)
+#define V4L2_CID_AUDIO_BALANCE (V4L2_CID_BASE+6)
+#define V4L2_CID_AUDIO_BASS (V4L2_CID_BASE+7)
+#define V4L2_CID_AUDIO_TREBLE (V4L2_CID_BASE+8)
+#define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9)
+#define V4L2_CID_AUDIO_LOUDNESS (V4L2_CID_BASE+10)
+#define V4L2_CID_BLACK_LEVEL (V4L2_CID_BASE+11)
+#define V4L2_CID_AUTO_WHITE_BALANCE (V4L2_CID_BASE+12)
+#define V4L2_CID_DO_WHITE_BALANCE (V4L2_CID_BASE+13)
+#define V4L2_CID_RED_BALANCE (V4L2_CID_BASE+14)
+#define V4L2_CID_BLUE_BALANCE (V4L2_CID_BASE+15)
+#define V4L2_CID_GAMMA (V4L2_CID_BASE+16)
+#define V4L2_CID_WHITENESS (V4L2_CID_GAMMA) /* ? Not sure */
+#define V4L2_CID_EXPOSURE (V4L2_CID_BASE+17)
+#define V4L2_CID_AUTOGAIN (V4L2_CID_BASE+18)
+#define V4L2_CID_GAIN (V4L2_CID_BASE+19)
+#define V4L2_CID_HFLIP (V4L2_CID_BASE+20)
+#define V4L2_CID_VFLIP (V4L2_CID_BASE+21)
+#define V4L2_CID_HCENTER (V4L2_CID_BASE+22)
+#define V4L2_CID_VCENTER (V4L2_CID_BASE+23)
+#define V4L2_CID_LASTP1 (V4L2_CID_BASE+24) /* last CID + 1 */
+
+/* MPEG-class control IDs defined by V4L2 */
+#define V4L2_CID_MPEG_BASE (V4L2_CTRL_CLASS_MPEG | 0x900)
+#define V4L2_CID_MPEG_CLASS (V4L2_CTRL_CLASS_MPEG | 1)
+
+/* MPEG streams */
+#define V4L2_CID_MPEG_STREAM_TYPE (V4L2_CID_MPEG_BASE+0)
+enum v4l2_mpeg_stream_type {
+ V4L2_MPEG_STREAM_TYPE_MPEG2_PS = 0, /* MPEG-2 program stream */
+ V4L2_MPEG_STREAM_TYPE_MPEG2_TS = 1, /* MPEG-2 transport stream */
+ V4L2_MPEG_STREAM_TYPE_MPEG1_SS = 2, /* MPEG-1 system stream */
+ V4L2_MPEG_STREAM_TYPE_MPEG2_DVD = 3, /* MPEG-2 DVD-compatible stream */
+ V4L2_MPEG_STREAM_TYPE_MPEG1_VCD = 4, /* MPEG-1 VCD-compatible stream */
+ V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD = 5, /* MPEG-2 SVCD-compatible stream */
+};
+#define V4L2_CID_MPEG_STREAM_PID_PMT (V4L2_CID_MPEG_BASE+1)
+#define V4L2_CID_MPEG_STREAM_PID_AUDIO (V4L2_CID_MPEG_BASE+2)
+#define V4L2_CID_MPEG_STREAM_PID_VIDEO (V4L2_CID_MPEG_BASE+3)
+#define V4L2_CID_MPEG_STREAM_PID_PCR (V4L2_CID_MPEG_BASE+4)
+#define V4L2_CID_MPEG_STREAM_PES_ID_AUDIO (V4L2_CID_MPEG_BASE+5)
+#define V4L2_CID_MPEG_STREAM_PES_ID_VIDEO (V4L2_CID_MPEG_BASE+6)
+#define V4L2_CID_MPEG_STREAM_VBI_FMT (V4L2_CID_MPEG_BASE+7)
+enum v4l2_mpeg_stream_vbi_fmt {
+ V4L2_MPEG_STREAM_VBI_FMT_NONE = 0, /* No VBI in the MPEG stream */
+ V4L2_MPEG_STREAM_VBI_FMT_IVTV = 1, /* VBI in private packets, IVTV format */
+};
+
+/* MPEG audio */
+#define V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ (V4L2_CID_MPEG_BASE+100)
+enum v4l2_mpeg_audio_sampling_freq {
+ V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100 = 0,
+ V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000 = 1,
+ V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000 = 2,
+};
+#define V4L2_CID_MPEG_AUDIO_ENCODING (V4L2_CID_MPEG_BASE+101)
+enum v4l2_mpeg_audio_encoding {
+ V4L2_MPEG_AUDIO_ENCODING_LAYER_1 = 0,
+ V4L2_MPEG_AUDIO_ENCODING_LAYER_2 = 1,
+ V4L2_MPEG_AUDIO_ENCODING_LAYER_3 = 2,
+};
+#define V4L2_CID_MPEG_AUDIO_L1_BITRATE (V4L2_CID_MPEG_BASE+102)
+enum v4l2_mpeg_audio_l1_bitrate {
+ V4L2_MPEG_AUDIO_L1_BITRATE_32K = 0,
+ V4L2_MPEG_AUDIO_L1_BITRATE_64K = 1,
+ V4L2_MPEG_AUDIO_L1_BITRATE_96K = 2,
+ V4L2_MPEG_AUDIO_L1_BITRATE_128K = 3,
+ V4L2_MPEG_AUDIO_L1_BITRATE_160K = 4,
+ V4L2_MPEG_AUDIO_L1_BITRATE_192K = 5,
+ V4L2_MPEG_AUDIO_L1_BITRATE_224K = 6,
+ V4L2_MPEG_AUDIO_L1_BITRATE_256K = 7,
+ V4L2_MPEG_AUDIO_L1_BITRATE_288K = 8,
+ V4L2_MPEG_AUDIO_L1_BITRATE_320K = 9,
+ V4L2_MPEG_AUDIO_L1_BITRATE_352K = 10,
+ V4L2_MPEG_AUDIO_L1_BITRATE_384K = 11,
+ V4L2_MPEG_AUDIO_L1_BITRATE_416K = 12,
+ V4L2_MPEG_AUDIO_L1_BITRATE_448K = 13,
+};
+#define V4L2_CID_MPEG_AUDIO_L2_BITRATE (V4L2_CID_MPEG_BASE+103)
+enum v4l2_mpeg_audio_l2_bitrate {
+ V4L2_MPEG_AUDIO_L2_BITRATE_32K = 0,
+ V4L2_MPEG_AUDIO_L2_BITRATE_48K = 1,
+ V4L2_MPEG_AUDIO_L2_BITRATE_56K = 2,
+ V4L2_MPEG_AUDIO_L2_BITRATE_64K = 3,
+ V4L2_MPEG_AUDIO_L2_BITRATE_80K = 4,
+ V4L2_MPEG_AUDIO_L2_BITRATE_96K = 5,
+ V4L2_MPEG_AUDIO_L2_BITRATE_112K = 6,
+ V4L2_MPEG_AUDIO_L2_BITRATE_128K = 7,
+ V4L2_MPEG_AUDIO_L2_BITRATE_160K = 8,
+ V4L2_MPEG_AUDIO_L2_BITRATE_192K = 9,
+ V4L2_MPEG_AUDIO_L2_BITRATE_224K = 10,
+ V4L2_MPEG_AUDIO_L2_BITRATE_256K = 11,
+ V4L2_MPEG_AUDIO_L2_BITRATE_320K = 12,
+ V4L2_MPEG_AUDIO_L2_BITRATE_384K = 13,
+};
+#define V4L2_CID_MPEG_AUDIO_L3_BITRATE (V4L2_CID_MPEG_BASE+104)
+enum v4l2_mpeg_audio_l3_bitrate {
+ V4L2_MPEG_AUDIO_L3_BITRATE_32K = 0,
+ V4L2_MPEG_AUDIO_L3_BITRATE_40K = 1,
+ V4L2_MPEG_AUDIO_L3_BITRATE_48K = 2,
+ V4L2_MPEG_AUDIO_L3_BITRATE_56K = 3,
+ V4L2_MPEG_AUDIO_L3_BITRATE_64K = 4,
+ V4L2_MPEG_AUDIO_L3_BITRATE_80K = 5,
+ V4L2_MPEG_AUDIO_L3_BITRATE_96K = 6,
+ V4L2_MPEG_AUDIO_L3_BITRATE_112K = 7,
+ V4L2_MPEG_AUDIO_L3_BITRATE_128K = 8,
+ V4L2_MPEG_AUDIO_L3_BITRATE_160K = 9,
+ V4L2_MPEG_AUDIO_L3_BITRATE_192K = 10,
+ V4L2_MPEG_AUDIO_L3_BITRATE_224K = 11,
+ V4L2_MPEG_AUDIO_L3_BITRATE_256K = 12,
+ V4L2_MPEG_AUDIO_L3_BITRATE_320K = 13,
+};
+#define V4L2_CID_MPEG_AUDIO_MODE (V4L2_CID_MPEG_BASE+105)
+enum v4l2_mpeg_audio_mode {
+ V4L2_MPEG_AUDIO_MODE_STEREO = 0,
+ V4L2_MPEG_AUDIO_MODE_JOINT_STEREO = 1,
+ V4L2_MPEG_AUDIO_MODE_DUAL = 2,
+ V4L2_MPEG_AUDIO_MODE_MONO = 3,
+};
+#define V4L2_CID_MPEG_AUDIO_MODE_EXTENSION (V4L2_CID_MPEG_BASE+106)
+enum v4l2_mpeg_audio_mode_extension {
+ V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4 = 0,
+ V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_8 = 1,
+ V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_12 = 2,
+ V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16 = 3,
+};
+#define V4L2_CID_MPEG_AUDIO_EMPHASIS (V4L2_CID_MPEG_BASE+107)
+enum v4l2_mpeg_audio_emphasis {
+ V4L2_MPEG_AUDIO_EMPHASIS_NONE = 0,
+ V4L2_MPEG_AUDIO_EMPHASIS_50_DIV_15_uS = 1,
+ V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17 = 2,
+};
+#define V4L2_CID_MPEG_AUDIO_CRC (V4L2_CID_MPEG_BASE+108)
+enum v4l2_mpeg_audio_crc {
+ V4L2_MPEG_AUDIO_CRC_NONE = 0,
+ V4L2_MPEG_AUDIO_CRC_CRC16 = 1,
+};
+#define V4L2_CID_MPEG_AUDIO_MUTE (V4L2_CID_MPEG_BASE+109)
+
+/* MPEG video */
+#define V4L2_CID_MPEG_VIDEO_ENCODING (V4L2_CID_MPEG_BASE+200)
+enum v4l2_mpeg_video_encoding {
+ V4L2_MPEG_VIDEO_ENCODING_MPEG_1 = 0,
+ V4L2_MPEG_VIDEO_ENCODING_MPEG_2 = 1,
+};
+#define V4L2_CID_MPEG_VIDEO_ASPECT (V4L2_CID_MPEG_BASE+201)
+enum v4l2_mpeg_video_aspect {
+ V4L2_MPEG_VIDEO_ASPECT_1x1 = 0,
+ V4L2_MPEG_VIDEO_ASPECT_4x3 = 1,
+ V4L2_MPEG_VIDEO_ASPECT_16x9 = 2,
+ V4L2_MPEG_VIDEO_ASPECT_221x100 = 3,
+};
+#define V4L2_CID_MPEG_VIDEO_B_FRAMES (V4L2_CID_MPEG_BASE+202)
+#define V4L2_CID_MPEG_VIDEO_GOP_SIZE (V4L2_CID_MPEG_BASE+203)
+#define V4L2_CID_MPEG_VIDEO_GOP_CLOSURE (V4L2_CID_MPEG_BASE+204)
+#define V4L2_CID_MPEG_VIDEO_PULLDOWN (V4L2_CID_MPEG_BASE+205)
+#define V4L2_CID_MPEG_VIDEO_BITRATE_MODE (V4L2_CID_MPEG_BASE+206)
+enum v4l2_mpeg_video_bitrate_mode {
+ V4L2_MPEG_VIDEO_BITRATE_MODE_VBR = 0,
+ V4L2_MPEG_VIDEO_BITRATE_MODE_CBR = 1,
+};
+#define V4L2_CID_MPEG_VIDEO_BITRATE (V4L2_CID_MPEG_BASE+207)
+#define V4L2_CID_MPEG_VIDEO_BITRATE_PEAK (V4L2_CID_MPEG_BASE+208)
+#define V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION (V4L2_CID_MPEG_BASE+209)
+#define V4L2_CID_MPEG_VIDEO_MUTE (V4L2_CID_MPEG_BASE+210)
+#define V4L2_CID_MPEG_VIDEO_MUTE_YUV (V4L2_CID_MPEG_BASE+211)
+
+/* MPEG-class control IDs specific to the CX2584x driver as defined by V4L2 */
+#define V4L2_CID_MPEG_CX2341X_BASE (V4L2_CTRL_CLASS_MPEG | 0x1000)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+0)
+enum v4l2_mpeg_cx2341x_video_spatial_filter_mode {
+ V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_MANUAL = 0,
+ V4L2_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE_AUTO = 1,
+};
+#define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+1)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+2)
+enum v4l2_mpeg_cx2341x_video_luma_spatial_filter_type {
+ V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_OFF = 0,
+ V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
+ V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_1D_VERT = 2,
+ V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_HV_SEPARABLE = 3,
+ V4L2_MPEG_CX2341X_VIDEO_LUMA_SPATIAL_FILTER_TYPE_2D_SYM_NON_SEPARABLE = 4,
+};
+#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+3)
+enum v4l2_mpeg_cx2341x_video_chroma_spatial_filter_type {
+ V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_OFF = 0,
+ V4L2_MPEG_CX2341X_VIDEO_CHROMA_SPATIAL_FILTER_TYPE_1D_HOR = 1,
+};
+#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE (V4L2_CID_MPEG_CX2341X_BASE+4)
+enum v4l2_mpeg_cx2341x_video_temporal_filter_mode {
+ V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_MANUAL = 0,
+ V4L2_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER_MODE_AUTO = 1,
+};
+#define V4L2_CID_MPEG_CX2341X_VIDEO_TEMPORAL_FILTER (V4L2_CID_MPEG_CX2341X_BASE+5)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE (V4L2_CID_MPEG_CX2341X_BASE+6)
+enum v4l2_mpeg_cx2341x_video_median_filter_type {
+ V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_OFF = 0,
+ V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR = 1,
+ V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_VERT = 2,
+ V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_HOR_VERT = 3,
+ V4L2_MPEG_CX2341X_VIDEO_MEDIAN_FILTER_TYPE_DIAG = 4,
+};
+#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+7)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_LUMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+8)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_BOTTOM (V4L2_CID_MPEG_CX2341X_BASE+9)
+#define V4L2_CID_MPEG_CX2341X_VIDEO_CHROMA_MEDIAN_FILTER_TOP (V4L2_CID_MPEG_CX2341X_BASE+10)
+#define V4L2_CID_MPEG_CX2341X_STREAM_INSERT_NAV_PACKETS (V4L2_CID_MPEG_CX2341X_BASE+11)
+
+/*
+ * T U N I N G
+ */
+struct v4l2_tuner
+{
+ __u32 index;
+ __u8 name[32];
+ enum v4l2_tuner_type type;
+ __u32 capability;
+ __u32 rangelow;
+ __u32 rangehigh;
+ __u32 rxsubchans;
+ __u32 audmode;
+ __s32 signal;
+ __s32 afc;
+ __u32 reserved[4];
+};
+
+struct v4l2_modulator
+{
+ __u32 index;
+ __u8 name[32];
+ __u32 capability;
+ __u32 rangelow;
+ __u32 rangehigh;
+ __u32 txsubchans;
+ __u32 reserved[4];
+};
+
+/* Flags for the 'capability' field */
+#define V4L2_TUNER_CAP_LOW 0x0001
+#define V4L2_TUNER_CAP_NORM 0x0002
+#define V4L2_TUNER_CAP_STEREO 0x0010
+#define V4L2_TUNER_CAP_LANG2 0x0020
+#define V4L2_TUNER_CAP_SAP 0x0020
+#define V4L2_TUNER_CAP_LANG1 0x0040
+
+/* Flags for the 'rxsubchans' field */
+#define V4L2_TUNER_SUB_MONO 0x0001
+#define V4L2_TUNER_SUB_STEREO 0x0002
+#define V4L2_TUNER_SUB_LANG2 0x0004
+#define V4L2_TUNER_SUB_SAP 0x0004
+#define V4L2_TUNER_SUB_LANG1 0x0008
+
+/* Values for the 'audmode' field */
+#define V4L2_TUNER_MODE_MONO 0x0000
+#define V4L2_TUNER_MODE_STEREO 0x0001
+#define V4L2_TUNER_MODE_LANG2 0x0002
+#define V4L2_TUNER_MODE_SAP 0x0002
+#define V4L2_TUNER_MODE_LANG1 0x0003
+#define V4L2_TUNER_MODE_LANG1_LANG2 0x0004
+
+struct v4l2_frequency
+{
+ __u32 tuner;
+ enum v4l2_tuner_type type;
+ __u32 frequency;
+ __u32 reserved[8];
+};
+
+/*
+ * A U D I O
+ */
+struct v4l2_audio
+{
+ __u32 index;
+ __u8 name[32];
+ __u32 capability;
+ __u32 mode;
+ __u32 reserved[2];
+};
+
+/* Flags for the 'capability' field */
+#define V4L2_AUDCAP_STEREO 0x00001
+#define V4L2_AUDCAP_AVL 0x00002
+
+/* Flags for the 'mode' field */
+#define V4L2_AUDMODE_AVL 0x00001
+
+struct v4l2_audioout
+{
+ __u32 index;
+ __u8 name[32];
+ __u32 capability;
+ __u32 mode;
+ __u32 reserved[2];
+};
+
+/*
+ * M P E G S E R V I C E S
+ *
+ * NOTE: EXPERIMENTAL API
+ */
+#if 1
+#define V4L2_ENC_IDX_FRAME_I (0)
+#define V4L2_ENC_IDX_FRAME_P (1)
+#define V4L2_ENC_IDX_FRAME_B (2)
+#define V4L2_ENC_IDX_FRAME_MASK (0xf)
+
+struct v4l2_enc_idx_entry {
+ __u64 offset;
+ __u64 pts;
+ __u32 length;
+ __u32 flags;
+ __u32 reserved[2];
+};
+
+#define V4L2_ENC_IDX_ENTRIES (64)
+struct v4l2_enc_idx {
+ __u32 entries;
+ __u32 entries_cap;
+ __u32 reserved[4];
+ struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
+};
+
+
+#define V4L2_ENC_CMD_START (0)
+#define V4L2_ENC_CMD_STOP (1)
+#define V4L2_ENC_CMD_PAUSE (2)
+#define V4L2_ENC_CMD_RESUME (3)
+
+/* Flags for V4L2_ENC_CMD_STOP */
+#define V4L2_ENC_CMD_STOP_AT_GOP_END (1 << 0)
+
+struct v4l2_encoder_cmd {
+ __u32 cmd;
+ __u32 flags;
+ union {
+ struct {
+ __u32 data[8];
+ } raw;
+ };
+};
+
+#endif
+
+
+/*
+ * D A T A S E R V I C E S ( V B I )
+ *
+ * Data services API by Michael Schimek
+ */
+
+/* Raw VBI */
+struct v4l2_vbi_format
+{
+ __u32 sampling_rate; /* in 1 Hz */
+ __u32 offset;
+ __u32 samples_per_line;
+ __u32 sample_format; /* V4L2_PIX_FMT_* */
+ __s32 start[2];
+ __u32 count[2];
+ __u32 flags; /* V4L2_VBI_* */
+ __u32 reserved[2]; /* must be zero */
+};
+
+/* VBI flags */
+#define V4L2_VBI_UNSYNC (1<< 0)
+#define V4L2_VBI_INTERLACED (1<< 1)
+
+/* Sliced VBI
+ *
+ * This implements is a proposal V4L2 API to allow SLICED VBI
+ * required for some hardware encoders. It should change without
+ * notice in the definitive implementation.
+ */
+
+struct v4l2_sliced_vbi_format
+{
+ __u16 service_set;
+ /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
+ service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
+ (equals frame lines 313-336 for 625 line video
+ standards, 263-286 for 525 line standards) */
+ __u16 service_lines[2][24];
+ __u32 io_size;
+ __u32 reserved[2]; /* must be zero */
+};
+
+/* Teletext World System Teletext
+ (WST), defined on ITU-R BT.653-2 */
+#define V4L2_SLICED_TELETEXT_B (0x0001)
+/* Video Program System, defined on ETS 300 231*/
+#define V4L2_SLICED_VPS (0x0400)
+/* Closed Caption, defined on EIA-608 */
+#define V4L2_SLICED_CAPTION_525 (0x1000)
+/* Wide Screen System, defined on ITU-R BT1119.1 */
+#define V4L2_SLICED_WSS_625 (0x4000)
+
+#define V4L2_SLICED_VBI_525 (V4L2_SLICED_CAPTION_525)
+#define V4L2_SLICED_VBI_625 (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
+
+struct v4l2_sliced_vbi_cap
+{
+ __u16 service_set;
+ /* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
+ service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
+ (equals frame lines 313-336 for 625 line video
+ standards, 263-286 for 525 line standards) */
+ __u16 service_lines[2][24];
+ enum v4l2_buf_type type;
+ __u32 reserved[3]; /* must be 0 */
+};
+
+struct v4l2_sliced_vbi_data
+{
+ __u32 id;
+ __u32 field; /* 0: first field, 1: second field */
+ __u32 line; /* 1-23 */
+ __u32 reserved; /* must be 0 */
+ __u8 data[48];
+};
+
+/*
+ * A G G R E G A T E S T R U C T U R E S
+ */
+
+/* Stream data format
+ */
+struct v4l2_format
+{
+ enum v4l2_buf_type type;
+ union
+ {
+ struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE
+ struct v4l2_window win; // V4L2_BUF_TYPE_VIDEO_OVERLAY
+ struct v4l2_vbi_format vbi; // V4L2_BUF_TYPE_VBI_CAPTURE
+ struct v4l2_sliced_vbi_format sliced; // V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
+ __u8 raw_data[200]; // user-defined
+ } fmt;
+};
+
+
+/* Stream type-dependent parameters
+ */
+struct v4l2_streamparm
+{
+ enum v4l2_buf_type type;
+ union
+ {
+ struct v4l2_captureparm capture;
+ struct v4l2_outputparm output;
+ __u8 raw_data[200]; /* user-defined */
+ } parm;
+};
+
+/*
+ * A D V A N C E D D E B U G G I N G
+ *
+ * NOTE: EXPERIMENTAL API
+ */
+
+/* VIDIOC_DBG_G_REGISTER and VIDIOC_DBG_S_REGISTER */
+
+#define V4L2_CHIP_MATCH_HOST 0 /* Match against chip ID on host (0 for the host) */
+#define V4L2_CHIP_MATCH_I2C_DRIVER 1 /* Match against I2C driver ID */
+#define V4L2_CHIP_MATCH_I2C_ADDR 2 /* Match against I2C 7-bit address */
+
+struct v4l2_register {
+ __u32 match_type; /* Match type */
+ __u32 match_chip; /* Match this chip, meaning determined by match_type */
+ __u64 reg;
+ __u64 val;
+};
+
+/* VIDIOC_G_CHIP_IDENT */
+struct v4l2_chip_ident {
+ __u32 match_type; /* Match type */
+ __u32 match_chip; /* Match this chip, meaning determined by match_type */
+ __u32 ident; /* chip identifier as specified in <media/v4l2-chip-ident.h> */
+ __u32 revision; /* chip revision, chip specific */
+};
+
+/*
+ * I O C T L C O D E S F O R V I D E O D E V I C E S
+ *
+ */
+#define VIDIOC_QUERYCAP _IOR ('V', 0, struct v4l2_capability)
+#define VIDIOC_RESERVED _IO ('V', 1)
+#define VIDIOC_ENUM_FMT _IOWR ('V', 2, struct v4l2_fmtdesc)
+#define VIDIOC_G_FMT _IOWR ('V', 4, struct v4l2_format)
+#define VIDIOC_S_FMT _IOWR ('V', 5, struct v4l2_format)
+#define VIDIOC_REQBUFS _IOWR ('V', 8, struct v4l2_requestbuffers)
+#define VIDIOC_QUERYBUF _IOWR ('V', 9, struct v4l2_buffer)
+#define VIDIOC_G_FBUF _IOR ('V', 10, struct v4l2_framebuffer)
+#define VIDIOC_S_FBUF _IOW ('V', 11, struct v4l2_framebuffer)
+#define VIDIOC_OVERLAY _IOW ('V', 14, int)
+#define VIDIOC_QBUF _IOWR ('V', 15, struct v4l2_buffer)
+#define VIDIOC_DQBUF _IOWR ('V', 17, struct v4l2_buffer)
+#define VIDIOC_STREAMON _IOW ('V', 18, int)
+#define VIDIOC_STREAMOFF _IOW ('V', 19, int)
+#define VIDIOC_G_PARM _IOWR ('V', 21, struct v4l2_streamparm)
+#define VIDIOC_S_PARM _IOWR ('V', 22, struct v4l2_streamparm)
+#define VIDIOC_G_STD _IOR ('V', 23, v4l2_std_id)
+#define VIDIOC_S_STD _IOW ('V', 24, v4l2_std_id)
+#define VIDIOC_ENUMSTD _IOWR ('V', 25, struct v4l2_standard)
+#define VIDIOC_ENUMINPUT _IOWR ('V', 26, struct v4l2_input)
+#define VIDIOC_G_CTRL _IOWR ('V', 27, struct v4l2_control)
+#define VIDIOC_S_CTRL _IOWR ('V', 28, struct v4l2_control)
+#define VIDIOC_G_TUNER _IOWR ('V', 29, struct v4l2_tuner)
+#define VIDIOC_S_TUNER _IOW ('V', 30, struct v4l2_tuner)
+#define VIDIOC_G_AUDIO _IOR ('V', 33, struct v4l2_audio)
+#define VIDIOC_S_AUDIO _IOW ('V', 34, struct v4l2_audio)
+#define VIDIOC_QUERYCTRL _IOWR ('V', 36, struct v4l2_queryctrl)
+#define VIDIOC_QUERYMENU _IOWR ('V', 37, struct v4l2_querymenu)
+#define VIDIOC_G_INPUT _IOR ('V', 38, int)
+#define VIDIOC_S_INPUT _IOWR ('V', 39, int)
+#define VIDIOC_G_OUTPUT _IOR ('V', 46, int)
+#define VIDIOC_S_OUTPUT _IOWR ('V', 47, int)
+#define VIDIOC_ENUMOUTPUT _IOWR ('V', 48, struct v4l2_output)
+#define VIDIOC_G_AUDOUT _IOR ('V', 49, struct v4l2_audioout)
+#define VIDIOC_S_AUDOUT _IOW ('V', 50, struct v4l2_audioout)
+#define VIDIOC_G_MODULATOR _IOWR ('V', 54, struct v4l2_modulator)
+#define VIDIOC_S_MODULATOR _IOW ('V', 55, struct v4l2_modulator)
+#define VIDIOC_G_FREQUENCY _IOWR ('V', 56, struct v4l2_frequency)
+#define VIDIOC_S_FREQUENCY _IOW ('V', 57, struct v4l2_frequency)
+#define VIDIOC_CROPCAP _IOWR ('V', 58, struct v4l2_cropcap)
+#define VIDIOC_G_CROP _IOWR ('V', 59, struct v4l2_crop)
+#define VIDIOC_S_CROP _IOW ('V', 60, struct v4l2_crop)
+#define VIDIOC_G_JPEGCOMP _IOR ('V', 61, struct v4l2_jpegcompression)
+#define VIDIOC_S_JPEGCOMP _IOW ('V', 62, struct v4l2_jpegcompression)
+#define VIDIOC_QUERYSTD _IOR ('V', 63, v4l2_std_id)
+#define VIDIOC_TRY_FMT _IOWR ('V', 64, struct v4l2_format)
+#define VIDIOC_ENUMAUDIO _IOWR ('V', 65, struct v4l2_audio)
+#define VIDIOC_ENUMAUDOUT _IOWR ('V', 66, struct v4l2_audioout)
+#define VIDIOC_G_PRIORITY _IOR ('V', 67, enum v4l2_priority)
+#define VIDIOC_S_PRIORITY _IOW ('V', 68, enum v4l2_priority)
+#define VIDIOC_G_SLICED_VBI_CAP _IOWR ('V', 69, struct v4l2_sliced_vbi_cap)
+#define VIDIOC_LOG_STATUS _IO ('V', 70)
+#define VIDIOC_G_EXT_CTRLS _IOWR ('V', 71, struct v4l2_ext_controls)
+#define VIDIOC_S_EXT_CTRLS _IOWR ('V', 72, struct v4l2_ext_controls)
+#define VIDIOC_TRY_EXT_CTRLS _IOWR ('V', 73, struct v4l2_ext_controls)
+#if 1
+#define VIDIOC_ENUM_FRAMESIZES _IOWR ('V', 74, struct v4l2_frmsizeenum)
+#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR ('V', 75, struct v4l2_frmivalenum)
+#define VIDIOC_G_ENC_INDEX _IOR ('V', 76, struct v4l2_enc_idx)
+#define VIDIOC_ENCODER_CMD _IOWR ('V', 77, struct v4l2_encoder_cmd)
+#define VIDIOC_TRY_ENCODER_CMD _IOWR ('V', 78, struct v4l2_encoder_cmd)
+
+/* Experimental, only implemented if CONFIG_VIDEO_ADV_DEBUG is defined */
+#define VIDIOC_DBG_S_REGISTER _IOW ('V', 79, struct v4l2_register)
+#define VIDIOC_DBG_G_REGISTER _IOWR ('V', 80, struct v4l2_register)
+
+#define VIDIOC_G_CHIP_IDENT _IOWR ('V', 81, struct v4l2_chip_ident)
+#endif
+
+#ifdef __OLD_VIDIOC_
+/* for compatibility, will go away some day */
+#define VIDIOC_OVERLAY_OLD _IOWR ('V', 14, int)
+#define VIDIOC_S_PARM_OLD _IOW ('V', 22, struct v4l2_streamparm)
+#define VIDIOC_S_CTRL_OLD _IOW ('V', 28, struct v4l2_control)
+#define VIDIOC_G_AUDIO_OLD _IOWR ('V', 33, struct v4l2_audio)
+#define VIDIOC_G_AUDOUT_OLD _IOWR ('V', 49, struct v4l2_audioout)
+#define VIDIOC_CROPCAP_OLD _IOR ('V', 58, struct v4l2_cropcap)
+#endif
+
+#define BASE_VIDIOC_PRIVATE 192 /* 192-255 are private */
+
+#endif /* __LINUX_VIDEODEV2_H */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/src/video/VideoCodec/H263.cpp b/src/video/VideoCodec/H263.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..23c8a0ec57fe19f92487e40d18bfc171029d6ad4
--- /dev/null
+++ b/src/video/VideoCodec/H263.cpp
@@ -0,0 +1,19 @@
+
+
+#include "H263.h"
+
+H263::H263(){}
+H263::~H263(){}
+int H263::videoEncode(int width, int height, uint8_t* buf, unsigned int size){
+
+
+return 0;
+ }
+
+int H263::videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf ){
+
+return 0;
+}
+
+
+
diff --git a/src/video/VideoCodec/H263.h b/src/video/VideoCodec/H263.h
new file mode 100644
index 0000000000000000000000000000000000000000..f76ab911640689b287008f5c9b5e90b7e3f6408d
--- /dev/null
+++ b/src/video/VideoCodec/H263.h
@@ -0,0 +1,54 @@
+/**
+ * H263 Class
+ *
+ * This class is a VideoCodec child class. Since the VideoCodec class is virtual and abstract
+ * an H263 videoCodec will assumme encoding and decoding video data.
+ * This class acts like an interface with the encoding and decoding methods of the h263
+ * libavcodec files
+ *
+ */
+
+#ifndef H263_H
+#define H263_H
+#include "VideoCodec.h"
+
+
+
+class H263 : public VideoCodec {
+public:
+
+ /**
+ * Default Constructor
+ *
+ */
+ H263();
+ /**
+ * Default Destructor
+ *
+ */
+ ~H263();
+/**
+ * Function to decode video information
+ * @param in_buf the input buffer
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param out_buf the output buffer
+ *
+ */
+ int videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf );
+ /**
+ * Function to encode video information
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param buf the buffer to encode
+ * @param size buffer size
+ *
+ */
+ int videoEncode(int width, int height, uint8_t* buf, unsigned int size);
+};
+
+
+
+
+#endif //H263_H
+
diff --git a/src/video/VideoCodec/H263P.cpp b/src/video/VideoCodec/H263P.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2834f3af48a5c249ad8cbf35bb5ef8d2abe36858
--- /dev/null
+++ b/src/video/VideoCodec/H263P.cpp
@@ -0,0 +1,12 @@
+
+
+#include "H263P.h"
+
+
+H263P::H263P(){}
+H263P::~H263P(){}
+
+int H263P::videoEncode(int width, int height, uint8_t* buf, unsigned int size){return 0;}
+int H263P::videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf ){return 0;}
+
+
diff --git a/src/video/VideoCodec/H263P.h b/src/video/VideoCodec/H263P.h
new file mode 100644
index 0000000000000000000000000000000000000000..a9245f99afe954d68f391d20b1d8d31fc01e9c08
--- /dev/null
+++ b/src/video/VideoCodec/H263P.h
@@ -0,0 +1,49 @@
+/**
+ * H263p Class
+ *
+ * This class is a VideoCodec child class. Since the VideoCodec class is virtual and abstract
+ * an H263p videoCodec will assumme encoding and decoding video data.
+ * This class acts like an interface with the encoding and decoding methods of the h263p
+ * libavcodec files
+ *
+ */
+
+#ifndef H263P_H
+#define H263P_H
+#include "VideoCodec.h"
+
+/**
+ * @author Jean-Francois Blanchard-Dionne */
+class H263P : public VideoCodec {
+public:
+ /**
+ * Default Constructor
+ *
+ */
+
+ H263P();
+ /**
+ * Default Destructor
+ *
+ */
+ ~H263P();
+/**
+ * Function to decode video information
+ * @param in_buf the input buffer
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param out_buf the output buffer
+ *
+ */
+ int videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf );
+/**
+ * Function to encode video information
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param buf the buffer to encode
+ * @param size buffer size
+ *
+ */
+ int videoEncode(int width, int height, uint8_t* buf, unsigned int size);
+};
+#endif //H263P_H
diff --git a/src/video/VideoCodec/H264.cpp b/src/video/VideoCodec/H264.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..29dbf497ac211b3fda232e3007fcce1b5ab47744
--- /dev/null
+++ b/src/video/VideoCodec/H264.cpp
@@ -0,0 +1,20 @@
+
+
+#include "H264.h"
+
+H264::H264(){}
+H264::~H264(){}
+
+int H264::videoEncode(int width, int height, uint8_t* buf, unsigned int size){
+
+
+return 0;
+}
+int H264::videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf ){
+
+return 0;
+
+}
+
+
+
diff --git a/src/video/VideoCodec/H264.h b/src/video/VideoCodec/H264.h
new file mode 100644
index 0000000000000000000000000000000000000000..ec8057a6d4598a03e4350835bc3246ce4174b3bb
--- /dev/null
+++ b/src/video/VideoCodec/H264.h
@@ -0,0 +1,51 @@
+/**
+ * H264 Class
+ *
+ * This class is a VideoCodec child class. Since the VideoCodec class is virtual and abstract
+ * an H264 videoCodec will assumme encoding and decoding video data.
+ * This class acts like an interface with the encoding and decoding methods of the h264
+ * libavcodec files
+ *
+ */
+
+#ifndef H264_H
+#define H264_H
+#include "VideoCodec.h"
+
+
+/**
+ * @author Jean-Francois Blanchard-Dionne
+ */
+class H264 : public VideoCodec {
+public:
+ /**
+ * Default Constructor
+ *
+ */
+
+ H264();
+ /**
+ * Default Destructor
+ *
+ */
+ ~H264();
+ /**
+ * Function to decode video information
+ * @param in_buf the input buffer
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param out_buf the output buffer
+ *
+ */
+ int videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf );
+ /**
+ * Function to encode video information
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param buf the buffer to encode
+ * @param size buffer size
+ *
+ */
+ int videoEncode(int width, int height, uint8_t* buf, unsigned int size);
+};
+#endif //H264_H
diff --git a/src/video/VideoCodec/Makefile.am b/src/video/VideoCodec/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..ccf383d9d08da8da8ddf0a4bd8189f57f9d463c6
--- /dev/null
+++ b/src/video/VideoCodec/Makefile.am
@@ -0,0 +1,10 @@
+SUBDIRS =
+
+noinst_LTLIBRARIES = libvideocodec.la
+
+libvideocodec_la_SOURCES = H263.cpp \
+ H263P.cpp \
+ H264.cpp
+
+AM_CXXFLAGS = -I$(top_srcdir)/include $(USER_INCLUDES)
+
diff --git a/src/video/VideoCodec/VideoCodec.h b/src/video/VideoCodec/VideoCodec.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a1a1edbc586afd39968c9a45b78a7e6f2e9137a
--- /dev/null
+++ b/src/video/VideoCodec/VideoCodec.h
@@ -0,0 +1,65 @@
+/**
+ * VideoCodec Class
+ *
+ * This is the mother VideoCodec class. It's a virtual abstract class for encoding and
+ * decoding video data.
+ */
+
+#ifndef VIDEOCODEC_H
+#define VIDEOCODEC_H
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+/**
+ * @author Jean-Francois Blanchard-Dionne */
+class VideoCodec {
+public:
+/**
+ * Function to decode video information
+ * @param in_buf the input buffer
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param out_buf the output buffer
+ *
+ */
+ virtual int videoDecode(uint8_t *in_buf, int width, int height, uint8_t* out_buf ) =0;
+/**
+ * Function to encode video information
+ * @param width of the video frame
+ * @param height of the video frame
+ * @param buf the buffer to encode
+ * @param size buffer size
+ *
+ */
+ virtual int videoEncode(int width, int height, uint8_t* buf, unsigned int size) =0;
+
+ void init();
+ /**
+ * Default Destructor
+ *
+ */
+ virtual ~VideoCodec() =0;
+ /**
+ * Default Constructor
+ *
+ */
+ VideoCodec();
+private:
+ /**
+ * Libavcodec Codec type
+ */
+ AVCodec* Codec;
+ /**
+ * Libavcodec Codec context
+ */
+ AVCodecContext* codecCtx;
+ /**
+ * Libavcodec packet
+ */
+ AVPacket pkt;
+ /**
+ * Libavcodec frame
+ */
+ AVFrame* frame;
+};
+#endif //VIDEOCODEC_H
+
diff --git a/src/video/VideoCodecDescriptor.cpp b/src/video/VideoCodecDescriptor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8b4e9f62d91aca8a86005b36211c2fbd69ce397e
--- /dev/null
+++ b/src/video/VideoCodecDescriptor.cpp
@@ -0,0 +1,38 @@
+#include "VideoCodecDescriptor.h"
+
+ VideoCodecDescriptor::~VideoCodecDescriptor(){}
+
+ VideoCodecDescriptor::VideoCodecDescriptor(){}
+
+
+ int VideoCodecDescriptor::setDefaultOrder(){
+
+ return 1;
+ }
+
+ void VideoCodecDescriptor::init(){}
+
+
+ bool VideoCodecDescriptor::isActive(enum CodecID id){
+
+ return true;
+ }
+
+
+ int VideoCodecDescriptor::removeCodec(enum CodecID id){
+
+ return 1;
+ }
+
+
+ int VideoCodecDescriptor::addCodec(enum CodecID id){
+ return 1;}
+
+ VideoCodecOrder& VideoCodecDescriptor::getActiveCodecs() { return activeCodecs; }
+
+ void VideoCodecDescriptor::setActiveCodecs(VideoCodecOrder& activeC){}
+
+ void VideoCodecDescriptor::setCodecMap(VideoCodecMap& codec){}
+
+ int setDefaultOrder(){return 0;}
+
diff --git a/src/video/VideoCodecDescriptor.h b/src/video/VideoCodecDescriptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..d76c6a2978fc86eedc8b8fa4360213b5c0560e95
--- /dev/null
+++ b/src/video/VideoCodecDescriptor.h
@@ -0,0 +1,105 @@
+/**
+ * VideoCodecDescriptor Class
+ *
+ * This class acts like a container. It generates at startup a map of all
+ * codecs, active or not, supported by the application and sets a vector for the order
+ * of negotiation of the video codecs
+ * Most functions in this class is for managing and accessing these two containers
+ * This class is mainly to interact with the GUI about video Codecs matter.
+ */
+
+
+#ifndef VIDEOCODECDESCRIPTOR_H
+#define VIDEOCODECDESCRIPTOR_H
+#include <map>
+#include <vector>
+#include <string>
+//#include "/usr/include/ffmpeg/avcodec.h"
+#include <ffmpeg/avcodec.h>
+
+using namespace std;
+/**
+ * @author Jean-francois Blanchard-dionne
+ */
+/* A codec is identified by its libavcodec CodecID. A CodecID is associated with a name. */
+typedef std::map<CodecID, std::string> VideoCodecMap;
+/* The struct to reflect the order the user wants to use the Video codecs */
+typedef std::vector<CodecID> VideoCodecOrder;
+
+class VideoCodecDescriptor {
+public:
+
+ /**
+ * Destructor
+ */
+ ~VideoCodecDescriptor();
+ /**
+ * Default Constructor
+ */
+ VideoCodecDescriptor();
+ /**
+ * Set the default codecs order
+ */
+ int setDefaultOrder();
+
+
+ void init();
+
+
+ /**
+ * Check in the map codec if the specified codec is supported
+ * @param id : libavcodec unique codecID
+ * @return true if the codec specified is supported
+ * false otherwise
+ */
+ bool isActive(enum CodecID id);
+
+ /**
+ * Remove the codec from the list
+ * @param id : libavcodec CodecID of the codec to erase
+ */
+ int removeCodec(enum CodecID id);
+
+ /**
+ * Add a codec in the list.
+ * @param id : libavcodec CodecID of the codec to add
+ */
+ int addCodec(enum CodecID id);
+ /**
+ * Function to send the map containing the active Codecs.
+ *
+ */
+ VideoCodecOrder& getActiveCodecs();
+ /**
+ * Function to set the map
+ * @param activeC to set the Codec Map with another map
+ * (not really suppose to happen)
+ */
+ void setActiveCodecs(VideoCodecOrder& activeC);
+ /**
+ * Function to set the map
+ * @param codecMap to set the Codec Map
+ * (not really suppose to happen)
+ */
+ void setCodecMap(VideoCodecMap& codecMap);
+ /**
+ * Function to get the map
+ * @return codecMap to set the Codec Map
+ */
+ VideoCodecMap& getCodecMap() { return codecMap; }
+
+private:
+ /**
+ * Vector of all the Active codecs
+ */
+ VideoCodecOrder activeCodecs;
+ /**
+ * Map of all codecs, active and inactive
+ */
+ VideoCodecMap codecMap;
+
+
+
+
+};
+#endif //VIDEOCODECDESCRIPTOR_H
diff --git a/src/video/VideoRtp.cpp b/src/video/VideoRtp.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d4ef13329bafba69d3a1090174433edcbbf40c50
--- /dev/null
+++ b/src/video/VideoRtp.cpp
@@ -0,0 +1,11 @@
+
+
+#include "VideoRtp.h"
+#include "VideoRtpRTX.h"
+
+
+VideoRtp::VideoRtp(){}
+VideoRtp::~VideoRtp(){}
+int VideoRtp::createNewVideoSession(bool conf){return 1;}
+int VideoRtp::closeVideoSession(bool conf){return 1;}
+
diff --git a/src/video/VideoRtp.h b/src/video/VideoRtp.h
new file mode 100644
index 0000000000000000000000000000000000000000..a91fa6989f0b2968dbab0a2b92f6ef728dfc03f0
--- /dev/null
+++ b/src/video/VideoRtp.h
@@ -0,0 +1,52 @@
+/**
+ * VideoRTP Class
+ *
+ * This class is responsible of creating the thread for getting and setting
+ * video data in a conversation and add an other thread in case Local SFLPhone
+ * is a Conference server
+ */
+
+#ifndef VIDEORTP_H
+#define VIDEORTP_H
+
+#include "VideoRtpRTX.h"
+#include <cc++/thread.h>
+#include <samplerate.h>
+class VideoRtpRTX;
+/**
+ * @author Jean-Francois Blanchard-Dionne
+ */
+class VideoRtp {
+public:
+ /**
+ * Destructor
+ */
+ ~VideoRtp();
+ /**
+ * Default Constructor
+ */
+ VideoRtp();
+
+ /**
+ * Function to create a new Vrtxthread
+ * @param conf is 0 to create a a conference video session thread
+ * note : must have an initial normal thread going on
+ * @return 0 if success , -1 if failure
+ */
+ int createNewVideoSession(bool conf);
+ /**
+ * Function to close a Vrtxthread
+ * @param conf is 0 to create a a conference video session thread
+ * note : must have an initial normal thread going on
+ *@return 0 if success , -1 if failure
+ */
+ int closeVideoSession(bool conf);
+
+private:
+ VideoRtpRTX* vRTXThread;
+ VideoRtpRTX* vRTXThreadConf;
+ ost::Mutex vThreadMutex;
+
+};
+
+#endif //VIDEORTP_H
diff --git a/src/video/VideoRtpRTX.cpp b/src/video/VideoRtpRTX.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e112c878459f710c7d1309a13d8be98961019964
--- /dev/null
+++ b/src/video/VideoRtpRTX.cpp
@@ -0,0 +1,21 @@
+#include "VideoRtpRTX.h"
+
+
+VideoRtpRTX::VideoRtpRTX(){}
+VideoRtpRTX::~VideoRtpRTX(){}
+
+
+void VideoRtpRTX::run(){}
+
+void VideoRtpRTX::initBuffers(){}
+
+void VideoRtpRTX::initVideoRtpSession(){}
+
+void VideoRtpRTX::sendSession(int timestamp){}
+
+
+void VideoRtpRTX::receiveSession(){}
+
+void VideoRtpRTX::loadCodec(enum CodecID id,int type){}
+
+void VideoRtpRTX::unloadCodec(enum CodecID id,int type){}
diff --git a/src/video/VideoRtpRTX.h b/src/video/VideoRtpRTX.h
new file mode 100644
index 0000000000000000000000000000000000000000..7b8cc712da6dd3c4ffec4b5add6a4a8727f1b725
--- /dev/null
+++ b/src/video/VideoRtpRTX.h
@@ -0,0 +1,92 @@
+/**
+ * VideoTrpTTX Class
+ *
+ * This class is a thread of execution for sending and receiving video data.
+ * It has to interact with local capture (V4l) the mixer and the RTPsessions.
+ *
+ */
+
+#ifndef VIDEORTPRTX_H
+#define VIDEORTPRTX_H
+
+#include "VideoCodec/VideoCodec.h"
+#include "VideoRtp.h"
+#include <cc++/thread.h>
+#include <ccrtp/rtp.h>
+class SIPCall;
+/**
+ * @author Jean-Francois Blanchard-Dionne
+ */
+class VideoRtpRTX : public ost::Thread, public ost::TimerPort {
+public:
+
+ /**
+ * Destructor
+ */
+ ~VideoRtpRTX();
+ /**
+ * Default Constructor
+ */
+ VideoRtpRTX();
+ /**
+ * Main function to init RTPSession, send and receive data
+ */
+ void run();
+ /**
+ * Function to init buffer size
+ */
+ void initBuffers();
+ /**
+ * Function to create RTP Session to send Video Packets
+ */
+ void initVideoRtpSession();
+private:
+
+ /**
+ * Get the data from V4l, send it to the mixer, encode and send to RTP
+ * @param timestamp : puts the current time
+ */
+ void sendSession(int timestamp);
+
+ /**
+ * Receive RTP packet, decode it, send it to mixer
+ */
+ void receiveSession();
+
+ /**
+ * Load a codec
+ * @param id : The ID of the codec you want to load
+ * @param type : 0 decode codec, 1 encode codec
+ */
+ void loadCodec(enum CodecID id,int type);
+
+ /**
+ * unloadCodec
+ * @param id : The ID of the codec you want to unload
+ * @param type : 0 decode codec, 1 encode codec
+ */
+ void unloadCodec(enum CodecID id,int type);
+
+private:
+
+
+ ost::Mutex threadMutex;
+ SIPCall* vidCall;
+ /** RTP Session to send */
+ ost::RTPSession* videoSessionSend;
+ /** RTP Session to receive */
+ ost::RTPSession* videoSessionReceive;
+ /** System Semaphore */
+ ost::Semaphore start;
+ /** Codec for encoding */
+ VideoCodec* encodeCodec;
+ /** Codec for decoding */
+ VideoCodec* decodeCodec;
+
+ /** buffer for received Data */
+ char* receiveDataDecoded;
+
+ /** Buffer for Data to send */
+ char* sendDataEncoded;
+};
+#endif //VIDEORTPRTX_H
diff --git a/src/video/old/COPYING b/src/video/old/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..623b6258a134210f0b0ada106fdaab7f0370d9c5
--- /dev/null
+++ b/src/video/old/COPYING
@@ -0,0 +1,340 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, 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 or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+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 give any other recipients of the Program a copy of this License
+along with the Program.
+
+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 Program or any portion
+of it, thus forming a work based on the Program, 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) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+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 Program, 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 Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) 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; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, 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 executable. However, as a
+special exception, the source code 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.
+
+If distribution of executable or 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 counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program 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.
+
+ 5. 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 Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program 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 to
+this License.
+
+ 7. 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 Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program 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 Program.
+
+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.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program 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.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the 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 Program
+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 Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, 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
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "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 PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. 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 PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), 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 Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. 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 program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/src/video/old/README b/src/video/old/README
new file mode 100644
index 0000000000000000000000000000000000000000..ee5d23dd39c550f95a4a137ab637efb402a409ac
--- /dev/null
+++ b/src/video/old/README
@@ -0,0 +1,23 @@
+##############################################################
+Pour compiler: faire 'make'
+gcc gui-openGL/display.c -lglut -ljpeg -o stream_video
+make clean : to remove the .o files
+##############################################################
+
+
+##############################################################
+Executable: stream_video
+
+Lit le flux video de la webcam (device video0), et l'affiche avec openGL comme une texture.
+Driver: video4linux2
+##############################################################
+
+
+################################################################
+Raccourcis clavier:
+
+'q', 'Q' ou 'echap pour quitter l'application
+pad numérique: 1 - taille initiale (de la résolution supportée par la caméra)
+ 2 - double la taille d'affichage
+ 3 - triple la taille d'affichage
+####################################################################
diff --git a/src/video/old/abstract.odt b/src/video/old/abstract.odt
new file mode 100644
index 0000000000000000000000000000000000000000..e9263f9cff27f087345e37418b363eba096349b0
Binary files /dev/null and b/src/video/old/abstract.odt differ
diff --git a/src/video/old/gui-openGL/display.c b/src/video/old/gui-openGL/display.c
new file mode 100755
index 0000000000000000000000000000000000000000..6d456be2e52ad504b97eb41439bc0b5c6a75c815
--- /dev/null
+++ b/src/video/old/gui-openGL/display.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2006-2007 Savoir-Faire Linux inc.
+ * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <GL/gl.h>
+#include <GL/glut.h>
+#include <jpeglib.h>
+#include <jerror.h>
+
+#include "../v4l2/capture_v4l2.c"
+
+unsigned char* pix;
+camera_v4l2* camera;
+// video resolution
+int RES_X;
+int RES_Y;
+// window size
+int WIDTH = 512;
+int HEIGHT = 512;
+// texture size
+int x_t;
+int y_t;
+
+
+/*
+ * Sets up appropriate viewport coordinates for 2D
+ */
+void reshape(int w, int h)
+{
+ glViewport(0, 0, w, h);
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+ glOrtho(0, w, h, 0, -1, 1);
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+}
+
+void makeQuad(){
+
+ // centrer la video dans la fenetre
+ int x1,y1,x2,y2,x3,y3,x4,y4;
+ x1 = (WIDTH - x_t) / 2;
+ y1 = (HEIGHT - y_t) / 2;
+ x2 = x_t + x1;
+ y2 = y1;
+ x3 = x2;
+ y3 = y1 + y_t;
+ x4 = x1;
+ y4 = y3;
+
+ glBegin(GL_QUADS);
+
+ glTexCoord3i(0,0,0);
+ glVertex3i(x1,y1,0);
+ glTexCoord3i(1,0,0);
+ glVertex3i(x2,y2,0);
+ glTexCoord3i(1,1,0);
+ glVertex3i(x3,y3,0);
+ glTexCoord3i(0,1,0);
+ glVertex3i(x4,y4,0);
+
+
+
+
+ glEnd();
+}
+
+
+/*
+ * display callback function
+ */
+void display(void){
+
+ pix = v4l2_grab_data(camera);
+
+ glClear(GL_COLOR_BUFFER_BIT);
+ makeQuad();
+ glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,RES_X,RES_Y,0,GL_RGB,GL_UNSIGNED_BYTE,pix);
+ glutSwapBuffers();
+
+}
+
+void keyboard(unsigned char c, int x, int y){
+ switch(c)
+ {
+ case 27:
+ case 'q':
+ case 'Q':
+ exit(1);
+ break;
+ case '1':
+ x_t = RES_X;
+ y_t = RES_Y;
+ break;
+ case '2':
+ x_t = RES_X*2;
+ y_t = RES_Y*2;
+ break;
+ case '3':
+ x_t = RES_X*3;
+ y_t = RES_Y*3;
+ break;
+ }
+}
+
+
+void idle( void )
+{
+ glutPostRedisplay();
+}
+
+
+int main (int argc, char **argv) {
+ // init webcam
+ camera = v4l2_init_camera("/dev/video0");
+ // set video resolution
+ RES_X = camera->width;
+ RES_Y = camera->height;
+ // set texture resolution
+ x_t = RES_X;
+ y_t = RES_Y;
+
+ glutInit (&argc, argv);
+ glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE) ;
+ glutInitWindowSize (WIDTH,HEIGHT);
+ glutInitWindowPosition (300,200);
+ glutCreateWindow ("SFLphone Video Prototype");
+
+ // OpenGL texture paramaters
+ glEnable(GL_TEXTURE_2D);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+ //printf("Texture initialization done...........");
+ //glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,WIDTH,HEIGHT,0,GL_RGB,GL_UNSIGNED_BYTE,pix);
+
+ // Callback functions
+ glutDisplayFunc (display);
+ glutReshapeFunc(reshape);
+ glutIdleFunc(idle);
+ glutKeyboardFunc(keyboard);
+
+
+ glEnable(GL_DEPTH_TEST);
+
+ // main loop
+ glutMainLoop ();
+ //return 0;
+}
diff --git a/src/video/old/ressources.odt b/src/video/old/ressources.odt
new file mode 100644
index 0000000000000000000000000000000000000000..1c9cfed4cc410d060e1f4fc2bc4b959ccf66764b
Binary files /dev/null and b/src/video/old/ressources.odt differ
diff --git a/src/video/old/stream_video b/src/video/old/stream_video
new file mode 100755
index 0000000000000000000000000000000000000000..d3d3a8525c3a4171a6fb5c18e91e4a631778fa73
Binary files /dev/null and b/src/video/old/stream_video differ
diff --git a/src/video/old/utils/convert.c b/src/video/old/utils/convert.c
new file mode 100644
index 0000000000000000000000000000000000000000..14cf21ed7bde4bb2ac3276964ee28383e56c7e08
--- /dev/null
+++ b/src/video/old/utils/convert.c
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2006-2007 Savoir-Faire Linux inc.
+ * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/videodev.h>
+
+
+#define CLIP 320
+#define RED_NULL 128
+#define BLUE_NULL 128
+#define LUN_MUL 256
+#define RED_MUL 512
+#define BLUE_MUL 512
+
+
+#define GREEN1_MUL (-RED_MUL/2)
+#define GREEN2_MUL (-BLUE_MUL/6)
+#define RED_ADD (-RED_NULL * RED_MUL)
+#define BLUE_ADD (-BLUE_NULL * BLUE_MUL)
+#define GREEN1_ADD (-RED_ADD/2)
+#define GREEN2_ADD (-BLUE_ADD/6)
+
+/* lookup tables */
+static unsigned int ng_yuv_gray[256];
+static unsigned int ng_yuv_red[256];
+static unsigned int ng_yuv_blue[256];
+static unsigned int ng_yuv_g1[256];
+static unsigned int ng_yuv_g2[256];
+static unsigned int ng_clip[256 + 2 * CLIP];
+
+#define GRAY(val) ng_yuv_gray[val]
+#define RED(gray,red) ng_clip[ CLIP + gray + ng_yuv_red[red] ]
+#define GREEN(gray,red,blue) ng_clip[ CLIP + gray + ng_yuv_g1[red] + \
+ ng_yuv_g2[blue] ]
+#define BLUE(gray,blue) ng_clip[ CLIP + gray + ng_yuv_blue[blue] ]
+
+#define clip(x) ( (x)<0 ? 0 : ( (x)>255 ? 255 : (x) ) )
+/******************************************************************************/
+
+void YUV2RGB_init(void)
+{
+ int i;
+
+ /* init Lookup tables */
+ for (i = 0; i < 256; i++) {
+ ng_yuv_gray[i] = i * LUN_MUL >> 8;
+ ng_yuv_red[i] = (RED_ADD + i * RED_MUL) >> 8;
+ ng_yuv_blue[i] = (BLUE_ADD + i * BLUE_MUL) >> 8;
+ ng_yuv_g1[i] = (GREEN1_ADD + i * GREEN1_MUL) >> 8;
+ ng_yuv_g2[i] = (GREEN2_ADD + i * GREEN2_MUL) >> 8;
+ }
+ for (i = 0; i < CLIP; i++)
+ ng_clip[i] = 0;
+ for (; i < CLIP + 256; i++)
+ ng_clip[i] = i - CLIP;
+ for (; i < 2 * CLIP + 256; i++)
+ ng_clip[i] = 255;
+}
+
+
+void write_rgb(unsigned char **out, int Y, int U, int V)
+{
+ int R,G,B;
+ R=(76284*Y+104595*V)>>16;
+ G=(76284*Y -25625*U-53281*V)>>16;
+ B=(76284*Y+132252*U)>>16;
+
+ *(*out)=clip(R);
+ *(*out+1)=clip(G);
+ *(*out+2)=clip(B);
+ *out+=3;
+}
+
+
+void yuv420_rgb (unsigned char *out, unsigned char *in, int width, int height)
+{
+ unsigned char *u,*u1,*v,*v1;
+ int Y=0,U=0,V=0,i,j;
+
+ u=in+width*height;
+ v=u+(width*height)/4;
+
+ for(i=0;i<height;i++) {
+ u1=u;
+ v1=v;
+ for(j=0;j<width;j++) {
+ Y=(*in++)-16;
+ if((j&1)==0) {
+ U=(*u++)-128;
+ V=(*v++)-128;
+ }
+ write_rgb(&out,Y,U,V);
+ }
+ if((i&1)==0) { u=u1; v=v1; }
+ }
+}
+
+void yuyv_rgb (unsigned char *out, unsigned char *in, int width, int height)
+{
+ unsigned char *u,*u1,*v,*v1;
+ int Y=0,U=0,V=0,i,j;
+
+ u=in+1; v=in+3;
+ for(i=0;i<width*height;i++) {
+ Y=(*in)-16;
+ U=(*u)-128;
+ V=(*v)-128;
+ write_rgb(&out,Y,U,V);
+ in+=2;
+ if((i&1)==1) { u+=4; v+=4; }
+ }
+}
+
+
+void format_conversion(int format, char* in, char* out, int width, int height){
+
+ YUV2RGB_init();
+
+ switch(format){
+ case V4L2_PIX_FMT_YUV420:
+ yuv420_rgb(out,in,width,height);
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ yuyv_rgb(out,in,width,height);
+ break;
+ }
+}
+
+
+
diff --git a/src/video/old/v4l2/capture_v4l2.c b/src/video/old/v4l2/capture_v4l2.c
new file mode 100755
index 0000000000000000000000000000000000000000..c5b8882695624da73efa743161a35c4f08c8b790
--- /dev/null
+++ b/src/video/old/v4l2/capture_v4l2.c
@@ -0,0 +1,197 @@
+/*
+ * Copyright (C) 2006-2007 Savoir-Faire Linux inc.
+ * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ **/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <jpeglib.h>
+
+#include "capture_v4l2.h"
+#include "../utils/convert.c"
+
+#define DEVICE "/dev/video0"
+
+
+/******************************************************************/
+
+camera_v4l2* v4l2_init_camera( char* device_name ){
+
+ // initialization of the struct fields
+ camera_v4l2* webcam;
+ webcam = (camera_v4l2*)malloc(sizeof(camera_v4l2));
+
+ memset(&(webcam->cap),0,sizeof(webcam->cap));
+ memset(&(webcam->format),0,sizeof(webcam->format));
+
+ webcam->device = device_name;
+
+ printf("Checking device /dev/video0.......\n");
+ int n = query_camera(webcam);
+ webcam->addr = n;
+
+ if(n==0){
+ printf("Failed - query_camera()\n");
+ return 0;
+ }
+
+ printf("Query webcam done....\n");
+
+ // we use the fmt.pix.sizeimage field of the v4l2_pix_format struct
+ // fmt.pix.sizeimage contains the total size of the buffer to hold a complete image, in bytes.
+ webcam->raw_data = malloc(webcam->format.fmt.pix.sizeimage);
+ if (webcam->raw_data == NULL){
+ printf("Error, can't alloc memory for data buffer\n");
+ return 0;
+ }
+
+ // set the resolution of the camera
+ webcam->width = webcam->format.fmt.pix.width;
+ webcam->height = webcam->format.fmt.pix.height;
+
+ // memory allocation for the buffer that will contain the RGB information
+ // 3 values per pixels
+ webcam->img_data = malloc(webcam->width*webcam->height*3*sizeof(unsigned char));
+
+ if(webcam==NULL){
+ printf("INIT FAILED!\n");
+ return NULL;
+ }
+
+ info_device(webcam);
+
+ return webcam;
+}
+
+int query_camera(camera_v4l2* const camera){
+
+ int fd;
+
+ char* device = camera->device;
+ struct v4l2_capability* cap = &(camera->cap);
+ struct v4l2_format* format = &(camera->format);
+
+ // open the webcam device, like a file, return a file descriptor
+ fd = open(device, O_RDONLY);
+
+ if(fd < 0){
+ printf("error, can't open device %s\n", device);
+ return 0;
+ }
+
+ // fill the v4l2_capabilities struct by a ioctl call (control device)
+ // VIDIOC_QUERYCAP (V4L2 API Specification)
+ if(ioctl(fd, VIDIOC_QUERYCAP,cap)==-1){
+ printf("error, can't query device's capabilities\n");
+ return 0;
+ }
+
+ format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ if(ioctl(fd, VIDIOC_G_FMT, format)==-1){
+ printf("error, can't set the capture image format\n");
+ return 0;
+ }
+ format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
+
+ // return the file descriptor of the device
+ return fd;
+}
+
+
+char* v4l2_grab_data(camera_v4l2* const camera){
+
+ int fd = camera->addr;
+ int n = read( fd,
+ camera->raw_data,
+ camera->format.fmt.pix.sizeimage);
+ if(n==-1){
+ printf("Error, can't read the webcam\n");
+ return 0;
+ }
+
+ // launch image format conversion
+ format_conversion(camera->format.fmt.pix.pixelformat, camera->raw_data, camera->img_data, camera->width, camera->height);
+
+
+ //return camera->raw_data;
+ return camera->img_data;
+}
+
+void v4l2_free_data(camera_v4l2* cam){
+
+ free(cam->device);
+ free(cam->raw_data);
+ free(cam->img_data);
+ free(cam);
+}
+
+void info_device(camera_v4l2* cam){
+
+ int format = cam->format.fmt.pix.pixelformat;
+
+ printf("****************** SPECS CAMERA ********************\n");
+ printf("Image resolution = %ix%i\n",cam->width,cam->height);
+ printf("Image size = %i bytes\n", cam->format.fmt.pix.sizeimage);
+ printf("Pixels format = ");
+ switch(format){
+ case V4L2_PIX_FMT_RGB332:
+ printf("RGB332\n");
+ break;
+ case V4L2_PIX_FMT_RGB555:
+ printf("RGB555\n");
+ break;
+ case V4L2_PIX_FMT_RGB565:
+ printf("RGB565\n");
+ break;
+ case V4L2_PIX_FMT_BGR24:
+ printf("BGR24\n");
+ break;
+ case V4L2_PIX_FMT_RGB24:
+ printf("RGB24\n");
+ break;
+ case V4L2_PIX_FMT_BGR32:
+ printf("BGR32\n");
+ break;
+ case V4L2_PIX_FMT_RGB32:
+ printf("RGB32\n");
+ break;
+ case V4L2_PIX_FMT_YUV410:
+ printf("YUV410\n");
+ break;
+ case V4L2_PIX_FMT_YUV420:
+ printf("YUV420\n");
+ break;
+ case V4L2_PIX_FMT_YUYV:
+ printf("YUYV\n");
+ break;
+ case V4L2_PIX_FMT_UYVY:
+ printf("UYVY\n");
+ break;
+ default:
+ printf("TODO: Implement support for V4L2_PIX_FMT 0x%X\n",
+ format);
+ exit(1);
+ }
+
+}
+
diff --git a/src/video/old/v4l2/capture_v4l2.h b/src/video/old/v4l2/capture_v4l2.h
new file mode 100755
index 0000000000000000000000000000000000000000..13d98d19b805c708f8c3d63a961167dc658a4351
--- /dev/null
+++ b/src/video/old/v4l2/capture_v4l2.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2006-2007 Savoir-Faire Linux inc.
+ * Author: Emmanuel Milou <emmanuel.milou@savoirfairelinux.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ **/
+
+#ifndef CAPTURE_V4L2_H
+#define CAPTURE_V4L2_H
+
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/videodev.h>
+
+/*********************************
+ * struct camera_v4l2
+ */
+
+ typedef struct {
+ char* device; //device name (/dev/video0 for the webcam)
+ struct v4l2_capability cap; //info on the device's capture capability (ex: type, name, ...)
+ struct v4l2_format format; //to handle multimedia data
+ char* raw_data; //buffer for the captured data
+ int addr; //file descriptor of the device
+ char* img_data;
+ int width;
+ int height;
+}camera_v4l2;
+
+/***********************************
+
+/***********************************
+ * Methods
+ */
+
+// initialization of a new camera_v4l2 struct
+camera_v4l2* v4l2_init_camera( char* device_name );
+
+// grab frames
+char* v4l2_grab_data(camera_v4l2* const camera);
+
+//free the allocated buffers
+void v4l2_free_data(camera_v4l2* camera);
+
+void info_device(camera_v4l2* camera);
+
+#endif
diff --git a/src/video/video.doxyfile b/src/video/video.doxyfile
new file mode 100644
index 0000000000000000000000000000000000000000..588c88f92a5e082075fec558e91eb09923c7084b
--- /dev/null
+++ b/src/video/video.doxyfile
@@ -0,0 +1,1294 @@
+# Doxyfile 1.5.3
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project
+#
+# All text after a hash (#) is considered a comment and will be ignored
+# The format is:
+# TAG = value [value, ...]
+# For lists items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (" ")
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the config file that
+# follow. The default is UTF-8 which is also the encoding used for all text before
+# the first occurrence of this tag. Doxygen uses libiconv (or the iconv built into
+# libc) for the transcoding. See http://www.gnu.org/software/libiconv for the list of
+# possible encodings.
+
+DOXYFILE_ENCODING = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
+# by quotes) that should identify the project.
+
+PROJECT_NAME = Video Package
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number.
+# This could be handy for archiving the generated documentation or
+# if some version control system is used.
+
+PROJECT_NUMBER = 1.0
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
+# base path where the generated documentation will be put.
+# If a relative path is entered, it will be relative to the location
+# where doxygen was started. If left blank the current directory will be used.
+
+OUTPUT_DIRECTORY = Doc
+
+# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
+# 4096 sub-directories (in 2 levels) under the output directory of each output
+# format and will distribute the generated files over these directories.
+# Enabling this option can be useful when feeding doxygen a huge amount of
+# source files, where putting all generated files in the same directory would
+# otherwise cause performance problems for the file system.
+
+CREATE_SUBDIRS = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# The default language is English, other supported languages are:
+# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
+# Croatian, Czech, Danish, Dutch, Finnish, French, German, Greek, Hungarian,
+# Italian, Japanese, Japanese-en (Japanese with English messages), Korean,
+# Korean-en, Lithuanian, Norwegian, Polish, Portuguese, Romanian, Russian,
+# Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.
+
+OUTPUT_LANGUAGE = English
+
+# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
+# include brief member descriptions after the members that are listed in
+# the file and class documentation (similar to JavaDoc).
+# Set to NO to disable this.
+
+BRIEF_MEMBER_DESC = YES
+
+# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
+# the brief description of a member or function before the detailed description.
+# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+
+REPEAT_BRIEF = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator
+# that is used to form the text in various listings. Each string
+# in this list, if found as the leading text of the brief description, will be
+# stripped from the text and the result after processing the whole list, is
+# used as the annotated text. Otherwise, the brief description is used as-is.
+# If left blank, the following values are used ("$name" is automatically
+# replaced with the name of the entity): "The $name class" "The $name widget"
+# "The $name file" "is" "provides" "specifies" "contains"
+# "represents" "a" "an" "the"
+
+ABBREVIATE_BRIEF =
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# Doxygen will generate a detailed section even if there is only a brief
+# description.
+
+ALWAYS_DETAILED_SEC = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+
+INLINE_INHERITED_MEMB = NO
+
+# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
+# path before files name in the file list and in the header files. If set
+# to NO the shortest path that makes the file name unique will be used.
+
+FULL_PATH_NAMES = YES
+
+# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
+# can be used to strip a user-defined part of the path. Stripping is
+# only done if one of the specified strings matches the left-hand part of
+# the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the
+# path to strip.
+
+STRIP_FROM_PATH =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
+# the path mentioned in the documentation of a class, which tells
+# the reader which header file to include in order to use a class.
+# If left blank only the name of the header file containing the class
+# definition is used. Otherwise one should specify the include paths that
+# are normally passed to the compiler using the -I flag.
+
+STRIP_FROM_INC_PATH =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
+# (but less readable) file names. This can be useful is your file systems
+# doesn't support long names like on DOS, Mac, or CD-ROM.
+
+SHORT_NAMES = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
+# will interpret the first line (until the first dot) of a JavaDoc-style
+# comment as the brief description. If set to NO, the JavaDoc
+# comments will behave just like regular Qt-style comments
+# (thus requiring an explicit @brief command for a brief description.)
+
+JAVADOC_AUTOBRIEF = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then Doxygen will
+# interpret the first line (until the first dot) of a Qt-style
+# comment as the brief description. If set to NO, the comments
+# will behave just like regular Qt-style comments (thus requiring
+# an explicit \brief command for a brief description.)
+
+QT_AUTOBRIEF = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
+# treat a multi-line C++ special comment block (i.e. a block of //! or ///
+# comments) as a brief description. This used to be the default behaviour.
+# The new default is to treat a multi-line C++ comment block as a detailed
+# description. Set this tag to YES if you prefer the old behaviour instead.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member
+# documentation.
+
+DETAILS_AT_TOP = NO
+
+# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
+# member inherits the documentation from any documented member that it
+# re-implements.
+
+INHERIT_DOCS = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
+# a new page for each member. If set to NO, the documentation of a member will
+# be part of the file/class/namespace that contains it.
+
+SEPARATE_MEMBER_PAGES = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab.
+# Doxygen uses this value to replace tabs by spaces in code fragments.
+
+TAB_SIZE = 8
+
+# This tag can be used to specify a number of aliases that acts
+# as commands in the documentation. An alias has the form "name=value".
+# For example adding "sideeffect=\par Side Effects:\n" will allow you to
+# put the command \sideeffect (or @sideeffect) in the documentation, which
+# will result in a user-defined paragraph with heading "Side Effects:".
+# You can put \n's in the value part of an alias to insert newlines.
+
+ALIASES =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
+# sources only. Doxygen will then generate output that is more tailored for C.
+# For instance, some of the names that are used will be different. The list
+# of all members will be omitted, etc.
+
+OPTIMIZE_OUTPUT_FOR_C = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
+# sources only. Doxygen will then generate output that is more tailored for Java.
+# For instance, namespaces will be presented as packages, qualified scopes
+# will look different, etc.
+
+OPTIMIZE_OUTPUT_JAVA = NO
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want to
+# include (a tag file for) the STL sources as input, then you should
+# set this tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
+# func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+
+BUILTIN_STL_SUPPORT = YES
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+
+CPP_CLI_SUPPORT = NO
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES, then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+
+DISTRIBUTE_GROUP_DOC = NO
+
+# Set the SUBGROUPING tag to YES (the default) to allow class member groups of
+# the same type (for instance a group of public functions) to be put as a
+# subgroup of that type (e.g. under the Public Functions section). Set it to
+# NO to prevent subgrouping. Alternatively, this can be done per class using
+# the \nosubgrouping command.
+
+SUBGROUPING = YES
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
+# documentation are documented, even if no documentation was available.
+# Private class members and static file members will be hidden unless
+# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
+
+EXTRACT_ALL = YES
+
+# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
+# will be included in the documentation.
+
+EXTRACT_PRIVATE = YES
+
+# If the EXTRACT_STATIC tag is set to YES all static members of a file
+# will be included in the documentation.
+
+EXTRACT_STATIC = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
+# defined locally in source files will be included in the documentation.
+# If set to NO only classes defined in header files are included.
+
+EXTRACT_LOCAL_CLASSES = YES
+
+# This flag is only useful for Objective-C code. When set to YES local
+# methods, which are defined in the implementation section but not in
+# the interface are included in the documentation.
+# If set to NO (the default) only methods in the interface are included.
+
+EXTRACT_LOCAL_METHODS = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be extracted
+# and appear in the documentation as a namespace called 'anonymous_namespace{file}',
+# where file will be replaced with the base name of the file that contains the anonymous
+# namespace. By default anonymous namespace are hidden.
+
+EXTRACT_ANON_NSPACES = NO
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
+# undocumented members of documented classes, files or namespaces.
+# If set to NO (the default) these members will be included in the
+# various overviews, but no documentation section is generated.
+# This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_MEMBERS = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy.
+# If set to NO (the default) these classes will be included in the various
+# overviews. This option has no effect if EXTRACT_ALL is enabled.
+
+HIDE_UNDOC_CLASSES = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
+# friend (class|struct|union) declarations.
+# If set to NO (the default) these declarations will be included in the
+# documentation.
+
+HIDE_FRIEND_COMPOUNDS = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
+# documentation blocks found inside the body of a function.
+# If set to NO (the default) these blocks will be appended to the
+# function's detailed documentation block.
+
+HIDE_IN_BODY_DOCS = NO
+
+# The INTERNAL_DOCS tag determines if documentation
+# that is typed after a \internal command is included. If the tag is set
+# to NO (the default) then the documentation will be excluded.
+# Set it to YES to include the internal documentation.
+
+INTERNAL_DOCS = NO
+
+# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
+# file names in lower-case letters. If set to YES upper-case letters are also
+# allowed. This is useful if you have classes or files whose names only differ
+# in case and if your file system supports case sensitive file names. Windows
+# and Mac users are advised to set this option to NO.
+
+CASE_SENSE_NAMES = NO
+
+# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
+# will show members with their full class and namespace scopes in the
+# documentation. If set to YES the scope will be hidden.
+
+HIDE_SCOPE_NAMES = NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
+# will put a list of the files that are included by a file in the documentation
+# of that file.
+
+SHOW_INCLUDE_FILES = YES
+
+# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
+# is inserted in the documentation for inline members.
+
+INLINE_INFO = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
+# will sort the (detailed) documentation of file and class members
+# alphabetically by member name. If set to NO the members will appear in
+# declaration order.
+
+SORT_MEMBER_DOCS = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
+# brief documentation of file, namespace and class members alphabetically
+# by member name. If set to NO (the default) the members will appear in
+# declaration order.
+
+SORT_BRIEF_DOCS = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
+# sorted by fully-qualified names, including namespaces. If set to
+# NO (the default), the class list will be sorted only by class name,
+# not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the
+# alphabetical list.
+
+SORT_BY_SCOPE_NAME = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or
+# disable (NO) the todo list. This list is created by putting \todo
+# commands in the documentation.
+
+GENERATE_TODOLIST = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or
+# disable (NO) the test list. This list is created by putting \test
+# commands in the documentation.
+
+GENERATE_TESTLIST = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or
+# disable (NO) the bug list. This list is created by putting \bug
+# commands in the documentation.
+
+GENERATE_BUGLIST = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
+# disable (NO) the deprecated list. This list is created by putting
+# \deprecated commands in the documentation.
+
+GENERATE_DEPRECATEDLIST = YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional
+# documentation sections, marked by \if sectionname ... \endif.
+
+ENABLED_SECTIONS =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
+# the initial value of a variable or define consists of for it to appear in
+# the documentation. If the initializer consists of more lines than specified
+# here it will be hidden. Use a value of 0 to hide initializers completely.
+# The appearance of the initializer of individual variables and defines in the
+# documentation can be controlled using \showinitializer or \hideinitializer
+# command in the documentation regardless of this setting.
+
+MAX_INITIALIZER_LINES = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
+# at the bottom of the documentation of classes and structs. If set to YES the
+# list will mention the files that were used to generate the documentation.
+
+SHOW_USED_FILES = NO
+
+# If the sources in your project are distributed over multiple directories
+# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy
+# in the documentation. The default is NO.
+
+SHOW_DIRECTORIES = NO
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from the
+# version control system). Doxygen will invoke the program by executing (via
+# popen()) the command <command> <input-file>, where <command> is the value of
+# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
+# provided by doxygen. Whatever the program writes to standard output
+# is used as the file version. See the manual for examples.
+
+FILE_VERSION_FILTER =
+
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated
+# by doxygen. Possible values are YES and NO. If left blank NO is used.
+
+QUIET = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated by doxygen. Possible values are YES and NO. If left blank
+# NO is used.
+
+WARNINGS = YES
+
+# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
+# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
+# automatically be disabled.
+
+WARN_IF_UNDOCUMENTED = YES
+
+# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some
+# parameters in a documented function, or documenting parameters that
+# don't exist or using markup commands wrongly.
+
+WARN_IF_DOC_ERROR = YES
+
+# This WARN_NO_PARAMDOC option can be abled to get warnings for
+# functions that are documented, but have no documentation for their parameters
+# or return value. If set to NO (the default) doxygen will only warn about
+# wrong or incomplete parameter documentation, but not about the absence of
+# documentation.
+
+WARN_NO_PARAMDOC = NO
+
+# The WARN_FORMAT tag determines the format of the warning messages that
+# doxygen can produce. The string should contain the $file, $line, and $text
+# tags, which will be replaced by the file and line number from which the
+# warning originated and the warning text. Optionally the format may contain
+# $version, which will be replaced by the version of the file (if it could
+# be obtained via FILE_VERSION_FILTER)
+
+WARN_FORMAT = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning
+# and error messages should be written. If left blank the output is written
+# to stderr.
+
+WARN_LOGFILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag can be used to specify the files and/or directories that contain
+# documented source files. You may enter file names like "myfile.cpp" or
+# directories like "/usr/src/myproject". Separate the files or directories
+# with spaces.
+
+INPUT = ./ ./VideoCodecs
+
+# This tag can be used to specify the character encoding of the source files that
+# doxygen parses. Internally doxygen uses the UTF-8 encoding, which is also the default
+# input encoding. Doxygen uses libiconv (or the iconv built into libc) for the transcoding.
+# See http://www.gnu.org/software/libiconv for the list of possible encodings.
+
+INPUT_ENCODING = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank the following patterns are tested:
+# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
+# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
+
+FILE_PATTERNS =
+
+# The RECURSIVE tag can be used to turn specify whether or not subdirectories
+# should be searched for input files as well. Possible values are YES and NO.
+# If left blank NO is used.
+
+RECURSIVE = NO
+
+# The EXCLUDE tag can be used to specify files and/or directories that should
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+
+EXCLUDE = *.cpp
+
+# The EXCLUDE_SYMLINKS tag can be used select whether or not files or
+# directories that are symbolic links (a Unix filesystem feature) are excluded
+# from the input.
+
+EXCLUDE_SYMLINKS = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories. Note that the wildcards are matched
+# against the file with absolute path, so to exclude all test directories
+# for example use the pattern */test/*
+
+EXCLUDE_PATTERNS =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the output.
+# The symbol name can be a fully qualified name, a word, or if the wildcard * is used,
+# a substring. Examples: ANamespace, AClass, AClass::ANamespace, ANamespace::*Test
+
+EXCLUDE_SYMBOLS =
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or
+# directories that contain example code fragments that are included (see
+# the \include command).
+
+EXAMPLE_PATH =
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
+# and *.h) to filter out the source-files in the directories. If left
+# blank all files are included.
+
+EXAMPLE_PATTERNS =
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude
+# commands irrespective of the value of the RECURSIVE tag.
+# Possible values are YES and NO. If left blank NO is used.
+
+EXAMPLE_RECURSIVE = NO
+
+# The IMAGE_PATH tag can be used to specify one or more files or
+# directories that contain image that are included in the documentation (see
+# the \image command).
+
+IMAGE_PATH =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command <filter> <input-file>, where <filter>
+# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
+# input file. Doxygen will then use the output that the filter program writes
+# to standard output. If FILTER_PATTERNS is specified, this tag will be
+# ignored.
+
+INPUT_FILTER =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form:
+# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
+# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER
+# is applied to all files.
+
+FILTER_PATTERNS =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will be used to filter the input files when producing source
+# files to browse (i.e. when SOURCE_BROWSER is set to YES).
+
+FILTER_SOURCE_FILES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will
+# be generated. Documented entities will be cross-referenced with these sources.
+# Note: To get rid of all source code in the generated output, make sure also
+# VERBATIM_HEADERS is set to NO. If you have enabled CALL_GRAPH or CALLER_GRAPH
+# then you must also enable this option. If you don't then doxygen will produce
+# a warning and turn it on anyway
+
+SOURCE_BROWSER = YES
+
+# Setting the INLINE_SOURCES tag to YES will include the body
+# of functions and classes directly in the documentation.
+
+INLINE_SOURCES = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
+# doxygen to hide any special comment blocks from generated source code
+# fragments. Normal C and C++ comments will always remain visible.
+
+STRIP_CODE_COMMENTS = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES (the default)
+# then for each documented function all documented
+# functions referencing it will be listed.
+
+REFERENCED_BY_RELATION = YES
+
+# If the REFERENCES_RELATION tag is set to YES (the default)
+# then for each documented function all documented entities
+# called/used by that function will be listed.
+
+REFERENCES_RELATION = YES
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
+# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
+# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
+# link to the source code. Otherwise they will link to the documentstion.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code
+# will point to the HTML generated by the htags(1) tool instead of doxygen
+# built-in source browser. The htags tool is part of GNU's global source
+# tagging system (see http://www.gnu.org/software/global/global.html). You
+# will need version 4.8.6 or higher.
+
+USE_HTAGS = NO
+
+# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
+# will generate a verbatim copy of the header file for each class for
+# which an include is specified. Set to NO to disable this.
+
+VERBATIM_HEADERS = YES
+
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
+# of all compounds will be generated. Enable this if the project
+# contains a lot of classes, structs, unions or interfaces.
+
+ALPHABETICAL_INDEX = NO
+
+# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
+# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
+# in which this list will be split (can be a number in the range [1..20])
+
+COLS_IN_ALPHA_INDEX = 5
+
+# In case all classes in a project start with a common prefix, all
+# classes will be put under the same header in the alphabetical index.
+# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
+# should be ignored while generating the index headers.
+
+IGNORE_PREFIX =
+
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
+# generate HTML output.
+
+GENERATE_HTML = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `html' will be used as the default path.
+
+HTML_OUTPUT = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
+# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
+# doxygen will generate files with .html extension.
+
+HTML_FILE_EXTENSION = .html
+
+# The HTML_HEADER tag can be used to specify a personal HTML header for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard header.
+
+HTML_HEADER =
+
+# The HTML_FOOTER tag can be used to specify a personal HTML footer for
+# each generated HTML page. If it is left blank doxygen will generate a
+# standard footer.
+
+HTML_FOOTER =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
+# style sheet that is used by each HTML page. It can be used to
+# fine-tune the look of the HTML output. If the tag is left blank doxygen
+# will generate a default style sheet. Note that doxygen will try to copy
+# the style sheet file to the HTML output directory, so don't put your own
+# stylesheet in the HTML output directory as well, or it will be erased!
+
+HTML_STYLESHEET =
+
+# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
+# files or namespaces will be aligned in HTML using tables. If set to
+# NO a bullet list will be used.
+
+HTML_ALIGN_MEMBERS = YES
+
+# If the GENERATE_HTMLHELP tag is set to YES, additional index files
+# will be generated that can be used as input for tools like the
+# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
+# of the generated HTML documentation.
+
+GENERATE_HTMLHELP = NO
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded. For this to work a browser that supports
+# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox
+# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari).
+
+HTML_DYNAMIC_SECTIONS = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
+# be used to specify the file name of the resulting .chm file. You
+# can add a path in front of the file if the result should not be
+# written to the html output directory.
+
+CHM_FILE =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
+# be used to specify the location (absolute path including file name) of
+# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
+# the HTML help compiler on the generated index.hhp.
+
+HHC_LOCATION =
+
+# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
+# controls if a separate .chi index file is generated (YES) or that
+# it should be included in the master .chm file (NO).
+
+GENERATE_CHI = NO
+
+# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
+# controls whether a binary table of contents is generated (YES) or a
+# normal table of contents (NO) in the .chm file.
+
+BINARY_TOC = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members
+# to the contents of the HTML help documentation and to the tree view.
+
+TOC_EXPAND = NO
+
+# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
+# top of each HTML page. The value NO (the default) enables the index and
+# the value YES disables it.
+
+DISABLE_INDEX = NO
+
+# This tag can be used to set the number of enum values (range [1..20])
+# that doxygen will group on one line in the generated HTML documentation.
+
+ENUM_VALUES_PER_LINE = 4
+
+# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
+# generated containing a tree-like index structure (just like the one that
+# is generated for HTML Help). For this to work a browser that supports
+# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
+# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
+# probably better off using the HTML help feature.
+
+GENERATE_TREEVIEW = YES
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
+# used to set the initial width (in pixels) of the frame in which the tree
+# is shown.
+
+TREEVIEW_WIDTH = 250
+
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
+# generate Latex output.
+
+GENERATE_LATEX = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `latex' will be used as the default path.
+
+LATEX_OUTPUT = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked. If left blank `latex' will be used as the default command name.
+
+LATEX_CMD_NAME = latex
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
+# generate index for LaTeX. If left blank `makeindex' will be used as the
+# default command name.
+
+MAKEINDEX_CMD_NAME = makeindex
+
+# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
+# LaTeX documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_LATEX = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used
+# by the printer. Possible values are: a4, a4wide, letter, legal and
+# executive. If left blank a4wide will be used.
+
+PAPER_TYPE = a4wide
+
+# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
+# packages that should be included in the LaTeX output.
+
+EXTRA_PACKAGES =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
+# the generated latex document. The header should contain everything until
+# the first chapter. If it is left blank doxygen will generate a
+# standard header. Notice: only use this tag if you know what you are doing!
+
+LATEX_HEADER =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
+# is prepared for conversion to pdf (using ps2pdf). The pdf file will
+# contain links (just like the HTML output) instead of page references
+# This makes the output suitable for online browsing using a pdf viewer.
+
+PDF_HYPERLINKS = NO
+
+# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
+# plain latex in the generated Makefile. Set this option to YES to get a
+# higher quality PDF documentation.
+
+USE_PDFLATEX = NO
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
+# command to the generated LaTeX files. This will instruct LaTeX to keep
+# running if errors occur, instead of asking the user for help.
+# This option is also used when generating formulas in HTML.
+
+LATEX_BATCHMODE = NO
+
+# If LATEX_HIDE_INDICES is set to YES then doxygen will not
+# include the index chapters (such as File Index, Compound Index, etc.)
+# in the output.
+
+LATEX_HIDE_INDICES = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
+# The RTF output is optimized for Word 97 and may not look very pretty with
+# other RTF readers or editors.
+
+GENERATE_RTF = YES
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `rtf' will be used as the default path.
+
+RTF_OUTPUT = rtf
+
+# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
+# RTF documents. This may be useful for small projects and may help to
+# save some trees in general.
+
+COMPACT_RTF = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
+# will contain hyperlink fields. The RTF file will
+# contain links (just like the HTML output) instead of page references.
+# This makes the output suitable for online browsing using WORD or other
+# programs which support those fields.
+# Note: wordpad (write) and others do not support links.
+
+RTF_HYPERLINKS = YES
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# config file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+
+RTF_STYLESHEET_FILE =
+
+# Set optional variables used in the generation of an rtf document.
+# Syntax is similar to doxygen's config file.
+
+RTF_EXTENSIONS_FILE =
+
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
+# generate man pages
+
+GENERATE_MAN = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `man' will be used as the default path.
+
+MAN_OUTPUT = man
+
+# The MAN_EXTENSION tag determines the extension that is added to
+# the generated man pages (default is the subroutine's section .3)
+
+MAN_EXTENSION = .3
+
+# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
+# then it will generate one additional man file for each entity
+# documented in the real man page(s). These additional files
+# only source the real man page, but without them the man command
+# would be unable to find the correct page. The default is NO.
+
+MAN_LINKS = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES Doxygen will
+# generate an XML file that captures the structure of
+# the code including all documentation.
+
+GENERATE_XML = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be
+# put in front of it. If left blank `xml' will be used as the default path.
+
+XML_OUTPUT = xml
+
+# The XML_SCHEMA tag can be used to specify an XML schema,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_SCHEMA =
+
+# The XML_DTD tag can be used to specify an XML DTD,
+# which can be used by a validating XML parser to check the
+# syntax of the XML files.
+
+XML_DTD =
+
+# If the XML_PROGRAMLISTING tag is set to YES Doxygen will
+# dump the program listings (including syntax highlighting
+# and cross-referencing information) to the XML output. Note that
+# enabling this will significantly increase the size of the XML output.
+
+XML_PROGRAMLISTING = YES
+
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
+# generate an AutoGen Definitions (see autogen.sf.net) file
+# that captures the structure of the code including all
+# documentation. Note that this feature is still experimental
+# and incomplete at the moment.
+
+GENERATE_AUTOGEN_DEF = NO
+
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES Doxygen will
+# generate a Perl module file that captures the structure of
+# the code including all documentation. Note that this
+# feature is still experimental and incomplete at the
+# moment.
+
+GENERATE_PERLMOD = NO
+
+# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
+# the necessary Makefile rules, Perl scripts and LaTeX code to be able
+# to generate PDF and DVI output from the Perl module output.
+
+PERLMOD_LATEX = NO
+
+# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
+# nicely formatted so it can be parsed by a human reader. This is useful
+# if you want to understand what is going on. On the other hand, if this
+# tag is set to NO the size of the Perl module output will be much smaller
+# and Perl will parse it just the same.
+
+PERLMOD_PRETTY = YES
+
+# The names of the make variables in the generated doxyrules.make file
+# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
+# This is useful so different doxyrules.make files included by the same
+# Makefile don't overwrite each other's variables.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
+# evaluate all C-preprocessor directives found in the sources and include
+# files.
+
+ENABLE_PREPROCESSING = YES
+
+# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
+# names in the source code. If set to NO (the default) only conditional
+# compilation will be performed. Macro expansion can be done in a controlled
+# way by setting EXPAND_ONLY_PREDEF to YES.
+
+MACRO_EXPANSION = NO
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
+# then the macro expansion is limited to the macros specified with the
+# PREDEFINED and EXPAND_AS_DEFINED tags.
+
+EXPAND_ONLY_PREDEF = NO
+
+# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
+# in the INCLUDE_PATH (see below) will be search if a #include is found.
+
+SEARCH_INCLUDES = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by
+# the preprocessor.
+
+INCLUDE_PATH =
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will
+# be used.
+
+INCLUDE_FILE_PATTERNS =
+
+# The PREDEFINED tag can be used to specify one or more macro names that
+# are defined before the preprocessor is started (similar to the -D option of
+# gcc). The argument of the tag is a list of macros of the form: name
+# or name=definition (no spaces). If the definition and the = are
+# omitted =1 is assumed. To prevent a macro definition from being
+# undefined via #undef or recursively expanded use the := operator
+# instead of the = operator.
+
+PREDEFINED =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
+# this tag can be used to specify a list of macro names that should be expanded.
+# The macro definition that is found in the sources will be used.
+# Use the PREDEFINED tag if you want to use a different macro definition.
+
+EXPAND_AS_DEFINED =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
+# doxygen's preprocessor will remove all function-like macros that are alone
+# on a line, have an all uppercase name, and do not end with a semicolon. Such
+# function macros are typically used for boiler-plate code, and will confuse
+# the parser if not removed.
+
+SKIP_FUNCTION_MACROS = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES option can be used to specify one or more tagfiles.
+# Optionally an initial location of the external documentation
+# can be added for each tagfile. The format of a tag file without
+# this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where "loc1" and "loc2" can be relative or absolute paths or
+# URLs. If a location is present for each tag, the installdox tool
+# does not have to be run to correct the links.
+# Note that each tag file must have a unique name
+# (where the name does NOT include the path)
+# If a tag file is not located in the directory in which doxygen
+# is run, you must also specify the path to the tagfile here.
+
+TAGFILES =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create
+# a tag file that is based on the input files it reads.
+
+GENERATE_TAGFILE =
+
+# If the ALLEXTERNALS tag is set to YES all external classes will be listed
+# in the class index. If set to NO only the inherited external classes
+# will be listed.
+
+ALLEXTERNALS = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will
+# be listed.
+
+EXTERNAL_GROUPS = YES
+
+# The PERL_PATH should be the absolute path and name of the perl script
+# interpreter (i.e. the result of `which perl').
+
+PERL_PATH = /usr/bin/perl
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
+# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# or super classes. Setting the tag to NO turns the diagrams off. Note that
+# this option is superseded by the HAVE_DOT option below. This is only a
+# fallback. It is recommended to install and use dot, since it yields more
+# powerful graphs.
+
+CLASS_DIAGRAMS = YES
+
+# You can define message sequence charts within doxygen comments using the \msc
+# command. Doxygen will then run the mscgen tool (see http://www.mcternan.me.uk/mscgen/) to
+# produce the chart and insert it in the documentation. The MSCGEN_PATH tag allows you to
+# specify the directory where the mscgen tool resides. If left empty the tool is assumed to
+# be found in the default search path.
+
+MSCGEN_PATH =
+
+# If set to YES, the inheritance and collaboration graphs will hide
+# inheritance and usage relations if the target is undocumented
+# or is not a class.
+
+HIDE_UNDOC_RELATIONS = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz, a graph visualization
+# toolkit from AT&T and Lucent Bell Labs. The other options in this section
+# have no effect if this option is set to NO (the default)
+
+HAVE_DOT = NO
+
+# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect inheritance relations. Setting this tag to YES will force the
+# the CLASS_DIAGRAMS tag to NO.
+
+CLASS_GRAPH = YES
+
+# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for each documented class showing the direct and
+# indirect implementation dependencies (inheritance, containment, and
+# class references variables) of the class with other documented classes.
+
+COLLABORATION_GRAPH = YES
+
+# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
+# will generate a graph for groups, showing the direct groups dependencies
+
+GROUP_GRAPHS = YES
+
+# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+
+UML_LOOK = YES
+
+# If set to YES, the inheritance and collaboration graphs will show the
+# relations between templates and their instances.
+
+TEMPLATE_RELATIONS = NO
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
+# tags are set to YES then doxygen will generate a graph for each documented
+# file showing the direct and indirect include dependencies of the file with
+# other documented files.
+
+INCLUDE_GRAPH = YES
+
+# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
+# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
+# documented header file showing the documented files that directly or
+# indirectly include this file.
+
+INCLUDED_BY_GRAPH = YES
+
+# If the CALL_GRAPH, SOURCE_BROWSER and HAVE_DOT tags are set to YES then doxygen will
+# generate a call dependency graph for every global function or class method.
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command.
+
+CALL_GRAPH = NO
+
+# If the CALLER_GRAPH, SOURCE_BROWSER and HAVE_DOT tags are set to YES then doxygen will
+# generate a caller dependency graph for every global function or class method.
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command.
+
+CALLER_GRAPH = NO
+
+# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
+# will graphical hierarchy of all classes instead of a textual one.
+
+GRAPHICAL_HIERARCHY = YES
+
+# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES
+# then doxygen will show the dependencies a directory has on other directories
+# in a graphical way. The dependency relations are determined by the #include
+# relations between the files in the directories.
+
+DIRECTORY_GRAPH = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. Possible values are png, jpg, or gif
+# If left blank png will be used.
+
+DOT_IMAGE_FORMAT = png
+
+# The tag DOT_PATH can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+
+DOT_PATH =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the
+# \dotfile command).
+
+DOTFILE_DIRS =
+
+# The MAX_DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
+# nodes that will be shown in the graph. If the number of nodes in a graph
+# becomes larger than this value, doxygen will truncate the graph, which is
+# visualized by representing a node as a red box. Note that doxygen if the number
+# of direct children of the root node in a graph is already larger than
+# MAX_DOT_GRAPH_NOTES then the graph will not be shown at all. Also note
+# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+
+DOT_GRAPH_MAX_NODES = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
+# graphs generated by dot. A depth value of 3 means that only nodes reachable
+# from the root by following a path via at most 3 edges will be shown. Nodes
+# that lay further from the root node will be omitted. Note that setting this
+# option to 1 or 2 may greatly reduce the computation time needed for large
+# code bases. Also note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+
+MAX_DOT_GRAPH_DEPTH = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, which results in a white background.
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+
+DOT_TRANSPARENT = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10)
+# support this, this feature is disabled by default.
+
+DOT_MULTI_TARGETS = NO
+
+# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
+# generate a legend page explaining the meaning of the various boxes and
+# arrows in the dot generated graphs.
+
+GENERATE_LEGEND = YES
+
+# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
+# remove the intermediate dot files that are used to generate
+# the various graphs.
+
+DOT_CLEANUP = YES
+
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine
+#---------------------------------------------------------------------------
+
+# The SEARCHENGINE tag specifies whether or not a search engine should be
+# used. If set to NO the values of all tags below this one will be ignored.
+
+SEARCHENGINE = NO