premier dump ffmpeg

+Built against ffmpeg v0.8.7

+# Project modified by ARCS1to2
+
+unix:  TEMPLATE = lib
+win32: TEMPLATE = vclib
+
+
+TARGET = arcsffmpeg
+
+HEADERS = videoencoder.h
+HEADERS+= ffmpeglib.h
+HEADERS+= videodecoder.h
+HEADERS+= samplefilter.h
+HEADERS+= videofilter.h
+HEADERS+= logofilter.h
+HEADERS+= flipvertfilter.h
+HEADERS+= textscreenfilter.h
+HEADERS+= videoviewer.h
+HEADERS+= videoglviewer.h
+
+SOURCES = videoencoder.cpp
+SOURCES+= ffmpeglib.cpp
+SOURCES+= videodecoder.cpp
+SOURCES+= samplefilter.cpp
+SOURCES+= videofilter.cpp
+SOURCES+= logofilter.cpp
+SOURCES+= flipvertfilter.cpp
+SOURCES+= textscreenfilter.cpp
+SOURCES+= videoviewer.cpp
+SOURCES+= videoglviewer.cpp
+SOURCES+= 
+
+MOC_DIR = ./moc
+OBJECTS_DIR = ./obj
+
+CONFIG += qt thread release opengl
+
+unix {
+LIBS += -lavformat -lavcodec -lavutil
+}
+
+win32 {
+INCLUDEPATH+=$$(ARCSDIR)/include
+LIBS += -L$$(ARCSDIR)/lib -lavformat -lavcodec -lavutil -lswscale -lavdevice
+CONFIG += dll exceptions
+DEFINES += _CRT_SECURE_NO_DEPRECATE
+}
+
+
+win32: DLLDESTDIR = ../libs
+unix: QMAKE_POST_LINK=mv *.so* ../libs
+#The following line was inserted by qt3to4
+QT +=  opengl qt3support 
+
+
+ALXFILE = libffmpeg.alx
+OTHER_FILES += libffmpeg.alx
+arcslibrary.output = alm_${QMAKE_FILE_BASE}.cpp
+arcslibrary.input = ALXFILE
+arcslibrary.commands = arcslibmaker ${QMAKE_FILE_NAME}
+arcslibrary.variable_out = SOURCES
+QMAKE_EXTRA_COMPILERS += arcslibrary
+INCLUDEPATH += $$(ARCSDIR)/include
+LIBS += -L$$(ARCSDIR)/lib -larcs
+ CONFIG += dll

+#include "ffmpeglib.h"
+
+bool FFMPegLib::initialized = false;

+#ifndef __FFMPEGLIB_H__
+#define __FFMPEGLIB_H__
+
+// this is for ffmpeg v 0.10.2
+
+#include <libavformat/avformat.h>
+#include <libavcodec/avcodec.h>
+#include <libavfilter/avfilter.h>
+
+class FFMPegLib
+{
+public:
+static void init()
+{
+	if (!initialized)
+    {
+        av_codec_register_all();
+		av_register_all();
+        avfilter_register_all();
+    }
+	initialized = true;
+}
+
+private :
+static bool initialized;
+
+};
+
+#endif

+#include "flipvertfilter.h"
+
+void FlipVertFilter::applyFilter()
+{
+     for (int j=0; j < getHeight(); j++)
+     {
+	  for (int i=0; i < getWidth(); i++)
+	  {
+	       imgOut(i,getHeight()-j-1,R, imgIn(i,j,R));
+	       imgOut(i,getHeight()-j-1,G, imgIn(i,j,G));
+	       imgOut(i,getHeight()-j-1,B, imgIn(i,j,B));
+	  }
+     }
+}

+#ifndef __FLIPVERTFILTER_H__
+#define __FLIPVERTFILTER_H__
+
+#include "videofilter.h"
+
+/*! \brief Vertical Flip VideoFilter class.
+ *
+ * This filter flips vertically any image.
+ * \author Jean-Yves Didier
+ * \date November, the 24th, 2007
+ * \ingroup video
+ */
+
+
+
+
+class FlipVertFilter : public VideoFilter
+{
+Q_OBJECT
+     public:
+FlipVertFilter(QObject* parent=0) : VideoFilter(parent) {} //<!ARCS Constructor
+
+protected:
+void applyFilter();
+
+};
+
+
+
+
+
+#endif //__FLIPVERTFILTER_H__

+<library>
+    <headers>
+        <header name="videoencoder.h"/>
+        <header name="videodecoder.h"/>
+        <header name="samplefilter.h"/>
+        <header name="logofilter.h"/>
+        <header name="textscreenfilter.h"/>
+        <header name="videoviewer.h"/>
+        <header name="videoglviewer.h"/>
+        <header name="flipvertfilter.h"/>
+    </headers>
+    <components>
+        <component name="VideoEncoder"/>
+        <component name="VideoDecoder"/>
+        <component name="VideoViewer"/>
+        <component name="VideoGLViewer"/>
+        <component name="SampleFilter"/>
+        <component name="LogoFilter"/>
+        <component name="FlipVertFilter"/>
+        <component name="TextScreenFilter"/>
+    </components>
+</library>

+<library>
+    <headers>
+        <header name="videoencoder.h"/>
+        <header name="videodecoder.h"/>
+        <header name="samplefilter.h"/>
+        <header name="logofilter.h"/>
+        <header name="textscreenfilter.h"/>
+        <header name="videoviewer.h"/>
+        <header name="videoglviewer.h"/>
+        <header name="flipvertfilter.h"/>
+    </headers>
+    <components>
+        <component name="VideoEncoder"/>
+        <component name="VideoDecoder"/>
+        <component name="VideoViewer"/>
+        <component name="VideoGLViewer"/>
+        <component name="SampleFilter"/>
+        <component name="LogoFilter"/>
+        <component name="FlipVertFilter"/>
+        <component name="TextScreenFilter"/>
+    </components>
+</library>

+<application>
+    <libraries>
+        <library name="../libs/libcommon.so" />
+        <library name="../libs/libarcsffmpeg.so" />
+    </libraries>
+    <objects>
+        <object classname="TokenTrigger" persistent="true" id="tt" />
+        <object classname="VideoEncoder" persistent="true" id="ve" />
+        <object classname="LogoFilter" persistent="true" id="sf" />
+        <object classname="VideoDecoder" persistent="true" id="vd" />
+    </objects>
+    <sheets>
+        <sheet id="end" />
+        <sheet id="start" >
+            <preconnection>
+                <init value="sample.avi" type="string" slot="setFile(QString)" object="vd" />
+		<init value="test.avi" type="string" slot="setFile(QString)" object="ve" />
+		<init value="1400000" type="int" slot="setFramerate(int)" object="ve" />
+		<init value="100" type="int" slot="setXOffset(int)" object="sf"/>
+		<init value="100" type="int" slot="setYOffset(int)" object="sf"/>
+		<init value="lsc.png" type="string" slot="setImage(QString)" object="sf" />
+                <init value="end" type="string" slot="setToken(QString)" object="tt" />
+            </preconnection>
+            <connection>
+                <wire objsource="vd" objdest="sf" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="sf" objdest="ve" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="vd" objdest="ve" signal="sendHeight(int)" slot="setHeight(int)" />
+		<wire objsource="vd" objdest="ve" signal="sendWidth(int)" slot="setWidth(int)" />
+		<wire objsource="vd" objdest="ve" signal="sendFramerate(float)" slot="setFramerate(float)"/>
+                <wire objsource="vd" objdest="ve" signal="finished()" slot="close()" />
+                <wire objsource="vd" objdest="tt" signal="finished()" slot="tic()" />
+            </connection>
+            <postconnection>
+                <init value="" type="void" slot="initDecoder()" object="vd" />
+                <init value="" type="void" slot="initEncoder()" object="ve" />
+                <init value="" type="void" slot="start()" object="vd" />
+            </postconnection>
+            <tokensender object="tt" />
+        </sheet>
+    </sheets>
+    <statemachine terminal="end" initial="start" >
+        <transition token="end" stepA="start" stepB="end" />
+    </statemachine>
+</application>

