summaryrefslogtreecommitdiff
Unidiff
Diffstat (more/less context) (ignore 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
@@ -42,6 +42,8 @@
42#include <qgfx_qws.h> 42#include <qgfx_qws.h>
43#include <qdirectpainter_qws.h> 43#include <qdirectpainter_qws.h>
44 44
45#include <assert.h>
46
45#include "xinevideowidget.h" 47#include "xinevideowidget.h"
46#include "frame.h" 48#include "frame.h"
47#include "lib.h" 49#include "lib.h"
@@ -219,8 +221,19 @@ int Lib::error() {
219 return xine_get_error( m_stream ); 221 return xine_get_error( m_stream );
220}; 222};
221 223
224void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType )
225{
226 assert( sendType == ThreadUtil::Channel::OneWay );
227 handleXineEvent( msg->type() );
228 delete msg;
229}
230
222void Lib::handleXineEvent( const xine_event_t* t ) { 231void Lib::handleXineEvent( const xine_event_t* t ) {
223 if ( t->type == XINE_EVENT_UI_PLAYBACK_FINISHED ) { 232 send( new ThreadUtil::ChannelMessage( t->type ), OneWay );
233}
234
235void Lib::handleXineEvent( int type ) {
236 if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) {
224 emit stopped(); 237 emit stopped();
225 } 238 }
226} 239}
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 @@
41#include <xine.h> 41#include <xine.h>
42//#include "xine.h" 42//#include "xine.h"
43 43
44#include "threadutil.h"
45
44class XineVideoWidget; 46class XineVideoWidget;
45 47
46namespace XINE { 48namespace XINE {
@@ -53,7 +55,7 @@ namespace XINE {
53 * stooping, seeking. 55 * stooping, seeking.
54 */ 56 */
55 class Frame; 57 class Frame;
56 class Lib : public QObject { 58 class Lib : public ThreadUtil::Channel {
57 Q_OBJECT 59 Q_OBJECT
58 public: 60 public:
59 Lib(XineVideoWidget* = 0); 61 Lib(XineVideoWidget* = 0);
@@ -176,6 +178,9 @@ namespace XINE {
176 178
177 void stopped(); 179 void stopped();
178 180
181 protected:
182 virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType );
183
179 private: 184 private:
180 int m_bytes_per_pixel; 185 int m_bytes_per_pixel;
181 int m_length, m_pos, m_time; 186 int m_length, m_pos, m_time;
@@ -190,6 +195,7 @@ namespace XINE {
190 xine_event_queue_t *m_queue; 195 xine_event_queue_t *m_queue;
191 196
192 void handleXineEvent( const xine_event_t* t ); 197 void handleXineEvent( const xine_event_t* t );
198 void handleXineEvent( int type );
193 void drawFrame( uint8_t* frame, int width, int height, int bytes ); 199 void drawFrame( uint8_t* frame, int width, int height, int bytes );
194 // C -> C++ bridge for the event system 200 // C -> C++ bridge for the event system
195 static void xine_event_handler( void* user_data, const xine_event_t* t); 201 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 @@
1/* This file is part of the KDE project
2 Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA.
18*/
19
20#include "threadutil.h"
21
22#include <qsocketnotifier.h>
23
24#include <pthread.h>
25#include <assert.h>
26#include <unistd.h>
27
28using namespace ThreadUtil;
29
30struct Mutex::Data
31{
32 Data()
33 {
34 pthread_mutex_init( &mutex, 0 );
35 }
36 ~Data()
37 {
38 pthread_mutex_destroy( &mutex );
39 }
40
41 pthread_mutex_t mutex;
42};
43
44Mutex::Mutex()
45 : d( new Data )
46{
47}
48
49Mutex::~Mutex()
50{
51 delete d;
52}
53
54void Mutex::lock()
55{
56 pthread_mutex_lock( &d->mutex );
57}
58
59void Mutex::unlock()
60{
61 pthread_mutex_unlock( &d->mutex );
62}
63
64bool Mutex::tryLock()
65{
66 return pthread_mutex_trylock( &d->mutex ) == 0;
67}
68
69bool Mutex::isLocked()
70{
71 if ( !tryLock() )
72 return true;
73
74 unlock();
75 return false;
76}
77
78struct WaitCondition::Data
79{
80 Data()
81 {
82 int result = pthread_cond_init( &waitCondition, 0 );
83 assert( result == 0 );
84 }
85 ~Data()
86 {
87 pthread_cond_destroy( &waitCondition );
88 }
89
90 pthread_cond_t waitCondition;
91};
92
93WaitCondition::WaitCondition()
94 : d( new Data )
95{
96}
97
98WaitCondition::~WaitCondition()
99{
100 delete d;
101}
102
103bool WaitCondition::wait()
104{
105 Mutex m;
106 m.lock();
107 return wait( m );
108}
109
110bool WaitCondition::wait( Mutex &mutex )
111{
112 return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex );
113}
114
115void WaitCondition::wakeOne()
116{
117 pthread_cond_signal( &d->waitCondition );
118}
119
120void WaitCondition::wakeAll()
121{
122 pthread_cond_broadcast( &d->waitCondition );
123}
124
125OnewayNotifier::OnewayNotifier()
126{
127 int fds[ 2 ];
128 pipe( fds );
129 m_readFd = fds[ 0 ];
130 m_writeFd = fds[ 1 ];
131
132 m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read );
133 connect( m_notifier, SIGNAL( activated( int ) ),
134 this, SLOT( wakeUp() ) );
135}
136
137OnewayNotifier::~OnewayNotifier()
138{
139 delete m_notifier;
140
141 ::close( m_readFd );
142 ::close( m_writeFd );
143}
144
145void OnewayNotifier::notify()
146{
147 const char c = 42;
148 ::write( m_writeFd, &c, 1 );
149}
150
151void OnewayNotifier::wakeUp()
152{
153 char c = 0;
154
155 if ( ::read( m_readFd, &c, 1 ) != 1 )
156 return;
157
158 emit awake();
159}
160
161ChannelMessage::ChannelMessage( int type )
162 : m_type( type ), m_isCall( false ), m_replied( false ),
163 m_inEventHandler( false )
164{
165}
166
167ChannelMessage::~ChannelMessage()
168{
169 if ( m_guard.isLocked() )
170 m_guard.unlock();
171}
172
173void ChannelMessage::reply()
174{
175 if ( !m_isCall )
176 {
177 qDebug( "ChannelMessage::reply() - can't reply oneway message!" );
178 return;
179 }
180
181 if ( m_inEventHandler )
182 {
183 m_replied = true;
184 return;
185 }
186
187 m_condition.wakeOne();
188 m_guard.unlock();
189}
190
191struct Channel::Private
192{
193 Private()
194 {
195 ownerThread = pthread_self();
196 }
197
198 pthread_t ownerThread;
199};
200
201Channel::Channel( QObject *parent, const char *name )
202 : QObject( parent, name ), d( new Private )
203{
204 connect( &m_notifier, SIGNAL( awake() ),
205 this, SLOT( deliver() ) );
206}
207
208Channel::~Channel()
209{
210 delete d;
211}
212
213void Channel::send( ChannelMessage *message, SendType type )
214{
215 if ( type == WaitForReply )
216 {
217 message->m_guard.lock();
218 message->m_isCall = true;
219 }
220
221 m_pendingMessagesGuard.lock();
222 m_pendingMessages << MsgEnvelope( type, message );
223 m_pendingMessagesGuard.unlock();
224
225 if ( d->ownerThread == pthread_self() ) {
226 assert( type != WaitForReply );
227
228 deliver();
229 }
230 else
231 m_notifier.notify();
232 //QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) );
233
234 if ( type == WaitForReply )
235 {
236 message->m_condition.wait( message->m_guard );
237 message->m_guard.unlock();
238 }
239}
240
241void Channel::deliver()
242{
243 AutoLock lock( m_pendingMessagesGuard );
244
245 while ( !m_pendingMessages.isEmpty() ) {
246 MsgEnvelope envelope = m_pendingMessages.first();
247
248 m_pendingMessages.remove( m_pendingMessages.begin() );
249
250 m_pendingMessagesGuard.unlock();
251 deliverOne( envelope );
252 m_pendingMessagesGuard.lock();
253 }
254}
255
256void Channel::deliverOne( const MsgEnvelope &envelope )
257{
258 ChannelMessage *msg = envelope.msg;
259
260 assert( msg );
261
262 if ( envelope.type == WaitForReply )
263 {
264 msg->m_guard.lock();
265 msg->m_inEventHandler = true;
266 }
267
268 receiveMessage( msg, envelope.type );
269
270 if ( envelope.type == WaitForReply )
271 {
272 msg->m_inEventHandler = false;
273 if ( msg->m_replied )
274 {
275 msg->m_condition.wakeOne();
276 // this is a bit tricky. we unlock only when we reply.
277 // reply() does an unlock as well.
278 msg->m_guard.unlock();
279 }
280 }
281}
282
283/* vim: et sw=4 ts=4
284 */
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 @@
1/* This file is part of the KDE project
2 Copyright (C) 1999 Simon Hausmann <hausmann@kde.org>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA.
18*/
19
20#ifndef THREADUTIL_H
21#define THREADUTIL_H
22
23#include <qvaluelist.h>
24#include <qobject.h>
25#include <qguardedptr.h>
26
27class QSocketNotifier;
28
29namespace ThreadUtil
30{
31
32 class Mutex
33 {
34 friend class WaitCondition;
35 public:
36 Mutex();
37 ~Mutex();
38
39 void lock();
40 void unlock();
41 bool tryLock();
42 bool isLocked();
43
44 private:
45 struct Data;
46 Data *d;
47
48 Mutex( const Mutex & );
49 Mutex &operator=( const Mutex & );
50 };
51
52 class AutoLock
53 {
54 public:
55 AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); }
56 ~AutoLock() { m_mutex.unlock(); }
57
58 Mutex *operator &() const { return &m_mutex; }
59
60 private:
61 Mutex &m_mutex;
62 };
63
64 class WaitCondition
65 {
66 public:
67 WaitCondition();
68 ~WaitCondition();
69
70 bool wait();
71 bool wait( Mutex &mutex );
72
73 void wakeOne();
74 void wakeAll();
75
76 private:
77 struct Data;
78 Data *d;
79
80 WaitCondition( const WaitCondition & );
81 WaitCondition &operator=( const WaitCondition & );
82 };
83
84 class OnewayNotifier : public QObject
85 {
86 Q_OBJECT
87 public:
88 OnewayNotifier();
89 ~OnewayNotifier();
90
91 void notify();
92
93 signals:
94 void awake();
95
96 private slots:
97 void wakeUp();
98
99 private:
100 int m_readFd;
101 int m_writeFd;
102 QSocketNotifier *m_notifier;
103 };
104
105
106 class Channel;
107
108 class ChannelMessage
109 {
110 friend class Channel;
111 public:
112 ChannelMessage( int type = -1 );
113 virtual ~ChannelMessage();
114
115 int type() const { return m_type; }
116
117 void reply();
118
119 private:
120 ChannelMessage( const ChannelMessage & );
121 ChannelMessage &operator=( const ChannelMessage );
122
123 int m_type;
124 bool m_isCall : 1;
125 bool m_replied : 1;
126 bool m_inEventHandler : 1;
127 Mutex m_guard;
128 WaitCondition m_condition;
129 QGuardedPtr<Channel> m_channel;
130 };
131
132 class Channel : public QObject
133 {
134 Q_OBJECT
135 public:
136 enum SendType { OneWay, WaitForReply };
137 Channel( QObject *parent = 0, const char *name = 0 );
138 virtual ~Channel();
139
140 void send( ChannelMessage *message, SendType type );
141
142 protected:
143 virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0;
144
145 private slots:
146 void deliver();
147
148 private:
149 OnewayNotifier m_notifier;
150
151 struct MsgEnvelope
152 {
153 MsgEnvelope() : type( OneWay ), msg( 0 ) {}
154 MsgEnvelope( SendType _type , ChannelMessage *_msg )
155 : type( _type ), msg( _msg ) {}
156
157 SendType type;
158 ChannelMessage *msg;
159 };
160
161 void deliverOne( const MsgEnvelope &envelope );
162
163 typedef QValueList<MsgEnvelope> MsgEnvelopeList;
164
165 MsgEnvelopeList m_pendingMessages;
166 Mutex m_pendingMessagesGuard;
167
168 struct Private;
169 Private *d;
170 };
171
172}
173
174#endif // THREADUTIL_H
175/* vim: et sw=4 ts=4
176 */