SVN commit 813203 by mkretz:

start of an (disabled from compilation for 4.1) implementation for Experimental::VideoDataOutput

 M  +1 -1      CMakeLists.txt  
 M  +4 -3      backend.cpp  
 M  +78 -23    videodataoutput.cpp  
 M  +18 -35    videodataoutput.h  


--- trunk/KDE/kdebase/runtime/phonon/xine/CMakeLists.txt #813202:813203
@@ -18,7 +18,7 @@
     effect.cpp
     audiooutput.cpp
     mediaobject.cpp
-    videodataoutput.cpp
+    #videodataoutput.cpp
     visualization.cpp
     backend.cpp
     volumefadereffect.cpp
--- trunk/KDE/kdebase/runtime/phonon/xine/backend.cpp #813202:813203
@@ -20,6 +20,7 @@
 */
 
 #include "backend.h"
+//#include <phonon/experimental/backendinterface.h>
 #include "mediaobject.h"
 #include "effect.h"
 #include "events.h"
@@ -28,7 +29,7 @@
 #include "nullsink.h"
 #include "visualization.h"
 #include "volumefadereffect.h"
-#include "videodataoutput.h"
+//#include "videodataoutput.h"
 #include "videowidget.h"
 #include "wirecall.h"
 #include "xinethread.h"
@@ -106,8 +107,8 @@
         return new AudioDataOutput(parent);
     case VisualizationClass:
         return new Visualization(parent);
-    case VideoDataOutputClass:
-        return new VideoDataOutput(parent);
+    //case Phonon::Experimental::BackendInterface::VideoDataOutputClass:
+        //return new VideoDataOutput(parent);
     case EffectClass:
         {
             Q_ASSERT(args.size() == 1);
--- trunk/KDE/kdebase/runtime/phonon/xine/videodataoutput.cpp #813202:813203
@@ -21,7 +21,10 @@
 #include "videodataoutput.h"
 #include <kdebug.h>
 #include "sourcenode.h"
+#include <Phonon/Experimental/AbstractVideoDataOutput>
 
+#define K_XT(type) (static_cast<type *>(SinkNode::threadSafeObject().data()))
+
 namespace Phonon
 {
 namespace Xine
@@ -29,64 +32,116 @@
 class VideoDataOutputXT : public SinkNodeXT
 {
     public:
+        VideoDataOutputXT();
+        ~VideoDataOutputXT();
         xine_video_port_t *videoPort() const { return m_videoPort; }
         void rewireTo(SourceNodeXT *);
 
+        Phonon::Experimental::AbstractVideoDataOutput *m_frontend;
     private:
+        struct Frame
+        {
+            int format;
+            int width;
+            int height;
+            double aspectRatio;
+            void *data0;
+            void *data1;
+            void *data2;
+        };
+        static void raw_output_cb(void *user_data, int frame_format, int frame_width,
+                int frame_height, double frame_aspect, void *data0, void *data1, void *data2);
+        static void raw_overlay_cb(void *user_data, int num_ovl, raw_overlay_t *overlay_array);
+
+#ifdef XINE_VISUAL_TYPE_RAW
+        raw_visual_t m_visual;
+#endif
         xine_video_port_t *m_videoPort;
 };
 
-VideoDataOutput::VideoDataOutput(QObject *parent)
-    : QObject(parent),
-    SinkNode(new VideoDataOutputXT)
+void VideoDataOutputXT::raw_output_cb(void *user_data, int format, int width,
+        int height, double aspect, void *data0, void *data1, void *data2)
 {
+    VideoDataOutputXT* vw = reinterpret_cast<VideoDataOutputXT *>(user_data);
+    const Experimental::VideoFrame f = {
+        width,
+        height,
+        aspect,
+        ((format == XINE_VORAW_YV12) ? Experimental::VideoFrame::Format_YV12 :
+         (format == XINE_VORAW_YUY2) ? Experimental::VideoFrame::Format_YUY2 :
+         (format == XINE_VORAW_RGB ) ? Experimental::VideoFrame::Format_RGB888 :
+                                       Experimental::VideoFrame::Format_Invalid),
+        QByteArray::fromRawData(reinterpret_cast<const char *>(data0), ((format == XINE_VORAW_RGB) ? 3 : (format == XINE_VORAW_YUY2) ? 2 : 1) * width * height),
+        QByteArray::fromRawData(reinterpret_cast<const char *>(data1), (format == XINE_VORAW_YV12) ? (width >> 1) + (height >> 1) : 0),
+        QByteArray::fromRawData(reinterpret_cast<const char *>(data2), (format == XINE_VORAW_YV12) ? (width >> 1) + (height >> 1) : 0)
+    };
+    if (vw->m_frontend) {
+        //kDebug(610) << "send frame to frontend";
+        vw->m_frontend->frameReady(f);
+    }
 }
 
-VideoDataOutput::~VideoDataOutput()
+void VideoDataOutputXT::raw_overlay_cb(void *user_data, int num_ovl, raw_overlay_t *overlay_array)
 {
+    VideoDataOutputXT* vw = reinterpret_cast<VideoDataOutputXT *>(user_data);
+    Q_UNUSED(vw);
+    Q_UNUSED(num_ovl);
+    Q_UNUSED(overlay_array);
 }
 
-void VideoDataOutputXT::rewireTo(SourceNodeXT *source)
+VideoDataOutputXT::VideoDataOutputXT()
+    : m_frontend(0),
+    m_videoPort(0)
 {
-    xine_post_wire_video_port(source->videoOutputPort(), videoPort());
+#ifdef XINE_VISUAL_TYPE_RAW
+    m_visual.user_data = static_cast<void *>(this);
+    m_visual.raw_output_cb = &Phonon::Xine::VideoDataOutputXT::raw_output_cb;
+    m_visual.raw_overlay_cb = &Phonon::Xine::VideoDataOutputXT::raw_overlay_cb;
+    m_visual.supported_formats = /*XINE_VORAW_YV12 | XINE_VORAW_YUY2 |*/ XINE_VORAW_RGB; // TODO
+    m_videoPort = xine_open_video_driver(XineEngine::xine(), "auto", XINE_VISUAL_TYPE_RAW, static_cast<void *>(&m_visual));
+#endif
 }
 
-quint32 VideoDataOutput::format() const
+VideoDataOutputXT::~VideoDataOutputXT()
 {
-    return m_fourcc;
-}
+    if (m_videoPort) {
+        xine_video_port_t *vp = m_videoPort;
+        m_videoPort = 0;
 
-int VideoDataOutput::frameRate() const
-{
-    return m_frameRate;
+        xine_close_video_driver(XineEngine::xine(), vp);
+    }
 }
 
-void VideoDataOutput::setFrameRate(int frameRate)
+VideoDataOutput::VideoDataOutput(QObject *parent)
+    : QObject(parent),
+    SinkNode(new VideoDataOutputXT)
 {
-    m_frameRate = frameRate;
 }
 
-QSize VideoDataOutput::naturalFrameSize() const
+VideoDataOutput::~VideoDataOutput()
 {
-    return QSize(320, 240);
 }
 
-QSize VideoDataOutput::frameSize() const
+void VideoDataOutputXT::rewireTo(SourceNodeXT *source)
 {
-    return m_frameSize;
+    if (!source->videoOutputPort()) {
+        return;
+    }
+    xine_post_wire_video_port(source->videoOutputPort(), videoPort());
 }
 
-void VideoDataOutput::setFrameSize(const QSize &frameSize)
+Experimental::AbstractVideoDataOutput *VideoDataOutput::frontendObject() const
 {
-    m_frameSize = frameSize;
+    return K_XT(const VideoDataOutputXT)->m_frontend;
 }
 
-void VideoDataOutput::setFormat(quint32 fourcc)
+void VideoDataOutput::setFrontendObject(Experimental::AbstractVideoDataOutput *x)
 {
-    m_fourcc = fourcc;
+    K_XT(VideoDataOutputXT)->m_frontend = x;
 }
 
 }} //namespace Phonon::Xine
 