+#include "logofilter.h"
+
+
+void LogoFilter::applyFilter()
+{
+     if (img.isNull())
+	  return ;
+
+     duplicateImage();
+
+
+     for (int i=0; i < img.width(); i++)
+     {
+	  for (int j=0; j< img.height() ; j++)
+	  {
+	       if (safeIndex(xoffset()+i,yoffset()+j))
+	       {
+		    uchar* col = img.scanLine(j)+(i*4);
+		    uchar alpha = *(col+3);
+		    float r = ((float)alpha * (float)(*(col+2)) + (255.0-(float)alpha)*(unsigned char)imgIn(xoffset()+i,yoffset()+j,R))/256.0;
+		    float g = ((float)alpha * (float)(*(col+1)) + (255.0-(float)alpha)*(unsigned char)imgIn(xoffset()+i,yoffset()+j,G))/256.0;
+		    float b = ((float)alpha * (float)(*(col)) + (255.0-(float)alpha)*(unsigned char)imgIn(xoffset()+i,yoffset()+j,B))/256.0;
+
+		    imgOut(xoffset()+i, yoffset()+j, R, (int)r);
+		    imgOut(xoffset()+i, yoffset()+j, G, (int)g);
+		    imgOut(xoffset()+i, yoffset()+j, B, (int)b);
+	       }
+	  }
+     }
+}
+
+

+#ifndef __LOGOFILTER_H__
+#define __LOGOFILTER_H__
+
+#include "videofilter.h"
+#include <QImage>
+
+/*! \brief A VideoFilter that could be used to display images in video.
+ *
+ * This filter is usefull to insert logos in videos for example.
+ * If the selected image has an alpha channel, then the image would be blended
+ * with the video stream.
+ * \author Jean-Yves Didier
+ * \date September, the 21st, 2006
+ * \ingroup video
+ */
+class LogoFilter: public VideoFilter
+{
+Q_OBJECT
+Q_PROPERTY(int xoffset READ xoffset WRITE setXOffset )
+Q_PROPERTY(int yoffset READ yoffset WRITE setYOffset )
+Q_PROPERTY(QImage image READ image WRITE setImage )
+Q_CLASSINFO( "xoffset", "X Offset for placing logo")
+Q_CLASSINFO( "yoffset", "Y Offset for placing logo")
+Q_CLASSINFO( "image" , "Image to display on top of video")
+Q_CLASSINFO( "author" , "Jean-Yves Didier")
+Q_CLASSINFO( "description", "This filter inserts an image inside a video")
+
+public:
+LogoFilter(QObject* parent=0) : VideoFilter(parent) { setXOffset(0); setYOffset(0);} //!< ARCS Constructor
+int xoffset() const {return xoff;} //!< Returns the x-offset of the displayed logo relative to the coordinates of image.
+int yoffset() const {return yoff;} //!< Returnss the y-offset of the displayed logo relative to the coordinates of image.
+QImage image() const { return img; } //!< Returns the logo to display over video stream.
+
+
+public slots:
+/*! \brief Sets the image that will be displayed over the video stream.
+ * \param s Image file name
+ */
+     void setImageFile(QString s) { img = QImage(s); if (img.depth() < 32) img = img.convertDepth(32); }
+
+/*! \brief Sets the image that will be displayed over the video stream.
+ * \param i Image in a QImage format.
+ */
+void setImage(QImage i) { img = i; }
+void applyFilter();
+void setXOffset(int i) { xoff=i; } //!< Sets the x-offset of the displayed logo relative to the coordinates of image.
+void setYOffset(int i) { yoff=i; } //!< Sets the y-offset of the displayed logo relative to the coordinates of image.
+
+private:
+QImage img;
+int xoff;
+int yoff;
+};
+
+#endif //__LOGOFILTER_H__

+<application>
+    <libraries>
+        <library name="../libs/libcommon.so" />
+        <library name="../libs/libarcsffmpeg.so" />
+    </libraries>
+    <objects>
+        <object classname="TokenTrigger" persistent="true" id="tt" />
+        <object classname="VideoEncoder" persistent="true" id="ve" />
+        <object classname="SampleFilter" persistent="true" id="sf" />
+        <object classname="VideoDecoder" persistent="true" id="vd" />
+    </objects>
+    <sheets>
+        <sheet id="end" />
+        <sheet id="start" >
+            <preconnection>
+                <init value="sample.avi" type="string" slot="setFile(QString)" object="vd" />
+                <init value="test.avi" type="string" slot="setFile(QString)" object="ve" />
+                <init value="end" type="string" slot="setToken(QString)" object="tt" />
+            </preconnection>
+            <connection>
+                <wire objsource="vd" objdest="sf" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="sf" objdest="ve" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="vd" objdest="ve" signal="sendHeight(int)" slot="setHeight(int)" />
+                <wire objsource="vd" objdest="ve" signal="sendWidth(int)" slot="setWidth(int)" />
+                <wire objsource="vd" objdest="ve" signal="finished()" slot="close()" />
+                <wire objsource="vd" objdest="tt" signal="finished()" slot="tic()" />
+            </connection>
+            <postconnection>
+                <init value="" type="void" slot="initDecoder()" object="vd" />
+                <init value="" type="void" slot="initEncoder()" object="ve" />
+                <init value="" type="void" slot="start()" object="vd" />
+            </postconnection>
+            <tokensender object="tt" />
+        </sheet>
+    </sheets>
+    <statemachine terminal="end" initial="start" >
+        <transition token="end" stepA="start" stepB="end" />
+    </statemachine>
+</application>

+#include "samplefilter.h"
+
+void SampleFilter::applyFilter()
+{
+     for (int j=0; j < getHeight() ; j++)
+     {
+	  for (int i=0; i < getWidth(); i++)
+	  {
+	       int mean = (unsigned char)imgIn(i,j,R) + (unsigned char)imgIn(i,j,G) + (unsigned char)imgIn(i,j,B);
+	       mean =  mean / 3;
+	       imgOut(i,j,R, mean);
+	       imgOut(i,j,G, mean);
+	       imgOut(i,j,B, mean);
+	  }
+     }
+}
+
+

+#ifndef __SAMPLEFILTER_H__
+#define __SAMPLEFILTER_H__
+
+#include "videofilter.h"
+
+/*! \brief Simple VideoFilter class.
+ *
+ * This filter transforms color images in black'n white images by doing the mean of each R, G, B values.
+ * \author Jean-Yves Didier
+ * \date September, the 21st, 2006
+ * \ingroup video
+ */
+
+class SampleFilter : public VideoFilter
+{
+Q_OBJECT
+     public:
+SampleFilter(QObject* parent=0) : VideoFilter(parent) {} //!< ARCS Constructor
+
+protected:
+void applyFilter();
+
+
+};
+
+#endif //__SAMPLEFILTER_H__

