| -rw-r--r-- | noncore/multimedia/opieplayer2/lib.cpp | 15 | ||||
| -rw-r--r-- | noncore/multimedia/opieplayer2/lib.h | 8 | ||||
| -rw-r--r-- | noncore/multimedia/opieplayer2/threadutil.cpp | 284 | ||||
| -rw-r--r-- | noncore/multimedia/opieplayer2/threadutil.h | 176 |
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 @@ -42,6 +42,8 @@ #include <qgfx_qws.h> #include <qdirectpainter_qws.h> +#include <assert.h> + #include "xinevideowidget.h" #include "frame.h" #include "lib.h" @@ -219,8 +221,19 @@ 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(); } } 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 @@ -41,6 +41,8 @@ #include <xine.h> //#include "xine.h" +#include "threadutil.h" + class XineVideoWidget; namespace XINE { @@ -53,7 +55,7 @@ namespace XINE { * stooping, seeking. */ class Frame; - class Lib : public QObject { + class Lib : public ThreadUtil::Channel { Q_OBJECT public: Lib(XineVideoWidget* = 0); @@ -176,6 +178,9 @@ namespace XINE { void stopped(); + protected: + virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ); + private: int m_bytes_per_pixel; int m_length, m_pos, m_time; @@ -190,6 +195,7 @@ namespace XINE { 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); 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 + */ |