summaryrefslogtreecommitdiff
authorsimon <simon>2002-12-02 10:25:36 (UTC)
committer simon <simon>2002-12-02 10:25:36 (UTC)
commit4447c70039ba1a3104bf229628699f33b8608973 (patch) (side-by-side diff)
tree9810b07492a20f1ec9332da8c353469c8c120e2e
parent2f11390d99fba4eefa330322e11280802fb6dc26 (diff)
downloadopie-4447c70039ba1a3104bf229628699f33b8608973.zip
opie-4447c70039ba1a3104bf229628699f33b8608973.tar.gz
opie-4447c70039ba1a3104bf229628699f33b8608973.tar.bz2
- 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
Diffstat (more/less context) (show whitespace changes)
-rw-r--r--noncore/multimedia/opieplayer2/lib.cpp15
-rw-r--r--noncore/multimedia/opieplayer2/lib.h8
-rw-r--r--noncore/multimedia/opieplayer2/threadutil.cpp284
-rw-r--r--noncore/multimedia/opieplayer2/threadutil.h176
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
@@ -33,24 +33,26 @@
#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 );
@@ -210,26 +212,37 @@ 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 );
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
@@ -32,37 +32,39 @@
*/
#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 );
@@ -167,36 +169,40 @@ namespace XINE {
* 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
+ */