+<application>
+    <libraries>
+        <library name="../libs/libcommon.so" />
+        <library name="../libs/libarcsffmpeg.so" />
+    </libraries>
+    <objects>
+        <object classname="TokenTrigger" persistent="true" id="tt" />
+        <object classname="VideoEncoder" persistent="true" id="ve" />
+        <object classname="TextScreenFilter" persistent="true" id="sf" />
+        <object classname="VideoDecoder" persistent="true" id="vd" />
+    </objects>
+    <sheets>
+        <sheet id="end" />
+        <sheet id="start" >
+            <preconnection>
+                <init value="sample.avi" type="string" slot="setFile(QString)" object="vd" />
+		<init value="test.avi" type="string" slot="setFile(QString)" object="ve" />
+		<!--init value="1400000" type="int" slot="setFramerate(int)" object="ve" /-->
+		<!--init value="100" type="int" slot="setXOffset(int)" object="sf"/>
+		<init value="100" type="int" slot="setYOffset(int)" object="sf"/>
+		<init value="lsc.png" type="string" slot="setImage(QString)" object="sf" /-->
+		<init value="Hello\\world !" type="string" slot="setText(QString)" object="sf"/>
+		<init value="25" type="int" slot="setFrameDuration(int)" object="sf"/>
+		<init value="10" type="int" slot="setStartingFrame(int)" object="sf"/>
+                <init value="end" type="string" slot="setToken(QString)" object="tt" />
+            </preconnection>
+	    <connection>
+		<wire objsource="vd" objdest="sf" signal="sendFrameNumber(int)" slot="setNumFrame(int)" />
+                <wire objsource="vd" objdest="sf" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="sf" objdest="ve" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+                <wire objsource="vd" objdest="ve" signal="sendHeight(int)" slot="setHeight(int)" />
+		<wire objsource="vd" objdest="ve" signal="sendWidth(int)" slot="setWidth(int)" />
+		<wire objsource="vd" objdest="ve" signal="sendFramerate(float)" slot="setFramerate(float)"/>
+                <wire objsource="vd" objdest="ve" signal="finished()" slot="close()" />
+                <wire objsource="vd" objdest="tt" signal="finished()" slot="tic()" />
+            </connection>
+            <postconnection>
+                <init value="" type="void" slot="initDecoder()" object="vd" />
+                <init value="" type="void" slot="initEncoder()" object="ve" />
+                <init value="" type="void" slot="start()" object="vd" />
+            </postconnection>
+            <tokensender object="tt" />
+        </sheet>
+    </sheets>
+    <statemachine terminal="end" initial="start" >
+        <transition token="end" stepA="start" stepB="end" />
+    </statemachine>
+</application>

+#include "textscreenfilter.h"
+#include <QPainter>
+#include <QImage>
+//Added by qt3to4:
+#include <QPixmap>
+
+void TextScreenFilter::applyFilter()
+{
+     if (frameNumber() == startingFrame)
+     {
+	  int l;
+	  int h = getHeight();
+
+
+	  fnt.setPointSize(h/lineNumber);
+
+	  while (QFontMetrics(fnt).lineSpacing() > h/lineNumber)
+	       fnt.setPointSize(fnt.pointSize()-1);
+	  
+	  QFontMetrics fmt(fnt);
+	  
+	  int ntimes = text.contains('\\') + 1;
+	  int fontwidth=0;
+	  h = h ;
+
+
+	  QPixmap pic(getWidth(),h);
+	  QPainter p(&pic);
+	  p.setBackgroundColor(bgColor);
+	  p.setFont(fnt);
+	  p.setPen(fgColor);
+	  
+	  if (alignRight)
+	  {
+	       for (l=0; l < ntimes ; l++)
+	       {
+		    QString section = text.section('\\',l,l);
+		    if (fontwidth < fmt.width(section))
+			 fontwidth = fmt.width(section);
+	       }
+	       for (l=0; l < ntimes ; l++)
+		    p.drawText((getWidth()-fontwidth)/2,(lineNumber-ntimes+2*l)*h/(2*lineNumber), text.section('\\',l,l));
+
+	  }
+	  else
+	  {
+	       for (l=0; l < ntimes ; l++)
+	       {
+		    fontwidth = fmt.width(text.section('\\',l,l));
+		    p.drawText((getWidth()-fontwidth)/2,(lineNumber-ntimes+2*l)*h/(2*lineNumber), text.section('\\',l,l));
+	       }
+	  }
+	  p.end();
+
+	  QImage image=pic.convertToImage().convertDepth(32);
+
+	  for (int i=0; i < getWidth(); i++)
+	  {
+	       for (int j=0; j < getHeight() ; j++)
+	       {
+		    imgOut(i,j,R, *((uchar*)image.scanLine(j) + (i*4) + 2));
+		    imgOut(i,j,G, *((uchar*)image.scanLine(j) + (i*4) + 1));
+		    imgOut(i,j,B, *((uchar*)image.scanLine(j) + (i*4) + 0));		    
+	       }
+
+	  }
+	  for (int k=0; k < (frameDuration-1); k++)
+	       emit sendImage(getWidth(),h,getImageOut());
+	  
+     }
+     else
+	  duplicateImage();
+}

+#ifndef __TEXTSCREENFILTER_H__
+#define __TEXTSCREENFILTER_H__
+
+#include "videofilter.h"
+#include <QColor>
+#include <QFont>
+
+
+/*! \brief A VideoFilter designed to display text fillers in videos.
+ *
+ * \author Jean-Yves Didier
+ * \ingroup video
+ * \date September, the 21st, 2006
+ */
+class TextScreenFilter : public VideoFilter
+{
+Q_OBJECT
+Q_CLASSINFO("backgroundColor","Color of the background of the text filler")
+Q_CLASSINFO("foregroundColor","Color of the text filler")
+Q_CLASSINFO("rightAlign", "Tells wether the text is to be aligned on the right or not.")
+Q_CLASSINFO("font", "Sets the appropriate font for the text to display")
+Q_PROPERTY( QColor backgroundColor READ backgroundColor WRITE setBackgroundColor)
+Q_PROPERTY( QColor foregroundColor READ foregroundColor WRITE setForegroundColor)
+Q_PROPERTY( bool rightAlign READ rightAlign WRITE setAlignRight)
+Q_PROPERTY(QFont font READ font WRITE setFont )
+
+public:
+/*! \brief ARCS Constructor
+ */
+TextScreenFilter(QObject* parent=0) : VideoFilter(parent) 
+     { 
+	  startingFrame = 0; frameDuration = 0; lineNumber=25; alignRight=false; 
+	  bgColor = Qt::black;
+	  fgColor = Qt::white;
+	  fnt = QFont("Sans Serif");
+	  fnt.setStyleHint(QFont::SansSerif);
+	  fnt.setWeight(QFont::Black);
+     }
+
+QColor backgroundColor() const { return bgColor; } //!< Gives the background color
+QColor foregroundColor() const { return fgColor; } //!< Gives the text color
+bool rightAlign() const { return alignRight; } //!< \todo change this property name
+QFont font() const { return fnt; } //!< Gives the font of the text
+
+public slots:
+     void setStartingFrame(int n) {startingFrame = n; } //!< Sets the starting frame \todo should be deprecated later
+void setFrameDuration(int n) { frameDuration = n;} //!< Sets the frameduration of text filler
+void setText(QString s) { text = s; } //!< Sets the text to display. Each line must be separated by a '\'.
+void setFont(QFont f) { fnt = f; } //!< Sets the font of the text
+void setLineNumber(int n) { lineNumber = n ;} //!< Sets the number of lines to display.
+void setAlignRight(bool b) { alignRight = b; } //!< \todo to adjust
+void setBackgroundColor(QColor col) { bgColor = col; } //!< Sets the background color
+void setForegroundColor(QColor col) { fgColor = col; } //!< Sets the text color.
+
+protected:
+void applyFilter();
+
+private:
+int startingFrame;
+int frameDuration;
+int lineNumber;
+bool alignRight;
+QString text;
+QColor bgColor;
+QColor fgColor;
+QFont fnt;
+
+};
+
+#endif //__TEXTSCREENFILTER_H__

