- put a thread pipe between the xine callback handler and the receiver

  on qt side, to avoid problems like repaints from within a non-gui thread

4 files changed, 481 insertions, 2 deletions

diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp
index 19b64e8..1ac9809 100644
--- a/noncore/multimedia/opieplayer2/lib.cpp
+++ b/noncore/multimedia/opieplayer2/lib.cpp
@@ -29,32 +29,34 @@
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <qimage.h>
 #include <qtextstream.h>
 #include <qpe/resource.h>
 
 #include <qfile.h>
 
 #include <qgfx_qws.h>
 #include <qdirectpainter_qws.h>
 
+#include <assert.h>
+
 #include "xinevideowidget.h"
 #include "frame.h"
 #include "lib.h"
 
 typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame,
                                       int  width, int height,int bytes );
 
 extern "C" {
     xine_vo_driver_t* init_video_out_plugin( xine_cfg_entry_t* conf, void* video);
     int null_is_showing_video( const xine_vo_driver_t* self );
     void null_set_show_video( const xine_vo_driver_t* self, int show );
     int null_is_fullscreen( const xine_vo_driver_t* self );
     void null_set_fullscreen( const xine_vo_driver_t* self, int screen );
     int null_is_scaling( const xine_vo_driver_t* self );
     void null_set_scaling( const xine_vo_driver_t* self, int scale );
     void null_set_gui_width( const xine_vo_driver_t* self, int width );
@@ -206,34 +208,45 @@ void Lib::seekTo( int time ) {
 }
 
 
 Frame Lib::currentFrame() {
     Frame frame;
     return frame;
 };
 
 QString Lib::metaInfo( int number) {
     return xine_get_meta_info( m_stream, number );
 }
 
 int Lib::error() {
     return xine_get_error( m_stream );
 };
 
+void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType )
+{
+    assert( sendType == ThreadUtil::Channel::OneWay );
+    handleXineEvent( msg->type() );
+    delete msg;
+}
+
 void Lib::handleXineEvent( const xine_event_t* t ) {
-    if ( t->type == XINE_EVENT_UI_PLAYBACK_FINISHED ) {
+    send( new ThreadUtil::ChannelMessage( t->type ), OneWay );
+}
+
+void Lib::handleXineEvent( int type ) {
+    if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) {
         emit stopped();
     }
 }
 
 
 void Lib::setShowVideo( bool video ) {
     m_video = video;
     ::null_set_show_video( m_videoOutput, video );
 }
 
 bool Lib::isShowingVideo() {
     return ::null_is_showing_video( m_videoOutput );
 }
 
 bool Lib::hasVideo() {
     return  xine_get_stream_info( m_stream, 18 );
diff --git a/noncore/multimedia/opieplayer2/lib.h b/noncore/multimedia/opieplayer2/lib.h
index 38938a1..75b9f12 100644
--- a/noncore/multimedia/opieplayer2/lib.h
+++ b/noncore/multimedia/opieplayer2/lib.h
@@ -28,45 +28,47 @@
                              If not, write to the Free Software Foundation,
                              Inc., 59 Temple Place - Suite 330,
                              Boston, MA 02111-1307, USA.
 
 */
 
 #ifndef ZECKEXINELIB_H
 #define ZECKEXINELIB_H
 
 #include <qcstring.h>
 #include <qstring.h>
 #include <qobject.h>
 
 #include <xine.h>
 //#include "xine.h"
 
+#include "threadutil.h"
+
 class XineVideoWidget;
 
 namespace XINE {
 
     /**
      * Lib wrapps the simple interface
      * of libxine for easy every day use
      * This will become a full C++ Wrapper
      * It supports playing, pausing, info,
      * stooping, seeking.
      */
     class Frame;
-    class Lib : public QObject {
+    class Lib : public ThreadUtil::Channel {
         Q_OBJECT
     public:
         Lib(XineVideoWidget* = 0);
         ~Lib();
         QCString version();
         int majorVersion()/*const*/;
         int minorVersion()/*const*/;
         int subVersion()/*const*/;
 
 
                 void resize ( const QSize &s );
 
         int play( const QString& fileName,
                   int startPos = 0,
                   int start_time = 0 );
         void stop() /*const*/;
@@ -163,40 +165,44 @@ namespace XINE {
          */
         Frame currentFrame()/*const*/;
 
         /**
          * Returns the error code
          * XINE_ERROR_NONE                    0
          * XINE_ERROR_NO_INPUT_PLUGIN         1
          * XINE_ERROR_NO_DEMUXER_PLUGIN       2
          * XINE_ERROR_DEMUXER_FAILED          3
          */
         int error() /*const*/;
 
     signals:
 
         void stopped();
 
+    protected:
+        virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType );
+
     private:
         int m_bytes_per_pixel;
         int m_length,  m_pos,  m_time;
         int m_major_version,  m_minor_version,  m_sub_version;
         bool m_video:1;
         XineVideoWidget *m_wid;
         xine_t *m_xine;
         xine_stream_t *m_stream;
         xine_cfg_entry_t *m_config;
         xine_vo_driver_t *m_videoOutput;
         xine_ao_driver_t* m_audioOutput;
         xine_event_queue_t *m_queue;
 
         void handleXineEvent( const xine_event_t* t );
+        void handleXineEvent( int type );
         void drawFrame( uint8_t* frame, int width, int height, int bytes );
         // C -> C++ bridge for the event system
         static void xine_event_handler( void* user_data, const xine_event_t* t);
         static void xine_display_frame( void* user_data, uint8_t* frame ,
                                         int width, int height, int bytes );
     };
 };
 
 
 #endif
diff --git a/noncore/multimedia/opieplayer2/threadutil.cpp b/noncore/multimedia/opieplayer2/threadutil.cpp
new file mode 100644
index 0000000..63863b4
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/threadutil.cpp
@@ -0,0 +1,284 @@
+/* This file is part of the KDE project
+   Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+
+#include "threadutil.h"
+
+#include <qsocketnotifier.h>
+
+#include <pthread.h>
+#include <assert.h>
+#include <unistd.h>
+
+using namespace ThreadUtil;
+
+struct Mutex::Data
+{
+    Data()
+    {
+        pthread_mutex_init( &mutex, 0 );
+    }
+    ~Data()
+    {
+        pthread_mutex_destroy( &mutex );
+    }
+
+    pthread_mutex_t mutex;
+};
+
+Mutex::Mutex()
+    : d( new Data )
+{
+}
+
+Mutex::~Mutex()
+{
+    delete d;
+}
+
+void Mutex::lock()
+{
+    pthread_mutex_lock( &d->mutex );
+}
+
+void Mutex::unlock()
+{
+    pthread_mutex_unlock( &d->mutex );
+}
+
+bool Mutex::tryLock()
+{
+    return pthread_mutex_trylock( &d->mutex ) == 0;
+}
+
+bool Mutex::isLocked()
+{
+    if ( !tryLock() )
+        return true;
+
+    unlock();
+    return false;
+}
+
+struct WaitCondition::Data
+{
+    Data()
+    {
+        int result = pthread_cond_init( &waitCondition, 0 );
+        assert( result == 0 );
+    }
+    ~Data()
+    {
+        pthread_cond_destroy( &waitCondition );
+    }
+
+    pthread_cond_t waitCondition;
+};
+
+WaitCondition::WaitCondition()
+    : d( new Data )
+{
+}
+
+WaitCondition::~WaitCondition()
+{
+    delete d;
+}
+
+bool WaitCondition::wait()
+{
+    Mutex m;
+    m.lock();
+    return wait( m );
+}
+
+bool WaitCondition::wait( Mutex &mutex )
+{
+    return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex );
+}
+
+void WaitCondition::wakeOne()
+{
+    pthread_cond_signal( &d->waitCondition );
+}
+
+void WaitCondition::wakeAll()
+{
+    pthread_cond_broadcast( &d->waitCondition );
+}
+
+OnewayNotifier::OnewayNotifier()
+{
+    int fds[ 2 ];
+    pipe( fds );
+    m_readFd = fds[ 0 ];
+    m_writeFd = fds[ 1 ];
+
+    m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read );
+    connect( m_notifier, SIGNAL( activated( int ) ),
+             this, SLOT( wakeUp() ) );
+}
+
+OnewayNotifier::~OnewayNotifier()
+{
+    delete m_notifier;
+
+    ::close( m_readFd );
+    ::close( m_writeFd );
+}
+
+void OnewayNotifier::notify()
+{
+    const char c = 42;
+    ::write( m_writeFd, &c, 1 );
+}
+
+void OnewayNotifier::wakeUp()
+{
+    char c = 0;
+
+    if ( ::read( m_readFd, &c, 1 ) != 1 )
+        return;
+
+    emit awake();
+}
+
+ChannelMessage::ChannelMessage( int type )
+    : m_type( type ), m_isCall( false ), m_replied( false ),
+      m_inEventHandler( false )
+{
+}
+
+ChannelMessage::~ChannelMessage()
+{
+    if ( m_guard.isLocked() )
+        m_guard.unlock();
+}
+
+void ChannelMessage::reply()
+{
+    if ( !m_isCall )
+    {
+        qDebug( "ChannelMessage::reply() - can't reply oneway message!" );
+        return;
+    }
+
+    if ( m_inEventHandler )
+    {
+        m_replied = true;
+        return;
+    }
+
+    m_condition.wakeOne();
+    m_guard.unlock();
+}
+
+struct Channel::Private
+{
+    Private()
+    {
+        ownerThread = pthread_self();
+    }
+
+    pthread_t ownerThread;
+};
+
+Channel::Channel( QObject *parent, const char *name )
+    : QObject( parent, name ), d( new Private )
+{
+    connect( &m_notifier, SIGNAL( awake() ),
+             this, SLOT( deliver() ) );
+}
+
+Channel::~Channel()
+{
+    delete d;
+}
+
+void Channel::send( ChannelMessage *message, SendType type )
+{
+    if ( type == WaitForReply )
+    {
+        message->m_guard.lock();
+        message->m_isCall = true;
+    }
+
+    m_pendingMessagesGuard.lock();
+    m_pendingMessages << MsgEnvelope( type, message );
+    m_pendingMessagesGuard.unlock();
+
+    if ( d->ownerThread == pthread_self() ) {
+        assert( type != WaitForReply );
+
+        deliver();
+    }
+    else
+        m_notifier.notify();
+    //QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) );
+
+    if ( type == WaitForReply )
+    {
+        message->m_condition.wait( message->m_guard );
+        message->m_guard.unlock();
+    }
+}
+
+void Channel::deliver()
+{
+    AutoLock lock( m_pendingMessagesGuard );
+
+    while ( !m_pendingMessages.isEmpty() ) {
+        MsgEnvelope envelope = m_pendingMessages.first();
+
+        m_pendingMessages.remove( m_pendingMessages.begin() );
+
+        m_pendingMessagesGuard.unlock();
+        deliverOne( envelope );
+        m_pendingMessagesGuard.lock();
+    }
+}
+
+void Channel::deliverOne( const MsgEnvelope &envelope )
+{
+    ChannelMessage *msg = envelope.msg;
+
+    assert( msg );
+
+    if ( envelope.type == WaitForReply )
+    {
+        msg->m_guard.lock();
+        msg->m_inEventHandler = true;
+    }
+
+    receiveMessage( msg, envelope.type );
+
+    if ( envelope.type == WaitForReply )
+    {
+        msg->m_inEventHandler = false;
+        if ( msg->m_replied )
+        {
+            msg->m_condition.wakeOne();
+            // this is a bit tricky. we unlock only when we reply.
+            // reply() does an unlock as well.
+            msg->m_guard.unlock();
+        }
+    }
+}
+
+/* vim: et sw=4 ts=4
+ */
diff --git a/noncore/multimedia/opieplayer2/threadutil.h b/noncore/multimedia/opieplayer2/threadutil.h
new file mode 100644
index 0000000..bcb9db9
--- a/dev/null
+++ b/noncore/multimedia/opieplayer2/threadutil.h
@@ -0,0 +1,176 @@
+/* This file is part of the KDE project
+   Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+
+#ifndef THREADUTIL_H
+#define THREADUTIL_H
+
+#include <qvaluelist.h>
+#include <qobject.h>
+#include <qguardedptr.h>
+
+class QSocketNotifier;
+
+namespace ThreadUtil
+{
+
+    class Mutex
+    {
+        friend class WaitCondition;
+    public:
+        Mutex();
+        ~Mutex();
+
+        void lock();
+        void unlock();
+        bool tryLock();
+        bool isLocked();
+
+    private:
+        struct Data;
+        Data *d;
+
+        Mutex( const Mutex & );
+        Mutex &operator=( const Mutex & );
+    };
+
+    class AutoLock
+    {
+    public:
+        AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); }
+        ~AutoLock() { m_mutex.unlock(); }
+
+        Mutex *operator &() const { return &m_mutex; }
+
+    private:
+        Mutex &m_mutex;
+    };
+
+    class WaitCondition
+    {
+    public:
+        WaitCondition();
+        ~WaitCondition();
+
+        bool wait();
+        bool wait( Mutex &mutex );
+
+        void wakeOne();
+        void wakeAll();
+
+    private:
+        struct Data;
+        Data *d;
+
+        WaitCondition( const WaitCondition & );
+        WaitCondition &operator=( const WaitCondition & );
+    };
+
+    class OnewayNotifier : public QObject
+    {
+        Q_OBJECT
+    public:
+        OnewayNotifier();
+        ~OnewayNotifier();
+
+        void notify();
+
+    signals:
+        void awake();
+
+    private slots:
+        void wakeUp();
+
+    private:
+        int m_readFd;
+        int m_writeFd;
+        QSocketNotifier *m_notifier;
+    };
+
+
+    class Channel;
+
+    class ChannelMessage
+    {
+        friend class Channel;
+    public:
+        ChannelMessage( int type = -1 );
+        virtual ~ChannelMessage();
+
+        int type() const { return m_type; }
+
+        void reply();
+
+    private:
+        ChannelMessage( const ChannelMessage & );
+        ChannelMessage &operator=( const ChannelMessage );
+
+        int m_type;
+        bool m_isCall : 1;
+        bool m_replied : 1;
+        bool m_inEventHandler : 1;
+        Mutex m_guard;
+        WaitCondition m_condition;
+        QGuardedPtr<Channel> m_channel;
+    };
+
+    class Channel : public QObject
+    {
+        Q_OBJECT
+    public:
+        enum SendType { OneWay, WaitForReply };
+        Channel( QObject *parent = 0, const char *name = 0 );
+        virtual ~Channel();
+
+        void send( ChannelMessage *message, SendType type );
+
+    protected:
+        virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0;
+
+    private slots:
+        void deliver();
+
+    private:
+        OnewayNotifier m_notifier;
+
+        struct MsgEnvelope
+        {
+            MsgEnvelope() : type( OneWay ), msg( 0 ) {}
+            MsgEnvelope( SendType _type , ChannelMessage *_msg )
+                : type( _type ), msg( _msg ) {}
+
+            SendType type;
+            ChannelMessage *msg;
+        };
+
+        void deliverOne( const MsgEnvelope &envelope );
+
+        typedef QValueList<MsgEnvelope> MsgEnvelopeList;
+
+        MsgEnvelopeList m_pendingMessages;
+        Mutex m_pendingMessagesGuard;
+
+        struct Private;
+        Private *d;
+    };
+
+}
+
+#endif // THREADUTIL_H
+/* vim: et sw=4 ts=4
+ */