+#undef K_XT
+
 #include "videodataoutput.moc"
-// vim: sw=4 ts=4
--- trunk/KDE/kdebase/runtime/phonon/xine/videodataoutput.h #813202:813203
@@ -1,5 +1,5 @@
 /*  This file is part of the KDE project
-    Copyright (C) 2006 Matthias Kretz <kretz@kde.org>
+    Copyright (C) 2006,2008 Matthias Kretz <kretz@kde.org>
 
     This program is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ -17,57 +17,40 @@
     Boston, MA 02110-1301, USA.
 
 */
-#ifndef Phonon_XINE_VIDEODATAOUTPUT_H
-#define Phonon_XINE_VIDEODATAOUTPUT_H
+#ifndef PHONON_XINE_VIDEODATAOUTPUT_H
+#define PHONON_XINE_VIDEODATAOUTPUT_H
 
-#include <phonon/experimental/videoframe.h>
-#include <QVector>
-#include <QByteArray>
-#include <QObject>
-#include <QSize>
-#include <QList>
 #include "sinknode.h"
 
+#include <Phonon/Experimental/VideoDataOutputInterface>
+#include <Phonon/Experimental/VideoFrame>
+
+#include <QtCore/QByteArray>
+#include <QtCore/QList>
+#include <QtCore/QObject>
+#include <QtCore/QSize>
+#include <QtCore/QVector>
+
 #include <xine.h>
 
 namespace Phonon
 {
 namespace Xine
 {
-/**
- * \author Matthias Kretz <kretz@kde.org>
- */
-class VideoDataOutput : public QObject, public Phonon::Xine::SinkNode
+
+class VideoDataOutput : public QObject, public Phonon::Experimental::VideoDataOutputInterface, public Phonon::Xine::SinkNode
 {
     Q_OBJECT
-    Q_INTERFACES(Phonon::Xine::SinkNode)
+    Q_INTERFACES(Phonon::Experimental::VideoDataOutputInterface Phonon::Xine::SinkNode)
     public:
         VideoDataOutput(QObject *parent);
         ~VideoDataOutput();
 
         MediaStreamTypes inputMediaStreamTypes() const { return Phonon::Xine::Video; }
 
-    public slots:
-        int frameRate() const;
-        void setFrameRate(int frameRate);
-
-        QSize naturalFrameSize() const;
-        QSize frameSize() const;
-        void setFrameSize(const QSize &frameSize);
-
-        quint32 format() const;
-        void setFormat(quint32 fourcc);
-
-    signals:
-        void frameReady(const Phonon::Experimental::VideoFrame &frame);
-        void endOfMedia();
-
-    private:
-        quint32 m_fourcc;
-        int m_frameRate;
-        QSize m_frameSize;
+        Experimental::AbstractVideoDataOutput *frontendObject() const;
+        void setFrontendObject(Experimental::AbstractVideoDataOutput *);
 };
 }} //namespace Phonon::Xine
 
-// vim: sw=4 ts=4 tw=80
-#endif // Phonon_XINE_VIDEODATAOUTPUT_H
+#endif // PHONON_XINE_VIDEODATAOUTPUT_H