+#include "videodecoder.h"
+#include <iostream>
+#include "ffmpeglib.h"
+
+VideoDecoder::VideoDecoder(QObject* parent) : QObject(parent)
+{
+     FFMPegLib::init();
+     //av_register_all();
+     threaded = false;
+     started = false;
+     loop = false;
+     
+     buffer = NULL;
+     pFrameRGB = NULL;
+     pFrame = NULL;
+     pCodecCtx =  NULL;
+     pFormatCtx = NULL;
+ #if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+	 img_convert_ctx = NULL;
+#endif
+}
+
+
+VideoDecoder::~VideoDecoder()
+{
+     // Libre les images RGB
+     if (buffer)
+	  free(buffer);
+
+     if (pFrameRGB)
+	  av_free(pFrameRGB);
+
+     // Libre l'image YUV
+     if (pFrame)
+	  av_free(pFrame);
+
+     // Fermeture du codec
+     if (pCodecCtx)
+	  avcodec_close(pCodecCtx);
+
+     // Fermeture du fichier video
+     if (pFormatCtx)
+	  av_close_input_file(pFormatCtx);
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )		
+	 if (img_convert_ctx)
+		 sws_freeContext(img_convert_ctx);
+#endif
+}
+
+
+
+void VideoDecoder::initDecoder()
+{
+    // opens video file
+    if (avformat_open_input(&pFormatCtx, qPrintable(fileName), NULL,NULL) < 0)
+        return ;
+
+    // looks for information (warning: deprecated!)
+    if (av_find_stream_info(pFormatCtx) < 0)
+        return ;
+    // dumps informations on the file
+    av_dump_format(pFormatCtx,0,qPrintable(fileName),0);
+
+    // look for video stream
+    videoStream = av_find_best_stream(pFormatCtx,AVMEDIA_TYPE_VIDEO,-1,-1,&pCodec,0);
+
+    if (videoStream < 0)
+        return;
+
+    //recovers the codec context
+    pCodecCtx = pFormatCtx->streams[videoStream]->codec;
+
+    if (avcodec_open(pCodecCtx,pCodec) < 0)
+        return;
+
+    // look for the correct framerate
+    if(pCodecCtx->time_base.num>1000 && pCodecCtx->time_base.den ==1)
+                  pCodecCtx->time_base.den =1000;
+
+    // allocate video image
+    pFrame=avcodec_alloc_frame();
+
+    // allocate resulting video image
+    pFrameRGB=avcodec_alloc_frame();
+    if(pFrameRGB==NULL)
+        return;
+
+    buffer=(uint8_t*)malloc(sizeof(uint8_t) *
+                avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height));
+
+    // Allocation des parts appropries du buffer pour les images RGB
+    avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,
+           pCodecCtx->width, pCodecCtx->height);
+
+    totalFrames = -1;
+    numFrames = 0;
+
+    std::cout << "[VDec] Succeeded in opening video file." << std::endl;
+
+    if (img_convert_ctx == NULL)
+       img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
+               pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_RGB24,
+               SWS_BICUBIC,NULL, NULL, NULL);
+
+
+
+/*
+    Start of very old code
+    // Ouverture du fichier video
+     if(av_open_input_file(&pFormatCtx, fileName.ascii(), NULL, 0, NULL)!=0)
+	  return; // Erreur d'ouverture
+
+     // Recupration des informations sur les flux
+     if(av_find_stream_info(pFormatCtx)<0)
+	  return; // Impossible de rcuprer les informations
+
+     // Dump des informations concernant le fichier video
+     dump_format(pFormatCtx, 0, fileName, 0);
+
+     // Recherche du premier flux video
+     videoStream=-1;
+     for(int i=0; i<pFormatCtx->nb_streams; i++)
+     {
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+          if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO)
+#else
+	  if(pFormatCtx->streams[i]->codec.codec_type==CODEC_TYPE_VIDEO)
+#endif
+	  {
+	       videoStream=i;
+	       break;
+	  }
+     }
+     if(videoStream==-1)
+	  return; // Pas de flux video trouv
+
+     // Rcupre le pointeur sur un contexte de codec pour la video. 
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+     pCodecCtx=pFormatCtx->streams[videoStream]->codec;
+#else
+     pCodecCtx=&pFormatCtx->streams[videoStream]->codec;
+#endif
+
+     // Trouve le codec associ au fichier video
+     pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
+     if(pCodec==NULL)
+	  return; // Codec introuvable
+
+     // Ouvre le codec
+     if(avcodec_open(pCodecCtx, pCodec)<0)
+	  return; // Imposible d'ouvrir le codec
+
+     // Petit hack pour rcuprer le bon framerate dans le cas o on a quelquechose d'absurde
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+     if(pCodecCtx->time_base.num>1000 && pCodecCtx->time_base.den ==1)
+	               pCodecCtx->time_base.den =1000;
+#else
+     if(pCodecCtx->frame_rate>1000 && pCodecCtx->frame_rate_base==1)
+	  pCodecCtx->frame_rate_base=1000;
+#endif
+
+     // Allocation d'une image video
+     pFrame=avcodec_alloc_frame();
+
+     // Allocation d'une structure pour les images videos
+     pFrameRGB=avcodec_alloc_frame();
+     if(pFrameRGB==NULL)
+	  return;
+
+     // Allocation du buffer ncessaire au stockage des images
+     buffer=(uint8_t*)malloc(sizeof(uint8_t) *
+			     avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height));
+
+     // Allocation des parts appropries du buffer pour les images RGB
+     avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,
+		    pCodecCtx->width, pCodecCtx->height);
+
+     totalFrames = -1;
+     numFrames = 0;
+
+     std::cout << "[VDec] Succeeded in opening video file." << std::endl;
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+	 if (img_convert_ctx == NULL)
+		img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
+				pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, PIX_FMT_RGB24,
+				SWS_BICUBIC,NULL, NULL, NULL);
+#endif
+
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+     emit sendFramerate((float)pCodecCtx->time_base.num/(float)pCodecCtx->time_base.den);
+#else
+     emit sendFramerate((float)pCodecCtx->frame_rate/(float)pCodecCtx->frame_rate_base);
+#endif
+     emit sendWidth(pCodecCtx->width);
+     emit sendHeight(pCodecCtx->height);
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+     emit sendTotalFrames(pFormatCtx->streams[videoStream]->duration*pCodecCtx->time_base.num/pCodecCtx->time_base.den/AV_TIME_BASE);
+#else
+     emit sendTotalFrames(pFormatCtx->streams[videoStream]->duration*pCodecCtx->frame_rate/pCodecCtx->frame_rate_base/AV_TIME_BASE);
+#endif
+*/
+}
+
+
+void VideoDecoder::start()
+{
+     if (buffer == NULL)
+     {
+	  std::cerr << "[VDec] Cannot start video decoding" << std::endl;
+	  return;
+     }
+     
+     started = true;
+     totalFrames = -1;
+
+     if (threaded)
+     {
+	  connect(&timer,SIGNAL(timeout()), this, SLOT(timeTrigger()));
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+	  timer.start(1000 / pCodecCtx->time_base.num);
+#else
+	  timer.start(1000 / pCodecCtx->frame_rate);
+#endif
+     }
+     else
+     {
+	  while(totalFrames == -1)
+	  {
+	       queryImage();
+	  }
+	  std::cerr << "[VDec] End of reading." << std::endl;
+     }         
+}
+
+void VideoDecoder::seekFrame(long n) 
+     {
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+	  long time = n * pCodecCtx->time_base.den * AV_TIME_BASE / pCodecCtx->time_base.num;
+	  if (av_seek_frame(pFormatCtx,videoStream, (int64_t)time,0)>0)
+#else	     
+	  long time = n * pCodecCtx->frame_rate_base * AV_TIME_BASE / pCodecCtx->frame_rate;
+	  if (av_seek_frame(pFormatCtx,videoStream, (int64_t)time)>0)
+#endif
+	  {
+	       numFrames = n - 1;
+	       queryImage();
+	  }
+     }
+
+
+void VideoDecoder::queryImage()
+{
+     int frameFinished;
+     AVPacket        packet;
+     packet.stream_index = ! videoStream ;
+     if (numFrames%10 == 0)
+	  std::cout << "[VDec] reading frame " << numFrames << std::endl;
+
+     while (packet.stream_index != videoStream)
+     {
+	  // Dcodage d'une image du flux vido
+	  if (av_read_frame(pFormatCtx, &packet) < 0)
+	  {
+	       totalFrames = numFrames;
+	       if (loop)
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+		    av_seek_frame(pFormatCtx,videoStream,0,0);
+#else
+		    av_seek_frame(pFormatCtx,videoStream,0);
+#endif
+	       else
+	       {
+		    numFrames = 0;
+		    //totalFrames = -1;
+		    emit finished();
+		    return;
+	       }
+	  }
+     }
+
+     // Vrification du paquet (est ce bien un paquet video ?)
+     //if(packet.stream_index==videoStream)
+     //{
+	  // Dcodage des images video
+	  avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, 
+			       packet.data, packet.size);
+
+	  // Est-ce que l'image video est rcupre ?
+	  if(frameFinished)
+	  {
+	       // Conversion de l'image au format RGB 
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )		
+		  sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
+			  pFrameRGB->data, pFrameRGB->linesize);
+
+#else
+	       img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, 
+			   (AVPicture*)pFrame, pCodecCtx->pix_fmt, pCodecCtx->width, 
+			   pCodecCtx->height);
+#endif
+
+	  }
+	  //}
+
+     // Libre le paquet allou par av_read_frame
+     av_free_packet(&packet);
+     emit sendFrameNumber(numFrames);
+     
+     numFrames++;
+
+     mutex.lock();
+     emit sendImage(pCodecCtx->width, pCodecCtx->height, (char*)pFrameRGB->data[0]);
+     mutex.unlock();
+}
+
+
+void VideoDecoder::timeTrigger()
+{
+     if (!started)
+          return;
+     queryImage();
+}
+
+
+void VideoDecoder::stop()
+{
+     started = false;
+
+     if (buffer == NULL)
+     {
+	  std::cerr << "[VDec] You should start video playing first." << std::endl;
+	  return;
+     }
+
+     if (threaded)
+	  timer.stop();
+
+     numFrames = 0;
+     totalFrames = -1;
+}

+#ifndef __VIDEODECODER_H__
+#define __VIDEODECODER_H__
+
+#include <QObject>
+#include <QTimer>
+#include <QMutex>
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+#include <ffmpeg/swscale.h>
+#endif
+
+
+/*! \defgroup video Video 
+ * \brief A list of video processing tools to decode, filter and encode video.
+ *
+ * This component is based on ffmpeg API. This is a tool to decode video files.
+ * 
+ */ 
+
+
+/*! \brief A video decoder component.
+ *
+ * This component is relying on ffmpeg library to open and decode video files.
+ * First, you will give a filename using setFile() then initialize the decoder
+ * using initDecoder(). Once it is performed, you can either use start() or queryImage().
+ *
+ * \author Jean-Yves Didier
+ * \date September, the 8th, 2006
+ * \ingroup video
+ */
+class VideoDecoder : public QObject
+{
+Q_OBJECT
+     public:
+VideoDecoder(QObject* parent=0); //!< ARCS Constructor
+~VideoDecoder(); //!< ARCS Destructor
+
+public slots:
+     /*! \brief  Sets the video file name to decode.
+      * This is intended for a use as a pre-connection initialization.
+      * It doesn't perform anything by itself. However, it is needed by 
+      * initDecoder().
+      * \param s The video file name.
+      */ 
+     void setFile(QString s) { fileName = s ; }
+/*! \brief Starts the video decoding
+ *
+ * The behaviour of this slot depends on the fact setThreaded() was called or not.
+ * By default, it will decode all the frames, without caring about the framerate of the video.
+ * On the contrary, if setThreaded() was called and <tt>true</tt> passed as a parameter,
+ * The images will be decoded at given times, taking into account framerate.
+ * Anyway, this slot results in multiple calls of queryImage().
+ * If setLoop() was enabled, the video will restart to play from the beginning.
+ */
+void start(); 
+
+void seekFrame(long n); //!< Seeks the n-th frame in the video.
+
+void stop(); //!< Stops the video decoding
+/*! \brief Performs all the initializations needed to decode video.
+ *
+ * When called, this slot triggers several signals with some characteristics of the 
+ * decoded video. It triggers : sendFramerate(), sendWidth(), sendHeight(), sendTotalFrames().
+ */
+void initDecoder();
+/*! \brief Decodes an image from the video stream.
+ *
+ * Once the image is decoded, the next call to this function will decode the next image
+ * in the stream. This slot triggers sendFrameNumber() then sendImage() once per call. 
+ * Once images are not available 
+ * anymore, the will result in a finished() signal.
+ */
+void queryImage();
+/*! \brief Tells wether the image decoding should be threaded or not.
+ * 
+ * \param b Set it to <tt>true</tt> if you want a threaded behaviour, <tt>false</tt> otherwise.
+ * \sa start()
+ */
+void setThreaded(bool b) { threaded = b ;}
+/*! \brief Tells wether the video decoding should be looped or not.
+ * 
+ * \param b Set it to <tt>true</tt> if you want a looped behaviour, <tt>false</tt> otherwise.
+ * \sa start()
+ */
+void setLoop(bool b) { loop = b; }
+
+protected slots:
+     void timeTrigger(); //!< For threading "purpose".
+
+signals:
+/*! \brief Sends a decoded image from the video stream.
+ * 
+ * The image is in RGB24 format.
+ * \param w width of the image,
+ * \param h height of the image,
+ * \param buffer image buffer in RGB24 pixel packing.
+ * \sa queryImage()
+ */
+void sendImage(int w,int h, char* buffer);
+void sendWidth(int); //!< Sends the video width.
+void sendHeight(int);//!< Sends the video heigth.
+void sendFramerate(float); //!< Sends the video framerate
+void sendFrameNumber(long);//!< Sends the number of the current decoded frame.
+void sendTotalFrames(long);//!< Sends the total number of frames stored in video if available.
+void finished(); //!< Tells when the video has been entirely decoded
+
+private:
+AVFormatContext *pFormatCtx;
+int             videoStream;
+AVCodecContext  *pCodecCtx;
+AVCodec         *pCodec;
+AVFrame         *pFrame; 
+AVFrame         *pFrameRGB;
+uint8_t         *buffer;
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+  struct SwsContext *img_convert_ctx;
+#endif
+
+QString fileName;
+QTimer timer;
+QMutex mutex;
+bool threaded;
+bool started;
+bool loop;
+
+long numFrames;
+long totalFrames;
+};
+
+#endif //__VIDEODECODER_H__

+#include "videoencoder.h"
+#include <iostream>
+#include <stdio.h>
+#include "ffmpeglib.h"
+//#include <string.h>
+
+
+VideoEncoder::VideoEncoder(QObject* parent) : QObject(parent)
+{
+     FFMPegLib::init();
+//     av_register_all();
+     width = 320;
+     height = 240;
+     framerate=25;
+     bitrate = 900000;
+
+     closed = true;
+     started = false;
+     
+     pixelFormat = PIX_FMT_RGB24 ;
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+	 img_convert_ctx = NULL;
+#endif
+}
+
+VideoEncoder::~VideoEncoder()
+{
+     if (!closed)
+	  close();
+}
+
+
+AVStream* VideoEncoder::addVideoStream(AVFormatContext *oc, CodecID codec_id)
+{
+    AVCodecContext *c;
+    AVStream *st= NULL;
+
+    st = av_new_stream(oc, 0);
+    if (st == NULL) 
+	 return st;
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+    c = st->codec;
+#else    
+    c = &st->codec;
+#endif
+    c->codec_id = codec_id;
+    c->codec_type = CODEC_TYPE_VIDEO;
+
+    /* put sample parameters */
+    c->bit_rate = bitrate;
+    //c->bit_rate_tolerance = 100000;
+    /* resolution must be a multiple of two */
+    c->width = width;  
+    c->height = height;
+    /* time base: this is the fundamental unit of time (in seconds) in terms
+       of which frame timestamps are represented. for fixed-fps content,
+       timebase should be 1/framerate and timestamp increments should be
+       identically 1. */
+    if ((int)(framerate*1000)/1000 != framerate)
+    {
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+	    c->time_base.num = 1000;
+	    c->time_base.den = 1000*(int)framerate;
+#else	    
+	    c->frame_rate = 1000*(int)framerate;
+	    c->frame_rate_base = 1000;
+#endif
+    }
+    else
+    {
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+	c->time_base.num = 1;
+	c->time_base.den = framerate;
+#else
+    	c->frame_rate = framerate;
+	c->frame_rate_base = 1;
+#endif
+    }
+    c->gop_size = 12; /* emit one intra frame every twelve frames at most */
+    c->pix_fmt = PIX_FMT_YUV420P;//STREAM_PIX_FMT;
+    if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
+        /* just for testing, we also add B frames */
+        c->max_b_frames = 2;
+    }
+    if (c->codec_id == CODEC_ID_MPEG1VIDEO){
+        /* needed to avoid using macroblocks in which some coeffs overflow 
+           this doesnt happen with normal video, it just happens here as the 
+           motion of the chroma plane doesnt match the luma plane */
+        c->mb_decision=2;
+    }
+    // some formats want stream headers to be seperate
+    if(!strcmp(oc->oformat->name, "mp4") || !strcmp(oc->oformat->name, "mov") || !strcmp(oc->oformat->name, "3gp"))
+        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
+    
+    return st;
+}
+
+AVFrame *VideoEncoder::allocPicture(int pix_fmt, int width, int height)
+{
+     AVFrame *picture;
+     uint8_t *picture_buf;
+     int size;
+     
+     picture = avcodec_alloc_frame();
+     if (!picture)
+	  return NULL;
+     size = avpicture_get_size(pix_fmt, width, height);
+     picture_buf = (uint8_t*)malloc(size);
+     if (!picture_buf) {
+	  av_free(picture);
+	  return NULL;
+     }
+     avpicture_fill((AVPicture *)picture, picture_buf, 
+		    pix_fmt, width, height);
+     return picture;
+}
+
+
+
+int VideoEncoder::openVideo(AVFormatContext *oc, AVStream *st)
+{
+    AVCodec *codec;
+    AVCodecContext *c;
+
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+    c = st->codec;
+#else    
+    c = &st->codec;
+#endif
+
+    /* find the video encoder */
+    codec = avcodec_find_encoder(c->codec_id);
+    if (!codec) 
+    {
+	 std::cerr << "Couldn't find codec" << std::endl;
+	 return -1;
+    }
+
+    /* open the codec */
+    if (avcodec_open(c, codec) < 0) 
+    {
+	 std::cerr << "Couldn't open codec" << std::endl;
+	 return -1;
+    }
+
+    video_outbuf = NULL;
+    if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) 
+    {
+        /* allocate output buffer */
+        /* XXX: API change will be done */
+	 video_outbuf_size = 200000;
+	 video_outbuf = (uint8_t*)malloc(video_outbuf_size);
+    }
+
+    /* allocate the encoded raw picture */
+    picture = allocPicture(c->pix_fmt, c->width, c->height);
+    if (!picture) 
+    {
+	 std::cerr << "Cannot allocate picture " << std::endl;
+	 return -1;
+    }
+
+    /* if the output format is not YUV420P, then a temporary YUV420P
+       picture is needed too. It is then converted to the required
+       output format */
+    tmp_picture = NULL;
+    tmp_picture = allocPicture(pixelFormat, c->width, c->height);
+    if (tmp_picture== NULL)
+    {
+	 std::cout << " Cannot allocate tmp_picture" << std::endl;
+	 return -1;
+    }
+
+	// creating sws context
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+	 if (img_convert_ctx == NULL)
+		img_convert_ctx = sws_getContext(c->width, c->height,
+				c->pix_fmt, c->width, c->height, pixelFormat,
+				SWS_BICUBIC,NULL, NULL, NULL);
+#endif
+
+
+    return 0;
+}
+
+void VideoEncoder::initEncoder()
+{
+     if (fileName.isEmpty())
+	  return ;
+     std::cout << "[VEnc] File name defined." << std::endl;
+     fmt = guess_format(NULL, fileName.ascii(), NULL);
+     std::cout << "[VEnc] File name " << fileName.ascii() << std::endl;
+
+     if (fmt == NULL)
+     {
+	  fmt = guess_format("mpeg", NULL, NULL);
+	  if (fmt == NULL)
+	  {
+	  std::cerr << "[VEnc] Could not guess format" << std::endl; 
+	  return;
+	  }
+     }
+     std::cout << "[VEnc] Format properly guessed." << std::endl;
+     if (QString(fmt->extensions) == "avi")
+	  fmt->video_codec = CODEC_ID_MSMPEG4V2 ;
+
+
+     oc = av_alloc_format_context();
+     if (oc == NULL)
+	  return;
+     oc->oformat = fmt;
+
+#ifdef WIN32
+     _snprintf(oc->filename, sizeof(oc->filename), "%s", fileName.ascii());
+#else
+     snprintf(oc->filename, sizeof(oc->filename), "%s", fileName.ascii());
+#endif
+     
+
+     video_st = NULL;
+
+    if (fmt->video_codec != CODEC_ID_NONE) 
+	 video_st = addVideoStream(oc, fmt->video_codec);
+    
+    if (video_st == NULL)
+    {
+	 std::cerr << "Failed to create video stream." << std::endl;
+	 return;
+    }
+
+    if (oc == NULL) 
+    {
+	 std::cerr << "Alerte gnrale" << std::endl;
+    }
+
+    if (av_set_parameters(oc, NULL) < 0) 
+	 return ;
+
+    dump_format(oc, 0, fileName.ascii(), 1);
+    if ( openVideo(oc, video_st) != 0)
+    {
+	 std::cerr << "Couldn't open video" << std::endl;
+	 return ;
+    }
+    if (!(fmt->flags & AVFMT_NOFILE)) 
+    {
+	 if (url_fopen(&oc->pb, fileName.ascii(), URL_WRONLY)) 
+	      return ;
+    }
+
+    av_write_header(oc);
+    started = true;
+    closed = false;
+    std::cout << "[VEnc] Encoder properly initialized." << std::endl;
+}
+
+
+void VideoEncoder::setImage(int w, int h, char* buffer)
+{
+     if (!started)
+	  return;
+
+     if ((w!=width)||(h!=height))
+	  return;
+
+    int out_size, ret;
+    AVCodecContext *c;
+
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+    c = video_st->codec;
+#else
+    c = &video_st->codec;
+#endif
+
+    if (pixelFormat == PIX_FMT_RGB24)
+	 memcpy( tmp_picture->data[0], (uint8_t*)buffer, width*height*3);
+    else
+	 memcpy( tmp_picture->data[0], (uint8_t*)buffer, width*height*4);
+
+//    tmp_picture->data[0] = (uint8_t*)buffer;
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )		
+	sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize, 0, c->height,
+			  picture->data, picture->linesize);
+
+#else
+    img_convert((AVPicture *)picture, c->pix_fmt, 
+		(AVPicture *)tmp_picture, pixelFormat,
+		c->width, c->height);
+#endif
+
+    if (oc->oformat->flags & AVFMT_RAWPICTURE) 
+    {
+	 /* raw video case. The API will change slightly in the near
+	    futur for that */
+	 AVPacket pkt;
+	 av_init_packet(&pkt);
+	 
+	 pkt.flags |= PKT_FLAG_KEY;
+	 pkt.stream_index= video_st->index;
+	 pkt.data= (uint8_t *)picture;
+	 pkt.size= sizeof(AVPicture);
+	 
+	 ret = av_write_frame(oc, &pkt);
+    } 
+    else 
+    {
+        /* encode the image */
+	 out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
+        /* if zero size, it means the image was buffered */
+	 if (out_size > 0) 
+	 {
+            AVPacket pkt;
+            av_init_packet(&pkt);
+            
+            pkt.pts= c->coded_frame->pts;//av_rescale_q(c->coded_frame->pts, c->frame_rate_base, video_st->frame_rate_base);
+            if(c->coded_frame->key_frame)
+                pkt.flags |= PKT_FLAG_KEY;
+            pkt.stream_index= video_st->index;
+            pkt.data= video_outbuf;
+            pkt.size= out_size;
+            
+            /* write the compressed frame in the media file */
+            ret = av_write_frame(oc, &pkt);
+	 } 
+	 else 
+	 {
+	      ret = 0;
+	 }
+    }
+
+    if (ret != 0) 
+	 return ; 
+}
+
+
+
+
+void VideoEncoder::close()
+{
+     if (closed)
+	  return;
+#if ( LIBAVFORMAT_VERSION_INT > 5000)
+     avcodec_close(video_st->codec);
+#else
+     avcodec_close(&video_st->codec);
+#endif
+     av_free(picture->data[0]);
+     av_free(picture);
+     if (tmp_picture) 
+     {
+	  av_free(tmp_picture->data[0]);
+	  av_free(tmp_picture);
+     }
+     av_free(video_outbuf);
+
+     av_write_trailer(oc);
+    
+     for(int i = 0; i < oc->nb_streams; i++) 
+	  av_freep(&oc->streams[i]);
+    
+     if (!(fmt->flags & AVFMT_NOFILE)) 
+#if ( LIBAVFORMAT_VERSION_INT >= 52<<16 )
+	  url_fclose(oc->pb);
+#else
+     url_fclose(&oc->pb);
+#endif
+
+     av_free(oc);
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )		
+	 if (img_convert_ctx)
+		 sws_freeContext(img_convert_ctx);
+#endif
+     
+     closed = true;
+}

+#ifndef __VIDEOENCODER_H__
+#define __VIDEOENCODER_H__
+
+#include <QObject>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+
+#include <libswscale/swscale.h>
+
+
+/*! \brief A video encoder component.
+ *
+ * This component is relying on ffmpeg library to open and encode video files.
+ * First, you will give a filename using setFile() then initialize the encoder
+ * using initEncoder(). Once it is performed, you can feed the encoder with frames
+ * by the slot setImage(). Once all the frames have been sent, you can close() the 
+ * video stream.
+ *
+ * \author Jean-Yves Didier
+ * \date September, the 8th, 2006
+ * \ingroup video
+ */
+
+class VideoEncoder : public QObject
+{
+Q_OBJECT
+     public:
+VideoEncoder(QObject* parent=0); //!< ARCS Constructor
+~VideoEncoder(); //!< ARCS Destructor
+
+public slots:
+     void setFile(QString s) {fileName = s; } //!< Sets the video file in which to encode.
+void initEncoder(); //!< Inits the encoder and prepare the video.
+/*! \brief Sets the image to encode inside video stream.
+ * 
+ * The image must be packed in RGB 24 format.
+ * \param w video width
+ * \param h video height
+ * \param buffer image buffer in RGB 24 format.
+ */
+void setImage(int w, int h, char* buffer);
+/*! \brief Close the video and write down the video file.
+ *
+ * This step is necessary: when closed index informations are written down.
+ * You will need this later if you want to be able to seek frames in the video.
+ */
+void close();
+void setWidth(int w) { width=w; } //!< Sets the video width. Should be called before initEncoder()
+void setHeight(int h) { height=h;}//!< Sets the video height. Should be called before initEncoder()
+void setFramerate(float f) { framerate=f; }//!< Sets the framerate. Should be called before initEncoder()
+void setBitrate(int b) { bitrate = b; } //!< Sets the video bitrate. Should be called before initEncoder()
+/*! \brief Set the input image format to RGB32
+ * 
+ * By default, this encoder is working with RGB24 images
+ * You must call this before initEncoder()
+ */
+void setRGBA() { pixelFormat = PIX_FMT_RGB32 ;}
+
+
+private:
+AVStream* addVideoStream(AVFormatContext *oc, CodecID codec_id);
+AVFrame *allocPicture(int pix_fmt, int width, int height);
+
+int openVideo(AVFormatContext *oc, AVStream *st);
+QString fileName;
+AVOutputFormat *fmt;
+AVFormatContext *oc;
+AVStream* video_st;
+AVFrame *picture, *tmp_picture;
+uint8_t *video_outbuf;
+int video_outbuf_size;
+
+#if ( LIBAVFORMAT_VERSION_INT > 52<<16 )
+  struct SwsContext *img_convert_ctx;
+#endif
+
+int width;
+int height;
+float framerate;
+int bitrate;
+
+int pixelFormat;
+
+bool started;
+bool closed;
+};
+
+#endif //__VIDEOENCODER_H__

+#include "videofilter.h"
+
+void VideoFilter::setImage(int w, int h, char* img)
+{
+     imageIn = img;
+     width = w;
+     height = h;
+
+     if ( previousSize != width*height*3 )
+     {
+	  if (imageOut != NULL)
+	       delete[] imageOut;
+	  imageOut = new char[width*height*3];
+	  previousSize = width*height*3 ;
+     }
+	       
+     applyFilter();
+
+
+     emit sendImage(width,height,imageOut);
+}

+#ifndef __VIDEOFILTER_H__
+#define __VIDEOFILTER_H__
+
+#include <QObject>
+
+/*! \brief A simple video filter empty shell to develop many video filters
+ * 
+ * All video filter may inherit from this class.
+ * In each child, applyFilter() needs to be reimplemented. 
+ * In some special cases, it may also be the case of setImage().
+ * 
+ * We recommend to look at the other developped filters.
+ * At the same time we may add some recommendations about meta-data to append to each filters.
+ *
+ * \author Jean-Yves Didier
+ * \date September, the 8th, 2006
+ * \ingroup video
+ */
+class VideoFilter : public QObject
+{
+Q_OBJECT
+public:
+VideoFilter(QObject* parent=0) : QObject(parent) { imageIn = NULL; imageOut = NULL; previousSize = 0; } //!< ARCS Constructor
+
+/*! \brief Simple enum for red, green, blue components of a pixel
+ * \sa imgIn() 
+ * \sa imgOut()
+ */
+enum RGB
+     {
+	  R = 0, //!< Red component
+	  G = 1, //!< Green component
+	  B = 2, //!< Blue component
+     };
+
+public slots:
+     void setFramerate(float f) { framerate = f; } //!< Sets the framerate of the video.
+void setNumFrame(long n) { framenumber = n ; } //!< Sets the framenumber of the video.
+/*! \brief Sets the input image to process.
+ * 
+ * Be aware that the image should be in RGB-24 bits format.
+ * This member take the input image, allocate in memory, if needed, the output image.
+ * Then it calls applyFilter(), then sends the output image using signal sendImage().
+ * \param w image width
+ * \param h image height
+ * \param imgData raw image data
+ */
+virtual void setImage(int w,int h,char* imgData); 
+
+signals:
+void sendImage(int,int,char*); //!< Sends the output image.
+
+protected:
+/*!\brief  This virtual function needs to be implemented for each video filter.
+ * 
+ * Note that for a simple use, there is no need to send output image. 
+ * This member will, in most of the cases, only contain code to transform one input image to one output image.
+ * See also other protected members of this class to see how to obtain the data you want to process.
+ * Be aware the bytes in output images are, at the begining, at random state. So you should properly intialize your
+ * output image if needed.
+ */
+virtual void applyFilter() = 0; 
+float elapsedTime() { return (float)framenumber/framerate; } //!< Returns the elapsed time since the begining of the video stream.
+float frameRate() { return framerate; } //!< Returns the frame rate of the video stream
+long frameNumber() { return framenumber; } //!< Gives the frame number in the video stream
+int getWidth() { return width; } //!< Gives the width of the video
+int getHeight() { return height; } //!< Gives the height of the video
+/*! \brief Gives the value of a coloured pixel in image obtained from input.
+ * 
+ * \param i x coordinate
+ * \param j y coordinate
+ * \param k some of the RGB indices
+ * \return a byte representing a monochrome pixel value
+ */
+char imgIn(int i, int j, RGB k) { return imageIn[(j*width+i)*3+k]; } 
+/*! \brief Sets the value of a coloured pixel in output image.
+ * 
+ * \param i x coordinate
+ * \param j y coordinate
+ * \param k some of the RGB indices
+ * \param b a byte representing a monochrome pixel value
+ */
+void imgOut(int i, int j, RGB k, char b) { imageOut[(j*width+i)*3+k] = b; }
+/*! \brief Tests wether a point is really in the video images or not.
+ * 
+ * \param i x coordinate
+ * \param j y coordinate
+ * \return <tt>true</tt> if inside image, <tt>false</tt> otherwise
+ */
+bool safeIndex(int i , int j) { return ((i < width)&&(i >= 0)&&(j<height)&&(j>=0)); }
+void duplicateImage() { memcpy(imageOut,imageIn,previousSize); } //!< Duplicate input image inside output image.
+char* getImageOut() { return imageOut; } //!< Gives the pointer on output image raw data
+
+private:
+float framerate;
+long framenumber;
+int width;
+int height;
+char* imageIn;
+char* imageOut;
+int previousSize;
+
+};
+
+#endif //__VIDEOFILTER_H__

+#include "videoglviewer.h"
+#include <GL/gl.h>
+#include <GL/glu.h>
+#include <iostream>
+#include <string.h>
+
+using namespace std;
+
+VideoGLViewer::VideoGLViewer(QObject* obj, const char* name) :
+     QGLWidget(NULL, name)
+{
+     makeCurrent();
+     QGLFormat glfmt = context()->format();
+     image = NULL;
+     resize(320,200);
+}
+
+void VideoGLViewer::setImage(int w, int h,char* buffer)
+{
+     makeCurrent();
+     
+     if ( (w != wth) && ( h != hht))
+	  if (image != NULL)
+	  {
+	       delete[] image;
+	       image = NULL;
+	  }
+
+     if (image == NULL)
+	  image = new char[w*h*3];
+
+     memcpy(image, buffer, w*h*3);
+     wth = w;
+     hht = h;
+     updateGL();
+     //paintGL();
+}
+
+
+void VideoGLViewer::initializeGL()
+{
+     glClearColor(1.0,1.0,1.0,0.0);
+}
+
+void VideoGLViewer::resizeGL(int w, int h)
+{
+     std::cout << "Call to resize" << std::endl;
+     glViewport(0,0,w,h);
+     glMatrixMode(GL_PROJECTION);
+     glLoadIdentity();
+     gluOrtho2D(0,w,0,h);
+}
+
+
+void VideoGLViewer::paintGL()
+{
+     glMatrixMode(GL_MODELVIEW);
+     glClear(GL_COLOR_BUFFER_BIT);
+
+
+     if (image != NULL) 
+    {
+	 glRasterPos3f(0.0,hht-0.001,-0.5);
+	  glPixelZoom(1.0,-1.0);
+	  glDrawPixels(wth, hht, GL_RGB, GL_UNSIGNED_BYTE, image);
+     }
+
+     swapBuffers();
+}
+

+#ifndef __VIDEOGLVIEWER_H__
+#define __VIDEOGLVIEWER_H__
+
+#include <opencv/cv.h>
+#include <qgl.h>
+#include <QString>
+#include <QEvent>
+#include <QImage>
+//#include <qstatusbar.h>
+
+/*! \brief A component to display and select points on an image.
+ *
+ * This component can work in selection point mode or not.
+ * Selection point mode allows the user to select a certain amount 
+ * of points (given by setPointNumber()). Each time a point is selected
+ * by the user a signal  give2DPoint() is emitted giving the 2D location
+ * of the selected point. If the required number of points is reached,
+ * it will then emit a signal give2Dpoints() giving the whole set of
+ * selected points. Then a last signal is emitted which clicked(), indicating
+ * the user has selected something on the image. 
+ *
+ * This component can also display some points (using give2Dpoints()) during
+ * a certain amount of time (set by setDelay()). 
+ * 
+ * \author Jean-Yves Didier
+ * \date December, the 8th, 2004
+ * \ingroup opencv
+ */
+class VideoGLViewer : public QGLWidget
+{
+     Q_OBJECT
+
+public:
+     VideoGLViewer(QObject* obj=0);//!< ARCS Constructor
+
+public slots:
+/*! \brief Sets the image on which points will be selected.
+ * \param img OpenCV image to display.
+ */
+void setImage(int w, int h, char* buffer);
+void setHeight(int h) { hht = h; resize(width(), h);}
+void setWidth(int w) { wth = w; resize(w,height() );}
+
+
+protected:
+void initializeGL();
+void resizeGL(int w, int h);
+void paintGL();
+void drawImage();
+
+
+private:
+char* image;
+int wth;
+int hht;
+
+};
+
+#endif //__VIDEOGLVIEWER_H__

+#include "videoviewer.h"
+
+void VideoViewer::setImage(int w,int h, char* buffer)
+{
+     img = QImage(w,h,32);
+
+     for (int j=0; j < h ; j++)
+	  for (int i=0; i < w; i++)
+	  {
+	       img.setPixel(i,j,qRgb(buffer[(j*w+i)*3],buffer[(j*w+i)*3+1],buffer[(j*w+i)*3+2]));
+	  }
+//     update();
+     repaint(0,0,width(),height(),false);
+}

+#ifndef __VIDEOVIEWER_H__
+#define __VIDEOVIEWER_H__
+
+#include <Q3Frame>
+#include <QImage>
+#include <QPainter>
+/*#include <qgl.h>
+#include <GL/glu.h>
+#include <GL/gl.h>*/
+
+class VideoViewer : public Q3Frame
+{
+Q_OBJECT
+
+public:
+VideoViewer(QObject* parent=0) : //QGLWidget(NULL, name) {}
+     Q3Frame(NULL, name,Qt::WNoAutoErase ) {} //!< ARCS Constructor
+
+public slots:
+     void setImage(int w, int h, char* buffer);
+void setWidth(int w) { resize(w, height()); }
+void setHeight(int h) { resize(width(), h); }
+
+protected:
+/*void resizeGL(int width, int height) 
+{ 
+     glViewport(0,width,0,height);*/
+
+
+void drawContents(QPainter* p) { 
+p->drawImage(0,0,img); 
+p->flush();
+}
+
+private:
+QImage img;
+};
+
+
+#endif //__VIDEOVIEWER_H__

+<application>
+    <defines/>
+    <libraries>
+        <library name="../libs/libarcsffmpeg.so" />
+    </libraries>
+    <objects>
+        <object classname="VideoViewer" persistent="true" id="vw" />
+        <object classname="VideoDecoder" persistent="true" id="vd" />
+    </objects>
+    <sheets>
+        <sheet id="start" >
+            <preconnection>
+                <init value="sample.avi" type="string" slot="setFile(QString)" object="vd" />
+                <init value="" type="void" slot="show()" object="vw" />
+                <init value="true" type="bool" slot="setThreaded(bool)" object="vd" />
+            </preconnection>
+            <connection>
+                <wire objsource="vd" objdest="vw" signal="sendHeight(int)" slot="setHeight(int)" />
+                <wire objsource="vd" objdest="vw" signal="sendWidth(int)" slot="setWidth(int)" />
+                <wire objsource="vd" objdest="vw" signal="sendImage(int,int,char*)" slot="setImage(int,int,char*)" />
+            </connection>
+            <postconnection>
+                <init value="" type="void" slot="initDecoder()" object="vd" />
+                <init value="" type="void" slot="start()" object="vd" />
+            </postconnection>
+        </sheet>
+    </sheets>
+    <statemachine terminal="end" initial="start" />
+</application>