author | zecke <zecke> | 2004-09-24 15:09:56 (UTC) |
---|---|---|
committer | zecke <zecke> | 2004-09-24 15:09:56 (UTC) |
commit | 8e903cd3ea735adf066e156462602987691a4c69 (patch) (unidiff) | |
tree | b05fe7cc6d46cbacdc47fe3f0411100076bc8a52 | |
parent | 478b2ead47a09956cadfacb8f469fb2fdee5531c (diff) | |
download | opie-8e903cd3ea735adf066e156462602987691a4c69.zip opie-8e903cd3ea735adf066e156462602987691a4c69.tar.gz opie-8e903cd3ea735adf066e156462602987691a4c69.tar.bz2 |
-Emit Progress from the xine Engine to Global::statusMessage
-Change ThreadUtil to pass data and const char* among threads
-rw-r--r-- | noncore/multimedia/opieplayer2/lib.cpp | 18 | ||||
-rw-r--r-- | noncore/multimedia/opieplayer2/lib.h | 2 | ||||
-rw-r--r-- | noncore/multimedia/opieplayer2/threadutil.cpp | 17 | ||||
-rw-r--r-- | noncore/multimedia/opieplayer2/threadutil.h | 6 |
4 files changed, 28 insertions, 15 deletions
diff --git a/noncore/multimedia/opieplayer2/lib.cpp b/noncore/multimedia/opieplayer2/lib.cpp index 8afb318..f1b9773 100644 --- a/noncore/multimedia/opieplayer2/lib.cpp +++ b/noncore/multimedia/opieplayer2/lib.cpp | |||
@@ -1,168 +1,168 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of the Opie Project | 2 | This file is part of the Opie Project |
3 | 3 | ||
4 | Copyright (c) 2002 Max Reiss <harlekin@handhelds.org> | 4 | Copyright (c) 2002 Max Reiss <harlekin@handhelds.org> |
5 | Copyright (c) 2002 LJP <> | 5 | Copyright (c) 2002 LJP <> |
6 | Copyright (c) 2002 Holger Freyther <zecke@handhelds.org> | 6 | Copyright (c) 2002 Holger Freyther <zecke@handhelds.org> |
7 | =. | 7 | =. |
8 | .=l. | 8 | .=l. |
9 | .>+-= | 9 | .>+-= |
10 | _;:, .> :=|. This program is free software; you can | 10 | _;:, .> :=|. This program is free software; you can |
11 | .> <`_, > . <= redistribute it and/or modify it under | 11 | .> <`_, > . <= redistribute it and/or modify it under |
12 | :`=1 )Y*s>-.-- : the terms of the GNU General Public | 12 | :`=1 )Y*s>-.-- : the terms of the GNU General Public |
13 | .="- .-=="i, .._ License as published by the Free Software | 13 | .="- .-=="i, .._ License as published by the Free Software |
14 | - . .-<_> .<> Foundation; either version 2 of the License, | 14 | - . .-<_> .<> Foundation; either version 2 of the License, |
15 | ._= =} : or (at your option) any later version. | 15 | ._= =} : or (at your option) any later version. |
16 | .%`+i> _;_. | 16 | .%`+i> _;_. |
17 | .i_,=:_. -<s. This program is distributed in the hope that | 17 | .i_,=:_. -<s. This program is distributed in the hope that |
18 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | 18 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; |
19 | : .. .:, . . . without even the implied warranty of | 19 | : .. .:, . . . without even the implied warranty of |
20 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | 20 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A |
21 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | 21 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU |
22 | ..}^=.= = ; Library General Public License for more | 22 | ..}^=.= = ; Library General Public License for more |
23 | ++= -. .` .: details. | 23 | ++= -. .` .: details. |
24 | : = ...= . :.=- | 24 | : = ...= . :.=- |
25 | -. .:....=;==+<; You should have received a copy of the GNU | 25 | -. .:....=;==+<; You should have received a copy of the GNU |
26 | -_. . . )=. = Library General Public License along with | 26 | -_. . . )=. = Library General Public License along with |
27 | -- :-=` this library; see the file COPYING.LIB. | 27 | -- :-=` this library; see the file COPYING.LIB. |
28 | If not, write to the Free Software Foundation, | 28 | If not, write to the Free Software Foundation, |
29 | Inc., 59 Temple Place - Suite 330, | 29 | Inc., 59 Temple Place - Suite 330, |
30 | Boston, MA 02111-1307, USA. | 30 | Boston, MA 02111-1307, USA. |
31 | 31 | ||
32 | */ | 32 | */ |
33 | 33 | ||
34 | #include "xinevideowidget.h" | 34 | #include "xinevideowidget.h" |
35 | #include "frame.h" | 35 | #include "frame.h" |
36 | #include "lib.h" | 36 | #include "lib.h" |
37 | 37 | ||
38 | /* OPIE */ | 38 | /* OPIE */ |
39 | #include <opie2/odebug.h> | 39 | #include <opie2/odebug.h> |
40 | using namespace Opie::Core; | 40 | #include <qpe/global.h> |
41 | 41 | ||
42 | /* QT */ | 42 | /* QT */ |
43 | #include <qtextstream.h> | 43 | #include <qtextstream.h> |
44 | #include <qdir.h> | 44 | #include <qdir.h> |
45 | #include <qgfx_qws.h> | 45 | #include <qgfx_qws.h> |
46 | 46 | ||
47 | /* STD */ | 47 | /* STD */ |
48 | #include <assert.h> | 48 | #include <assert.h> |
49 | #include <unistd.h> | 49 | #include <unistd.h> |
50 | 50 | ||
51 | typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame, | 51 | typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame, |
52 | int width, int height,int bytes ); | 52 | int width, int height,int bytes ); |
53 | 53 | ||
54 | extern "C" { | 54 | extern "C" { |
55 | xine_vo_driver_t* init_video_out_plugin( xine_t *xine, void* video, display_xine_frame_t, void * ); | 55 | xine_vo_driver_t* init_video_out_plugin( xine_t *xine, void* video, display_xine_frame_t, void * ); |
56 | int null_is_showing_video( const xine_vo_driver_t* self ); | 56 | int null_is_showing_video( const xine_vo_driver_t* self ); |
57 | void null_set_show_video( const xine_vo_driver_t* self, int show ); | 57 | void null_set_show_video( const xine_vo_driver_t* self, int show ); |
58 | int null_is_fullscreen( const xine_vo_driver_t* self ); | 58 | int null_is_fullscreen( const xine_vo_driver_t* self ); |
59 | void null_set_fullscreen( const xine_vo_driver_t* self, int screen ); | 59 | void null_set_fullscreen( const xine_vo_driver_t* self, int screen ); |
60 | int null_is_scaling( const xine_vo_driver_t* self ); | 60 | int null_is_scaling( const xine_vo_driver_t* self ); |
61 | void null_set_scaling( const xine_vo_driver_t* self, int scale ); | 61 | void null_set_scaling( const xine_vo_driver_t* self, int scale ); |
62 | void null_set_gui_width( const xine_vo_driver_t* self, int width ); | 62 | void null_set_gui_width( const xine_vo_driver_t* self, int width ); |
63 | void null_set_gui_height( const xine_vo_driver_t* self, int height ); | 63 | void null_set_gui_height( const xine_vo_driver_t* self, int height ); |
64 | void null_set_mode( const xine_vo_driver_t* self, int depth, int rgb ); | 64 | void null_set_mode( const xine_vo_driver_t* self, int depth, int rgb ); |
65 | void null_set_videoGamma( const xine_vo_driver_t* self , int value ); | 65 | void null_set_videoGamma( const xine_vo_driver_t* self , int value ); |
66 | void null_display_handler( const xine_vo_driver_t* self, display_xine_frame_t t, void* user_data ); | 66 | void null_display_handler( const xine_vo_driver_t* self, display_xine_frame_t t, void* user_data ); |
67 | 67 | ||
68 | void null_preload_decoders( xine_stream_t *stream ); | 68 | void null_preload_decoders( xine_stream_t *stream ); |
69 | } | 69 | } |
70 | 70 | ||
71 | using namespace XINE; | 71 | using namespace XINE; |
72 | 72 | ||
73 | Lib::Lib( InitializationMode initMode, XineVideoWidget* widget ) | 73 | Lib::Lib( InitializationMode initMode, XineVideoWidget* widget ) |
74 | { | 74 | { |
75 | m_initialized = false; | 75 | m_initialized = false; |
76 | m_duringInitialization = false; | 76 | m_duringInitialization = false; |
77 | m_video = false; | 77 | m_video = false; |
78 | m_wid = widget; | 78 | m_wid = widget; |
79 | printf("Lib"); | 79 | printf("Lib"); |
80 | QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf"; | 80 | QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf"; |
81 | // get the configuration | 81 | // get the configuration |
82 | 82 | ||
83 | // not really OO, should be an extra class, later | 83 | // not really OO, should be an extra class, later |
84 | if ( !QFile::exists(configPath) ) { | 84 | if ( !QFile::exists(configPath) ) { |
85 | QFile f(configPath); | 85 | QFile f(configPath); |
86 | f.open(IO_WriteOnly); | 86 | f.open(IO_WriteOnly); |
87 | QTextStream ts( &f ); | 87 | QTextStream ts( &f ); |
88 | ts << "misc.memcpy_method:glibc\n"; | 88 | ts << "misc.memcpy_method:glibc\n"; |
89 | ts << "# uncomment if you experience double speed audio \n #audio.oss_sync_method:softsync\n"; | 89 | ts << "# uncomment if you experience double speed audio \n #audio.oss_sync_method:softsync\n"; |
90 | ts << "codec.ffmpeg_pp_quality:3\n"; | 90 | ts << "codec.ffmpeg_pp_quality:3\n"; |
91 | ts << "audio.num_buffers:50\n"; | 91 | ts << "audio.num_buffers:50\n"; |
92 | ts << "audio.size_buffers:4096\n"; | 92 | ts << "audio.size_buffers:4096\n"; |
93 | ts << "video.num_buffers:20\n"; | 93 | ts << "video.num_buffers:20\n"; |
94 | ts << "video.size_buffers:4096\n"; | 94 | ts << "video.size_buffers:4096\n"; |
95 | ts << "audio.out_num_audio_buf:16\n"; | 95 | ts << "audio.out_num_audio_buf:16\n"; |
96 | ts << "audio.out_size_audio_buf:8096\n"; | 96 | ts << "audio.out_size_audio_buf:8096\n"; |
97 | ts << "audio.out_size_zero_buf:1024\n"; | 97 | ts << "audio.out_size_zero_buf:1024\n"; |
98 | ts << "audio.passthrough_offset:0\n"; | 98 | ts << "audio.passthrough_offset:0\n"; |
99 | f.close(); | 99 | f.close(); |
100 | } | 100 | } |
101 | 101 | ||
102 | if ( initMode == InitializeImmediately ) { | 102 | if ( initMode == InitializeImmediately ) { |
103 | initialize(); | 103 | initialize(); |
104 | m_initialized = true; | 104 | m_initialized = true; |
105 | } | 105 | } |
106 | else | 106 | else |
107 | start(); | 107 | start(); |
108 | } | 108 | } |
109 | 109 | ||
110 | void Lib::run() | 110 | void Lib::run() |
111 | { | 111 | { |
112 | odebug << "Lib::run() started" << oendl; | 112 | odebug << "Lib::run() started" << oendl; |
113 | initialize(); | 113 | initialize(); |
114 | m_initialized = true; | 114 | m_initialized = true; |
115 | odebug << "Lib::run() finished" << oendl; | 115 | odebug << "Lib::run() finished" << oendl; |
116 | } | 116 | } |
117 | 117 | ||
118 | void Lib::initialize() | 118 | void Lib::initialize() |
119 | { | 119 | { |
120 | m_duringInitialization = true; | 120 | m_duringInitialization = true; |
121 | m_xine = xine_new( ); | 121 | m_xine = xine_new( ); |
122 | 122 | ||
123 | QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf"; | 123 | QString configPath = QDir::homeDirPath() + "/Settings/opiexine.cf"; |
124 | xine_config_load( m_xine, QFile::encodeName( configPath ) ); | 124 | xine_config_load( m_xine, QFile::encodeName( configPath ) ); |
125 | 125 | ||
126 | xine_init( m_xine ); | 126 | xine_init( m_xine ); |
127 | 127 | ||
128 | // allocate oss for sound | 128 | // allocate oss for sound |
129 | // and fb for framebuffer | 129 | // and fb for framebuffer |
130 | m_audioOutput = xine_open_audio_driver( m_xine, "oss", NULL ); | 130 | m_audioOutput = xine_open_audio_driver( m_xine, "oss", NULL ); |
131 | m_videoOutput = ::init_video_out_plugin( m_xine, NULL, xine_display_frame, this ); | 131 | m_videoOutput = ::init_video_out_plugin( m_xine, NULL, xine_display_frame, this ); |
132 | 132 | ||
133 | m_stream = xine_stream_new (m_xine, m_audioOutput, m_videoOutput ); | 133 | m_stream = xine_stream_new (m_xine, m_audioOutput, m_videoOutput ); |
134 | 134 | ||
135 | if (m_wid != 0 ) | 135 | if (m_wid != 0 ) |
136 | setWidget( m_wid ); | 136 | setWidget( m_wid ); |
137 | 137 | ||
138 | 138 | ||
139 | m_queue = xine_event_new_queue (m_stream); | 139 | m_queue = xine_event_new_queue (m_stream); |
140 | xine_event_create_listener_thread (m_queue, xine_event_handler, this); | 140 | xine_event_create_listener_thread (m_queue, xine_event_handler, this); |
141 | 141 | ||
142 | ::null_preload_decoders( m_stream ); | 142 | ::null_preload_decoders( m_stream ); |
143 | 143 | ||
144 | m_duringInitialization = false; | 144 | m_duringInitialization = false; |
145 | } | 145 | } |
146 | 146 | ||
147 | Lib::~Lib() { | 147 | Lib::~Lib() { |
148 | assert( isRunning() == false ); | 148 | assert( isRunning() == false ); |
149 | assert( m_initialized ); | 149 | assert( m_initialized ); |
150 | 150 | ||
151 | // free( m_config ); | 151 | // free( m_config ); |
152 | 152 | ||
153 | xine_close( m_stream ); | 153 | xine_close( m_stream ); |
154 | xine_event_dispose_queue( m_queue ); | 154 | xine_event_dispose_queue( m_queue ); |
155 | xine_dispose( m_stream ); | 155 | xine_dispose( m_stream ); |
156 | xine_exit( m_xine ); | 156 | xine_exit( m_xine ); |
157 | 157 | ||
158 | /* FIXME either free or delete but valgrind bitches against both */ | 158 | /* FIXME either free or delete but valgrind bitches against both */ |
159 | //free( m_videoOutput ); | 159 | //free( m_videoOutput ); |
160 | //delete m_audioOutput; | 160 | //delete m_audioOutput; |
161 | } | 161 | } |
162 | 162 | ||
163 | void Lib::resize ( const QSize &s ) { | 163 | void Lib::resize ( const QSize &s ) { |
164 | assert( m_initialized || m_duringInitialization ); | 164 | assert( m_initialized || m_duringInitialization ); |
165 | 165 | ||
166 | if ( s. width ( ) && s. height ( ) ) { | 166 | if ( s. width ( ) && s. height ( ) ) { |
167 | ::null_set_gui_width( m_videoOutput, s. width() ); | 167 | ::null_set_gui_width( m_videoOutput, s. width() ); |
168 | ::null_set_gui_height( m_videoOutput, s. height() ); | 168 | ::null_set_gui_height( m_videoOutput, s. height() ); |
@@ -201,214 +201,224 @@ int Lib::play( const QString& fileName, int startPos, int start_time ) { | |||
201 | 201 | ||
202 | void Lib::stop() { | 202 | void Lib::stop() { |
203 | assert( m_initialized ); | 203 | assert( m_initialized ); |
204 | xine_stop( m_stream ); | 204 | xine_stop( m_stream ); |
205 | } | 205 | } |
206 | 206 | ||
207 | void Lib::pause( bool toggle ) { | 207 | void Lib::pause( bool toggle ) { |
208 | assert( m_initialized ); | 208 | assert( m_initialized ); |
209 | 209 | ||
210 | xine_set_param( m_stream, XINE_PARAM_SPEED, toggle ? XINE_SPEED_PAUSE : XINE_SPEED_NORMAL ); | 210 | xine_set_param( m_stream, XINE_PARAM_SPEED, toggle ? XINE_SPEED_PAUSE : XINE_SPEED_NORMAL ); |
211 | } | 211 | } |
212 | 212 | ||
213 | int Lib::speed() const { | 213 | int Lib::speed() const { |
214 | assert( m_initialized ); | 214 | assert( m_initialized ); |
215 | 215 | ||
216 | return xine_get_param ( m_stream, XINE_PARAM_SPEED ); | 216 | return xine_get_param ( m_stream, XINE_PARAM_SPEED ); |
217 | } | 217 | } |
218 | 218 | ||
219 | void Lib::setSpeed( int speed ) { | 219 | void Lib::setSpeed( int speed ) { |
220 | assert( m_initialized ); | 220 | assert( m_initialized ); |
221 | 221 | ||
222 | xine_set_param ( m_stream, XINE_PARAM_SPEED, speed ); | 222 | xine_set_param ( m_stream, XINE_PARAM_SPEED, speed ); |
223 | } | 223 | } |
224 | 224 | ||
225 | int Lib::status() const { | 225 | int Lib::status() const { |
226 | assert( m_initialized ); | 226 | assert( m_initialized ); |
227 | 227 | ||
228 | return xine_get_status( m_stream ); | 228 | return xine_get_status( m_stream ); |
229 | } | 229 | } |
230 | 230 | ||
231 | int Lib::currentPosition() const { | 231 | int Lib::currentPosition() const { |
232 | assert( m_initialized ); | 232 | assert( m_initialized ); |
233 | 233 | ||
234 | int pos, time, length; | 234 | int pos, time, length; |
235 | xine_get_pos_length( m_stream, &pos, &time, &length ); | 235 | xine_get_pos_length( m_stream, &pos, &time, &length ); |
236 | return pos; | 236 | return pos; |
237 | } | 237 | } |
238 | 238 | ||
239 | int Lib::currentTime() const { | 239 | int Lib::currentTime() const { |
240 | assert( m_initialized ); | 240 | assert( m_initialized ); |
241 | 241 | ||
242 | int pos, time, length; | 242 | int pos, time, length; |
243 | pos = time = length = 0; | 243 | pos = time = length = 0; |
244 | 244 | ||
245 | if ( xine_get_pos_length( m_stream, &pos, &time, &length ) ) | 245 | if ( xine_get_pos_length( m_stream, &pos, &time, &length ) ) |
246 | return time/1000; | 246 | return time/1000; |
247 | else | 247 | else |
248 | return 0; | 248 | return 0; |
249 | } | 249 | } |
250 | 250 | ||
251 | int Lib::length() const { | 251 | int Lib::length() const { |
252 | assert( m_initialized ); | 252 | assert( m_initialized ); |
253 | 253 | ||
254 | int pos, time, length; | 254 | int pos, time, length; |
255 | /* dilb: patch to solve the wrong stream length reported to the GUI*/ | 255 | /* dilb: patch to solve the wrong stream length reported to the GUI*/ |
256 | int iRetVal=0, iTestLoop=0; | 256 | int iRetVal=0, iTestLoop=0; |
257 | 257 | ||
258 | do | 258 | do |
259 | { | 259 | { |
260 | iRetVal = xine_get_pos_length( m_stream, &pos, &time, &length ); | 260 | iRetVal = xine_get_pos_length( m_stream, &pos, &time, &length ); |
261 | if (iRetVal) | 261 | if (iRetVal) |
262 | {/* if the function didn't return 0, then pos, time and length are valid.*/ | 262 | {/* if the function didn't return 0, then pos, time and length are valid.*/ |
263 | return length/1000; | 263 | return length/1000; |
264 | } | 264 | } |
265 | /*don't poll too much*/ | 265 | /*don't poll too much*/ |
266 | usleep(100000); | 266 | usleep(100000); |
267 | iTestLoop++; | 267 | iTestLoop++; |
268 | } | 268 | } |
269 | while ( iTestLoop < 10 ); /* if after 1s, we still don't have any | 269 | while ( iTestLoop < 10 ); /* if after 1s, we still don't have any |
270 | valid stream, then return -1 (this value could be used to make the stream | 270 | valid stream, then return -1 (this value could be used to make the stream |
271 | unseekable, but it should never occur!! Mr. Murphy ? :) ) */ | 271 | unseekable, but it should never occur!! Mr. Murphy ? :) ) */ |
272 | 272 | ||
273 | return -1; | 273 | return -1; |
274 | } | 274 | } |
275 | 275 | ||
276 | bool Lib::isSeekable() const { | 276 | bool Lib::isSeekable() const { |
277 | assert( m_initialized ); | 277 | assert( m_initialized ); |
278 | 278 | ||
279 | return xine_get_stream_info( m_stream, XINE_STREAM_INFO_SEEKABLE ); | 279 | return xine_get_stream_info( m_stream, XINE_STREAM_INFO_SEEKABLE ); |
280 | } | 280 | } |
281 | 281 | ||
282 | void Lib::seekTo( int time ) { | 282 | void Lib::seekTo( int time ) { |
283 | assert( m_initialized ); | 283 | assert( m_initialized ); |
284 | 284 | ||
285 | xine_play( m_stream, 0, time*1000 ); | 285 | xine_play( m_stream, 0, time*1000 ); |
286 | } | 286 | } |
287 | 287 | ||
288 | 288 | ||
289 | Frame Lib::currentFrame() const { | 289 | Frame Lib::currentFrame() const { |
290 | assert( m_initialized ); | 290 | assert( m_initialized ); |
291 | 291 | ||
292 | Frame frame; | 292 | Frame frame; |
293 | return frame; | 293 | return frame; |
294 | }; | 294 | }; |
295 | 295 | ||
296 | QString Lib::metaInfo( int number) const { | 296 | QString Lib::metaInfo( int number) const { |
297 | assert( m_initialized ); | 297 | assert( m_initialized ); |
298 | 298 | ||
299 | return xine_get_meta_info( m_stream, number ); | 299 | return xine_get_meta_info( m_stream, number ); |
300 | } | 300 | } |
301 | 301 | ||
302 | int Lib::error() const { | 302 | int Lib::error() const { |
303 | assert( m_initialized ); | 303 | assert( m_initialized ); |
304 | 304 | ||
305 | return xine_get_error( m_stream ); | 305 | return xine_get_error( m_stream ); |
306 | }; | 306 | }; |
307 | 307 | ||
308 | void Lib::ensureInitialized() | 308 | void Lib::ensureInitialized() |
309 | { | 309 | { |
310 | if ( m_initialized ) | 310 | if ( m_initialized ) |
311 | return; | 311 | return; |
312 | 312 | ||
313 | odebug << "waiting for initialization thread to finish" << oendl; | 313 | odebug << "waiting for initialization thread to finish" << oendl; |
314 | wait(); | 314 | wait(); |
315 | odebug << "initialization thread finished!" << oendl; | 315 | odebug << "initialization thread finished!" << oendl; |
316 | } | 316 | } |
317 | 317 | ||
318 | void Lib::setWidget( XineVideoWidget *widget ) | 318 | void Lib::setWidget( XineVideoWidget *widget ) |
319 | { | 319 | { |
320 | m_wid = widget; | 320 | m_wid = widget; |
321 | resize ( m_wid-> size ( ) ); | 321 | resize ( m_wid-> size ( ) ); |
322 | ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() ); | 322 | ::null_set_mode( m_videoOutput, qt_screen->depth(), qt_screen->pixelType() ); |
323 | m_wid->repaint(); | 323 | m_wid->repaint(); |
324 | } | 324 | } |
325 | 325 | ||
326 | void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ) | 326 | void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ) |
327 | { | 327 | { |
328 | assert( sendType == ThreadUtil::Channel::OneWay ); | 328 | assert( sendType == ThreadUtil::Channel::OneWay ); |
329 | handleXineEvent( msg->type() ); | 329 | handleXineEvent( msg->type(), msg->data(), msg->msg() ); |
330 | delete msg; | 330 | delete msg; |
331 | } | 331 | } |
332 | 332 | ||
333 | void Lib::handleXineEvent( const xine_event_t* t ) { | 333 | void Lib::handleXineEvent( const xine_event_t* t ) { |
334 | send( new ThreadUtil::ChannelMessage( t->type ), OneWay ); | 334 | int prog = -1; const char* name = 0; |
335 | if ( t->type == XINE_EVENT_PROGRESS ) { | ||
336 | xine_progress_data_t *pt = static_cast<xine_progress_data_t*>( t->data ); | ||
337 | prog = pt->percent; | ||
338 | name = pt->description; | ||
339 | } | ||
340 | |||
341 | send( new ThreadUtil::ChannelMessage( t->type, prog, name ), OneWay ); | ||
335 | } | 342 | } |
336 | 343 | ||
337 | void Lib::handleXineEvent( int type ) { | 344 | void Lib::handleXineEvent( int type, int data, const char* name ) { |
338 | assert( m_initialized ); | 345 | assert( m_initialized ); |
339 | 346 | ||
340 | if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) { | 347 | if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) { |
341 | emit stopped(); | 348 | emit stopped(); |
349 | }else if ( type == XINE_EVENT_PROGRESS ) { | ||
350 | QString str = name == 0 ? QString::null : QString::fromUtf8( name ); | ||
351 | Global::statusMessage( tr( "Progress: %1 %2" ).arg( name, data ) );; | ||
342 | } | 352 | } |
343 | } | 353 | } |
344 | 354 | ||
345 | 355 | ||
346 | void Lib::setShowVideo( bool video ) { | 356 | void Lib::setShowVideo( bool video ) { |
347 | assert( m_initialized ); | 357 | assert( m_initialized ); |
348 | 358 | ||
349 | m_video = video; | 359 | m_video = video; |
350 | ::null_set_show_video( m_videoOutput, video ); | 360 | ::null_set_show_video( m_videoOutput, video ); |
351 | } | 361 | } |
352 | 362 | ||
353 | bool Lib::isShowingVideo() const { | 363 | bool Lib::isShowingVideo() const { |
354 | assert( m_initialized ); | 364 | assert( m_initialized ); |
355 | 365 | ||
356 | return ::null_is_showing_video( m_videoOutput ); | 366 | return ::null_is_showing_video( m_videoOutput ); |
357 | } | 367 | } |
358 | 368 | ||
359 | bool Lib::hasVideo() const { | 369 | bool Lib::hasVideo() const { |
360 | assert( m_initialized ); | 370 | assert( m_initialized ); |
361 | 371 | ||
362 | return xine_get_stream_info( m_stream, 18 ); | 372 | return xine_get_stream_info( m_stream, 18 ); |
363 | } | 373 | } |
364 | 374 | ||
365 | void Lib::showVideoFullScreen( bool fullScreen ) { | 375 | void Lib::showVideoFullScreen( bool fullScreen ) { |
366 | assert( m_initialized ); | 376 | assert( m_initialized ); |
367 | 377 | ||
368 | ::null_set_fullscreen( m_videoOutput, fullScreen ); | 378 | ::null_set_fullscreen( m_videoOutput, fullScreen ); |
369 | } | 379 | } |
370 | 380 | ||
371 | bool Lib::isVideoFullScreen() const { | 381 | bool Lib::isVideoFullScreen() const { |
372 | assert( m_initialized ); | 382 | assert( m_initialized ); |
373 | 383 | ||
374 | return ::null_is_fullscreen( m_videoOutput ); | 384 | return ::null_is_fullscreen( m_videoOutput ); |
375 | } | 385 | } |
376 | 386 | ||
377 | void Lib::setScaling( bool scale ) { | 387 | void Lib::setScaling( bool scale ) { |
378 | assert( m_initialized ); | 388 | assert( m_initialized ); |
379 | 389 | ||
380 | ::null_set_scaling( m_videoOutput, scale ); | 390 | ::null_set_scaling( m_videoOutput, scale ); |
381 | } | 391 | } |
382 | 392 | ||
383 | void Lib::setGamma( int value ) { | 393 | void Lib::setGamma( int value ) { |
384 | assert( m_initialized ); | 394 | assert( m_initialized ); |
385 | 395 | ||
386 | ::null_set_videoGamma( m_videoOutput, value ); | 396 | ::null_set_videoGamma( m_videoOutput, value ); |
387 | } | 397 | } |
388 | 398 | ||
389 | bool Lib::isScaling() const { | 399 | bool Lib::isScaling() const { |
390 | assert( m_initialized ); | 400 | assert( m_initialized ); |
391 | 401 | ||
392 | return ::null_is_scaling( m_videoOutput ); | 402 | return ::null_is_scaling( m_videoOutput ); |
393 | } | 403 | } |
394 | 404 | ||
395 | void Lib::xine_event_handler( void* user_data, const xine_event_t* t ) { | 405 | void Lib::xine_event_handler( void* user_data, const xine_event_t* t ) { |
396 | ( (Lib*)user_data)->handleXineEvent( t ); | 406 | ( (Lib*)user_data)->handleXineEvent( t ); |
397 | } | 407 | } |
398 | 408 | ||
399 | void Lib::xine_display_frame( void* user_data, uint8_t *frame, | 409 | void Lib::xine_display_frame( void* user_data, uint8_t *frame, |
400 | int width, int height, int bytes ) { | 410 | int width, int height, int bytes ) { |
401 | ( (Lib*)user_data)->drawFrame( frame, width, height, bytes ); | 411 | ( (Lib*)user_data)->drawFrame( frame, width, height, bytes ); |
402 | } | 412 | } |
403 | 413 | ||
404 | void Lib::drawFrame( uint8_t* frame, int width, int height, int bytes ) { | 414 | void Lib::drawFrame( uint8_t* frame, int width, int height, int bytes ) { |
405 | assert( m_initialized ); | 415 | assert( m_initialized ); |
406 | 416 | ||
407 | if ( !m_video ) { | 417 | if ( !m_video ) { |
408 | return; | 418 | return; |
409 | } | 419 | } |
410 | 420 | ||
411 | assert( m_wid ); | 421 | assert( m_wid ); |
412 | 422 | ||
413 | m_wid-> setVideoFrame ( frame, width, height, bytes ); | 423 | m_wid-> setVideoFrame ( frame, width, height, bytes ); |
414 | } | 424 | } |
diff --git a/noncore/multimedia/opieplayer2/lib.h b/noncore/multimedia/opieplayer2/lib.h index 0ff14d0..dfddc2a 100644 --- a/noncore/multimedia/opieplayer2/lib.h +++ b/noncore/multimedia/opieplayer2/lib.h | |||
@@ -78,139 +78,139 @@ namespace XINE { | |||
78 | * Set the speed of the stream, if codec supports it | 78 | * Set the speed of the stream, if codec supports it |
79 | * XINE_SPEED_PAUSE 0 | 79 | * XINE_SPEED_PAUSE 0 |
80 | * XINE_SPEED_SLOW_4 1 | 80 | * XINE_SPEED_SLOW_4 1 |
81 | * XINE_SPEED_SLOW_2 2 | 81 | * XINE_SPEED_SLOW_2 2 |
82 | * XINE_SPEED_NORMAL 4 | 82 | * XINE_SPEED_NORMAL 4 |
83 | * XINE_SPEED_FAST_2 8 | 83 | * XINE_SPEED_FAST_2 8 |
84 | *XINE_SPEED_FAST_4 16 | 84 | *XINE_SPEED_FAST_4 16 |
85 | */ | 85 | */ |
86 | void setSpeed( int speed = XINE_SPEED_PAUSE ); | 86 | void setSpeed( int speed = XINE_SPEED_PAUSE ); |
87 | 87 | ||
88 | int status() const; | 88 | int status() const; |
89 | 89 | ||
90 | int currentPosition()const; | 90 | int currentPosition()const; |
91 | //in seconds | 91 | //in seconds |
92 | int currentTime()const; | 92 | int currentTime()const; |
93 | 93 | ||
94 | int length() const; | 94 | int length() const; |
95 | 95 | ||
96 | bool isSeekable()const; | 96 | bool isSeekable()const; |
97 | 97 | ||
98 | /** | 98 | /** |
99 | * Whether or not to show video output | 99 | * Whether or not to show video output |
100 | */ | 100 | */ |
101 | void setShowVideo(bool video); | 101 | void setShowVideo(bool video); |
102 | 102 | ||
103 | /** | 103 | /** |
104 | * is we show video | 104 | * is we show video |
105 | */ | 105 | */ |
106 | bool isShowingVideo() const; | 106 | bool isShowingVideo() const; |
107 | 107 | ||
108 | /** | 108 | /** |
109 | * | 109 | * |
110 | */ | 110 | */ |
111 | void showVideoFullScreen( bool fullScreen ); | 111 | void showVideoFullScreen( bool fullScreen ); |
112 | 112 | ||
113 | /** | 113 | /** |
114 | * | 114 | * |
115 | */ | 115 | */ |
116 | bool isVideoFullScreen() const; | 116 | bool isVideoFullScreen() const; |
117 | 117 | ||
118 | 118 | ||
119 | /** | 119 | /** |
120 | * Get the meta info (like author etc) from the stream | 120 | * Get the meta info (like author etc) from the stream |
121 | * XINE_META_INFO_TITLE 0 | 121 | * XINE_META_INFO_TITLE 0 |
122 | * XINE_META_INFO_COMMENT 1 | 122 | * XINE_META_INFO_COMMENT 1 |
123 | * XINE_META_INFO_ARTIST 2 | 123 | * XINE_META_INFO_ARTIST 2 |
124 | * XINE_META_INFO_GENRE 3 | 124 | * XINE_META_INFO_GENRE 3 |
125 | * XINE_META_INFO_ALBUM 4 | 125 | * XINE_META_INFO_ALBUM 4 |
126 | * XINE_META_INFO_YEAR 5 | 126 | * XINE_META_INFO_YEAR 5 |
127 | * XINE_META_INFO_VIDEOCODEC 6 | 127 | * XINE_META_INFO_VIDEOCODEC 6 |
128 | * XINE_META_INFO_AUDIOCODEC 7 | 128 | * XINE_META_INFO_AUDIOCODEC 7 |
129 | * XINE_META_INFO_SYSTEMLAYER 8 | 129 | * XINE_META_INFO_SYSTEMLAYER 8 |
130 | * XINE_META_INFO_INPUT_PLUGIN 9 | 130 | * XINE_META_INFO_INPUT_PLUGIN 9 |
131 | */ | 131 | */ |
132 | QString metaInfo( int number ) const; | 132 | QString metaInfo( int number ) const; |
133 | 133 | ||
134 | /** | 134 | /** |
135 | * | 135 | * |
136 | */ | 136 | */ |
137 | bool isScaling() const; | 137 | bool isScaling() const; |
138 | 138 | ||
139 | /** | 139 | /** |
140 | * seek to a position | 140 | * seek to a position |
141 | */ | 141 | */ |
142 | void seekTo( int time ); | 142 | void seekTo( int time ); |
143 | 143 | ||
144 | /** | 144 | /** |
145 | * | 145 | * |
146 | * @return is media stream has video | 146 | * @return is media stream has video |
147 | */ | 147 | */ |
148 | bool hasVideo() const; | 148 | bool hasVideo() const; |
149 | 149 | ||
150 | /** | 150 | /** |
151 | * | 151 | * |
152 | */ | 152 | */ |
153 | void setScaling( bool ); | 153 | void setScaling( bool ); |
154 | 154 | ||
155 | /** | 155 | /** |
156 | * Set the Gamma value for video output | 156 | * Set the Gamma value for video output |
157 | * @param int the value between -100 and 100, 0 is original | 157 | * @param int the value between -100 and 100, 0 is original |
158 | */ | 158 | */ |
159 | void setGamma( int ); | 159 | void setGamma( int ); |
160 | 160 | ||
161 | /** | 161 | /** |
162 | * test | 162 | * test |
163 | */ | 163 | */ |
164 | Frame currentFrame() const; | 164 | Frame currentFrame() const; |
165 | 165 | ||
166 | /** | 166 | /** |
167 | * Returns the error code | 167 | * Returns the error code |
168 | * XINE_ERROR_NONE 0 | 168 | * XINE_ERROR_NONE 0 |
169 | * XINE_ERROR_NO_INPUT_PLUGIN 1 | 169 | * XINE_ERROR_NO_INPUT_PLUGIN 1 |
170 | * XINE_ERROR_NO_DEMUXER_PLUGIN 2 | 170 | * XINE_ERROR_NO_DEMUXER_PLUGIN 2 |
171 | * XINE_ERROR_DEMUXER_FAILED 3 | 171 | * XINE_ERROR_DEMUXER_FAILED 3 |
172 | */ | 172 | */ |
173 | int error() const; | 173 | int error() const; |
174 | 174 | ||
175 | void ensureInitialized(); | 175 | void ensureInitialized(); |
176 | 176 | ||
177 | void setWidget( XineVideoWidget *widget ); | 177 | void setWidget( XineVideoWidget *widget ); |
178 | 178 | ||
179 | signals: | 179 | signals: |
180 | 180 | ||
181 | void stopped(); | 181 | void stopped(); |
182 | 182 | ||
183 | void initialized(); | 183 | void initialized(); |
184 | 184 | ||
185 | protected: | 185 | protected: |
186 | virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ); | 186 | virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ); |
187 | 187 | ||
188 | virtual void run(); | 188 | virtual void run(); |
189 | 189 | ||
190 | private: | 190 | private: |
191 | void initialize(); | 191 | void initialize(); |
192 | 192 | ||
193 | int m_bytes_per_pixel; | 193 | int m_bytes_per_pixel; |
194 | bool m_initialized:1; | 194 | bool m_initialized:1; |
195 | bool m_duringInitialization:1; | 195 | bool m_duringInitialization:1; |
196 | bool m_video:1; | 196 | bool m_video:1; |
197 | XineVideoWidget *m_wid; | 197 | XineVideoWidget *m_wid; |
198 | xine_t *m_xine; | 198 | xine_t *m_xine; |
199 | xine_stream_t *m_stream; | 199 | xine_stream_t *m_stream; |
200 | xine_cfg_entry_t *m_config; | 200 | xine_cfg_entry_t *m_config; |
201 | xine_vo_driver_t *m_videoOutput; | 201 | xine_vo_driver_t *m_videoOutput; |
202 | xine_ao_driver_t* m_audioOutput; | 202 | xine_ao_driver_t* m_audioOutput; |
203 | xine_event_queue_t *m_queue; | 203 | xine_event_queue_t *m_queue; |
204 | 204 | ||
205 | void handleXineEvent( const xine_event_t* t ); | 205 | void handleXineEvent( const xine_event_t* t ); |
206 | void handleXineEvent( int type ); | 206 | void handleXineEvent( int type, int data, const char* name ); |
207 | void drawFrame( uint8_t* frame, int width, int height, int bytes ); | 207 | void drawFrame( uint8_t* frame, int width, int height, int bytes ); |
208 | // C -> C++ bridge for the event system | 208 | // C -> C++ bridge for the event system |
209 | static void xine_event_handler( void* user_data, const xine_event_t* t); | 209 | static void xine_event_handler( void* user_data, const xine_event_t* t); |
210 | static void xine_display_frame( void* user_data, uint8_t* frame , | 210 | static void xine_display_frame( void* user_data, uint8_t* frame , |
211 | int width, int height, int bytes ); | 211 | int width, int height, int bytes ); |
212 | }; | 212 | }; |
213 | }; | 213 | }; |
214 | 214 | ||
215 | 215 | ||
216 | #endif | 216 | #endif |
diff --git a/noncore/multimedia/opieplayer2/threadutil.cpp b/noncore/multimedia/opieplayer2/threadutil.cpp index 6ed9853..b5cac61 100644 --- a/noncore/multimedia/opieplayer2/threadutil.cpp +++ b/noncore/multimedia/opieplayer2/threadutil.cpp | |||
@@ -1,395 +1,394 @@ | |||
1 | /* This file is part of the KDE project | 1 | /* This file is part of the KDE project |
2 | Copyright (C) 2002 Simon Hausmann <hausmann@kde.org> | 2 | Copyright (C) 2002 Simon Hausmann <hausmann@kde.org> |
3 | 3 | ||
4 | This library is free software; you can redistribute it and/or | 4 | This library is free software; you can redistribute it and/or |
5 | modify it under the terms of the GNU Library General Public | 5 | modify it under the terms of the GNU Library General Public |
6 | License as published by the Free Software Foundation; either | 6 | License as published by the Free Software Foundation; either |
7 | version 2 of the License, or (at your option) any later version. | 7 | version 2 of the License, or (at your option) any later version. |
8 | 8 | ||
9 | This library is distributed in the hope that it will be useful, | 9 | This library is distributed in the hope that it will be useful, |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | Library General Public License for more details. | 12 | Library General Public License for more details. |
13 | 13 | ||
14 | You should have received a copy of the GNU Library General Public License | 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 | 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, | 16 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
17 | Boston, MA 02111-1307, USA. | 17 | Boston, MA 02111-1307, USA. |
18 | */ | 18 | */ |
19 | 19 | ||
20 | #include "threadutil.h" | 20 | #include "threadutil.h" |
21 | 21 | ||
22 | #include <opie2/odebug.h> | 22 | #include <opie2/odebug.h> |
23 | #include <qsocketnotifier.h> | 23 | #include <qsocketnotifier.h> |
24 | 24 | ||
25 | #include <pthread.h> | 25 | #include <pthread.h> |
26 | #include <assert.h> | 26 | #include <assert.h> |
27 | #include <unistd.h> | 27 | #include <unistd.h> |
28 | #include <errno.h> | 28 | #include <errno.h> |
29 | 29 | ||
30 | using namespace ThreadUtil; | 30 | using namespace ThreadUtil; |
31 | 31 | ||
32 | struct Mutex::Data | 32 | struct Mutex::Data |
33 | { | 33 | { |
34 | Data() | 34 | Data() |
35 | { | 35 | { |
36 | pthread_mutex_init( &mutex, 0 ); | 36 | pthread_mutex_init( &mutex, 0 ); |
37 | } | 37 | } |
38 | ~Data() | 38 | ~Data() |
39 | { | 39 | { |
40 | pthread_mutex_destroy( &mutex ); | 40 | pthread_mutex_destroy( &mutex ); |
41 | } | 41 | } |
42 | 42 | ||
43 | pthread_mutex_t mutex; | 43 | pthread_mutex_t mutex; |
44 | }; | 44 | }; |
45 | 45 | ||
46 | Mutex::Mutex() | 46 | Mutex::Mutex() |
47 | : d( new Data ) | 47 | : d( new Data ) |
48 | { | 48 | { |
49 | } | 49 | } |
50 | 50 | ||
51 | Mutex::~Mutex() | 51 | Mutex::~Mutex() |
52 | { | 52 | { |
53 | delete d; | 53 | delete d; |
54 | } | 54 | } |
55 | 55 | ||
56 | void Mutex::lock() | 56 | void Mutex::lock() |
57 | { | 57 | { |
58 | pthread_mutex_lock( &d->mutex ); | 58 | pthread_mutex_lock( &d->mutex ); |
59 | } | 59 | } |
60 | 60 | ||
61 | void Mutex::unlock() | 61 | void Mutex::unlock() |
62 | { | 62 | { |
63 | pthread_mutex_unlock( &d->mutex ); | 63 | pthread_mutex_unlock( &d->mutex ); |
64 | } | 64 | } |
65 | 65 | ||
66 | bool Mutex::tryLock() | 66 | bool Mutex::tryLock() |
67 | { | 67 | { |
68 | return pthread_mutex_trylock( &d->mutex ) == 0; | 68 | return pthread_mutex_trylock( &d->mutex ) == 0; |
69 | } | 69 | } |
70 | 70 | ||
71 | bool Mutex::isLocked() | 71 | bool Mutex::isLocked() |
72 | { | 72 | { |
73 | if ( !tryLock() ) | 73 | if ( !tryLock() ) |
74 | return true; | 74 | return true; |
75 | 75 | ||
76 | unlock(); | 76 | unlock(); |
77 | return false; | 77 | return false; |
78 | } | 78 | } |
79 | 79 | ||
80 | struct WaitCondition::Data | 80 | struct WaitCondition::Data |
81 | { | 81 | { |
82 | Data() | 82 | Data() |
83 | { | 83 | { |
84 | int result = pthread_cond_init( &waitCondition, 0 ); | 84 | int result = pthread_cond_init( &waitCondition, 0 ); |
85 | assert( result == 0 ); | 85 | assert( result == 0 ); |
86 | } | 86 | } |
87 | ~Data() | 87 | ~Data() |
88 | { | 88 | { |
89 | pthread_cond_destroy( &waitCondition ); | 89 | pthread_cond_destroy( &waitCondition ); |
90 | } | 90 | } |
91 | 91 | ||
92 | pthread_cond_t waitCondition; | 92 | pthread_cond_t waitCondition; |
93 | }; | 93 | }; |
94 | 94 | ||
95 | WaitCondition::WaitCondition() | 95 | WaitCondition::WaitCondition() |
96 | : d( new Data ) | 96 | : d( new Data ) |
97 | { | 97 | { |
98 | } | 98 | } |
99 | 99 | ||
100 | WaitCondition::~WaitCondition() | 100 | WaitCondition::~WaitCondition() |
101 | { | 101 | { |
102 | delete d; | 102 | delete d; |
103 | } | 103 | } |
104 | 104 | ||
105 | bool WaitCondition::wait() | 105 | bool WaitCondition::wait() |
106 | { | 106 | { |
107 | Mutex m; | 107 | Mutex m; |
108 | m.lock(); | 108 | m.lock(); |
109 | return wait( m ); | 109 | return wait( m ); |
110 | } | 110 | } |
111 | 111 | ||
112 | bool WaitCondition::wait( Mutex &mutex ) | 112 | bool WaitCondition::wait( Mutex &mutex ) |
113 | { | 113 | { |
114 | return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex ); | 114 | return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex ); |
115 | } | 115 | } |
116 | 116 | ||
117 | void WaitCondition::wakeOne() | 117 | void WaitCondition::wakeOne() |
118 | { | 118 | { |
119 | pthread_cond_signal( &d->waitCondition ); | 119 | pthread_cond_signal( &d->waitCondition ); |
120 | } | 120 | } |
121 | 121 | ||
122 | void WaitCondition::wakeAll() | 122 | void WaitCondition::wakeAll() |
123 | { | 123 | { |
124 | pthread_cond_broadcast( &d->waitCondition ); | 124 | pthread_cond_broadcast( &d->waitCondition ); |
125 | } | 125 | } |
126 | 126 | ||
127 | struct Thread::Data | 127 | struct Thread::Data |
128 | { | 128 | { |
129 | Data() : isRunning( false ) | 129 | Data() : isRunning( false ) |
130 | {} | 130 | {} |
131 | 131 | ||
132 | pthread_t self; | 132 | pthread_t self; |
133 | Mutex guard; | 133 | Mutex guard; |
134 | bool isRunning; | 134 | bool isRunning; |
135 | 135 | ||
136 | WaitCondition finishCondition; | 136 | WaitCondition finishCondition; |
137 | 137 | ||
138 | Thread *thr; | 138 | Thread *thr; |
139 | 139 | ||
140 | void run() { thr->run(); } | 140 | void run() { thr->run(); } |
141 | }; | 141 | }; |
142 | 142 | ||
143 | extern "C" | 143 | extern "C" |
144 | { | 144 | { |
145 | 145 | ||
146 | static void terminate_thread( void *arg ) | 146 | static void terminate_thread( void *arg ) |
147 | { | 147 | { |
148 | Thread::Data *data = ( Thread::Data* )arg; | 148 | Thread::Data *data = ( Thread::Data* )arg; |
149 | 149 | ||
150 | assert( data ); | 150 | assert( data ); |
151 | 151 | ||
152 | AutoLock locker( data->guard ); | 152 | AutoLock locker( data->guard ); |
153 | data->isRunning = false; | 153 | data->isRunning = false; |
154 | data->finishCondition.wakeAll(); | 154 | data->finishCondition.wakeAll(); |
155 | } | 155 | } |
156 | 156 | ||
157 | static void *start_thread( void *arg ) | 157 | static void *start_thread( void *arg ) |
158 | { | 158 | { |
159 | Thread::Data *data = ( Thread::Data* )arg; | 159 | Thread::Data *data = ( Thread::Data* )arg; |
160 | 160 | ||
161 | pthread_cleanup_push( terminate_thread, data ); | 161 | pthread_cleanup_push( terminate_thread, data ); |
162 | 162 | ||
163 | data->isRunning = true; | 163 | data->isRunning = true; |
164 | data->run(); | 164 | data->run(); |
165 | 165 | ||
166 | pthread_cleanup_pop( true ); | 166 | pthread_cleanup_pop( true ); |
167 | 167 | ||
168 | Thread::exit(); | 168 | Thread::exit(); |
169 | return 0; // never reached | 169 | return 0; // never reached |
170 | } | 170 | } |
171 | 171 | ||
172 | } | 172 | } |
173 | 173 | ||
174 | Thread::Thread() | 174 | Thread::Thread() |
175 | : d( new Data ) | 175 | : d( new Data ) |
176 | { | 176 | { |
177 | d->thr = this; | 177 | d->thr = this; |
178 | } | 178 | } |
179 | 179 | ||
180 | Thread::~Thread() | 180 | Thread::~Thread() |
181 | { | 181 | { |
182 | assert( d->isRunning == false ); | 182 | assert( d->isRunning == false ); |
183 | delete d; | 183 | delete d; |
184 | } | 184 | } |
185 | 185 | ||
186 | void Thread::start() | 186 | void Thread::start() |
187 | { | 187 | { |
188 | AutoLock lock( d->guard ); | 188 | AutoLock lock( d->guard ); |
189 | 189 | ||
190 | if ( d->isRunning ) { | 190 | if ( d->isRunning ) { |
191 | odebug << "ThreadUtil::Thread::start() called for running thread." << oendl; | 191 | odebug << "ThreadUtil::Thread::start() called for running thread." << oendl; |
192 | return; | 192 | return; |
193 | } | 193 | } |
194 | 194 | ||
195 | pthread_attr_t attributes; | 195 | pthread_attr_t attributes; |
196 | pthread_attr_init( &attributes ); | 196 | pthread_attr_init( &attributes ); |
197 | pthread_attr_setscope( &attributes, PTHREAD_SCOPE_SYSTEM ); | 197 | pthread_attr_setscope( &attributes, PTHREAD_SCOPE_SYSTEM ); |
198 | int err = pthread_create( &d->self, &attributes, start_thread, ( void* )d ); | 198 | int err = pthread_create( &d->self, &attributes, start_thread, ( void* )d ); |
199 | if ( err != 0 ) { | 199 | if ( err != 0 ) { |
200 | odebug << "ThreadUtil::Thread::start() : can't create thread: " << strerror( err ) << "" << oendl; | 200 | odebug << "ThreadUtil::Thread::start() : can't create thread: " << strerror( err ) << "" << oendl; |
201 | pthread_attr_destroy( &attributes ); | 201 | pthread_attr_destroy( &attributes ); |
202 | return; | 202 | return; |
203 | } | 203 | } |
204 | pthread_attr_destroy( &attributes ); | 204 | pthread_attr_destroy( &attributes ); |
205 | } | 205 | } |
206 | 206 | ||
207 | void Thread::terminate() | 207 | void Thread::terminate() |
208 | { | 208 | { |
209 | AutoLock lock( d->guard ); | 209 | AutoLock lock( d->guard ); |
210 | if ( !d->isRunning ) | 210 | if ( !d->isRunning ) |
211 | return; | 211 | return; |
212 | 212 | ||
213 | pthread_cancel( d->self ); | 213 | pthread_cancel( d->self ); |
214 | } | 214 | } |
215 | 215 | ||
216 | bool Thread::wait() | 216 | bool Thread::wait() |
217 | { | 217 | { |
218 | AutoLock lock( d->guard ); | 218 | AutoLock lock( d->guard ); |
219 | if ( !d->isRunning ) | 219 | if ( !d->isRunning ) |
220 | return true; | 220 | return true; |
221 | 221 | ||
222 | return d->finishCondition.wait( d->guard ); | 222 | return d->finishCondition.wait( d->guard ); |
223 | } | 223 | } |
224 | 224 | ||
225 | bool Thread::isRunning() const | 225 | bool Thread::isRunning() const |
226 | { | 226 | { |
227 | AutoLock lock( d->guard ); | 227 | AutoLock lock( d->guard ); |
228 | return d->isRunning; | 228 | return d->isRunning; |
229 | } | 229 | } |
230 | 230 | ||
231 | void Thread::exit() | 231 | void Thread::exit() |
232 | { | 232 | { |
233 | pthread_exit( 0 ); | 233 | pthread_exit( 0 ); |
234 | } | 234 | } |
235 | 235 | ||
236 | OnewayNotifier::OnewayNotifier() | 236 | OnewayNotifier::OnewayNotifier() |
237 | { | 237 | { |
238 | int fds[ 2 ]; | 238 | int fds[ 2 ]; |
239 | pipe( fds ); | 239 | pipe( fds ); |
240 | m_readFd = fds[ 0 ]; | 240 | m_readFd = fds[ 0 ]; |
241 | m_writeFd = fds[ 1 ]; | 241 | m_writeFd = fds[ 1 ]; |
242 | 242 | ||
243 | m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read ); | 243 | m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read ); |
244 | connect( m_notifier, SIGNAL( activated(int) ), | 244 | connect( m_notifier, SIGNAL( activated(int) ), |
245 | this, SLOT( wakeUp() ) ); | 245 | this, SLOT( wakeUp() ) ); |
246 | } | 246 | } |
247 | 247 | ||
248 | OnewayNotifier::~OnewayNotifier() | 248 | OnewayNotifier::~OnewayNotifier() |
249 | { | 249 | { |
250 | delete m_notifier; | 250 | delete m_notifier; |
251 | 251 | ||
252 | ::close( m_readFd ); | 252 | ::close( m_readFd ); |
253 | ::close( m_writeFd ); | 253 | ::close( m_writeFd ); |
254 | } | 254 | } |
255 | 255 | ||
256 | void OnewayNotifier::notify() | 256 | void OnewayNotifier::notify() |
257 | { | 257 | { |
258 | const char c = 42; | 258 | const char c = 42; |
259 | ::write( m_writeFd, &c, 1 ); | 259 | ::write( m_writeFd, &c, 1 ); |
260 | } | 260 | } |
261 | 261 | ||
262 | void OnewayNotifier::wakeUp() | 262 | void OnewayNotifier::wakeUp() |
263 | { | 263 | { |
264 | char c = 0; | 264 | char c = 0; |
265 | 265 | ||
266 | if ( ::read( m_readFd, &c, 1 ) != 1 ) | 266 | if ( ::read( m_readFd, &c, 1 ) != 1 ) |
267 | return; | 267 | return; |
268 | 268 | ||
269 | emit awake(); | 269 | emit awake(); |
270 | } | 270 | } |
271 | 271 | ||
272 | ChannelMessage::ChannelMessage( int type ) | 272 | ChannelMessage::ChannelMessage( int type, int data, const char* msg ) |
273 | : m_type( type ), m_isCall( false ), m_replied( false ), | 273 | : m_type( type ), m_data( data ), m_msg( msg ), |
274 | m_inEventHandler( false ) | 274 | m_isCall( false ), m_replied( false ), m_inEventHandler( false ) |
275 | { | 275 | {} |
276 | } | ||
277 | 276 | ||
278 | ChannelMessage::~ChannelMessage() | 277 | ChannelMessage::~ChannelMessage() |
279 | { | 278 | { |
280 | if ( m_guard.isLocked() ) | 279 | if ( m_guard.isLocked() ) |
281 | m_guard.unlock(); | 280 | m_guard.unlock(); |
282 | } | 281 | } |
283 | 282 | ||
284 | void ChannelMessage::reply() | 283 | void ChannelMessage::reply() |
285 | { | 284 | { |
286 | if ( !m_isCall ) | 285 | if ( !m_isCall ) |
287 | { | 286 | { |
288 | odebug << "ChannelMessage::reply() - can't reply oneway message!" << oendl; | 287 | odebug << "ChannelMessage::reply() - can't reply oneway message!" << oendl; |
289 | return; | 288 | return; |
290 | } | 289 | } |
291 | 290 | ||
292 | if ( m_inEventHandler ) | 291 | if ( m_inEventHandler ) |
293 | { | 292 | { |
294 | m_replied = true; | 293 | m_replied = true; |
295 | return; | 294 | return; |
296 | } | 295 | } |
297 | 296 | ||
298 | m_condition.wakeOne(); | 297 | m_condition.wakeOne(); |
299 | m_guard.unlock(); | 298 | m_guard.unlock(); |
300 | } | 299 | } |
301 | 300 | ||
302 | struct Channel::Private | 301 | struct Channel::Private |
303 | { | 302 | { |
304 | Private() | 303 | Private() |
305 | { | 304 | { |
306 | ownerThread = pthread_self(); | 305 | ownerThread = pthread_self(); |
307 | } | 306 | } |
308 | 307 | ||
309 | pthread_t ownerThread; | 308 | pthread_t ownerThread; |
310 | }; | 309 | }; |
311 | 310 | ||
312 | Channel::Channel( QObject *parent, const char *name ) | 311 | Channel::Channel( QObject *parent, const char *name ) |
313 | : QObject( parent, name ), d( new Private ) | 312 | : QObject( parent, name ), d( new Private ) |
314 | { | 313 | { |
315 | connect( &m_notifier, SIGNAL( awake() ), | 314 | connect( &m_notifier, SIGNAL( awake() ), |
316 | this, SLOT( deliver() ) ); | 315 | this, SLOT( deliver() ) ); |
317 | } | 316 | } |
318 | 317 | ||
319 | Channel::~Channel() | 318 | Channel::~Channel() |
320 | { | 319 | { |
321 | delete d; | 320 | delete d; |
322 | } | 321 | } |
323 | 322 | ||
324 | void Channel::send( ChannelMessage *message, SendType type ) | 323 | void Channel::send( ChannelMessage *message, SendType type ) |
325 | { | 324 | { |
326 | if ( type == WaitForReply ) | 325 | if ( type == WaitForReply ) |
327 | { | 326 | { |
328 | message->m_guard.lock(); | 327 | message->m_guard.lock(); |
329 | message->m_isCall = true; | 328 | message->m_isCall = true; |
330 | } | 329 | } |
331 | 330 | ||
332 | m_pendingMessagesGuard.lock(); | 331 | m_pendingMessagesGuard.lock(); |
333 | m_pendingMessages << MsgEnvelope( type, message ); | 332 | m_pendingMessages << MsgEnvelope( type, message ); |
334 | m_pendingMessagesGuard.unlock(); | 333 | m_pendingMessagesGuard.unlock(); |
335 | 334 | ||
336 | if ( d->ownerThread == pthread_self() ) { | 335 | if ( d->ownerThread == pthread_self() ) { |
337 | assert( type != WaitForReply ); | 336 | assert( type != WaitForReply ); |
338 | 337 | ||
339 | deliver(); | 338 | deliver(); |
340 | } | 339 | } |
341 | else | 340 | else |
342 | m_notifier.notify(); | 341 | m_notifier.notify(); |
343 | //QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) ); | 342 | //QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) ); |
344 | 343 | ||
345 | if ( type == WaitForReply ) | 344 | if ( type == WaitForReply ) |
346 | { | 345 | { |
347 | message->m_condition.wait( message->m_guard ); | 346 | message->m_condition.wait( message->m_guard ); |
348 | message->m_guard.unlock(); | 347 | message->m_guard.unlock(); |
349 | } | 348 | } |
350 | } | 349 | } |
351 | 350 | ||
352 | void Channel::deliver() | 351 | void Channel::deliver() |
353 | { | 352 | { |
354 | AutoLock lock( m_pendingMessagesGuard ); | 353 | AutoLock lock( m_pendingMessagesGuard ); |
355 | 354 | ||
356 | while ( !m_pendingMessages.isEmpty() ) { | 355 | while ( !m_pendingMessages.isEmpty() ) { |
357 | MsgEnvelope envelope = m_pendingMessages.first(); | 356 | MsgEnvelope envelope = m_pendingMessages.first(); |
358 | 357 | ||
359 | m_pendingMessages.remove( m_pendingMessages.begin() ); | 358 | m_pendingMessages.remove( m_pendingMessages.begin() ); |
360 | 359 | ||
361 | m_pendingMessagesGuard.unlock(); | 360 | m_pendingMessagesGuard.unlock(); |
362 | deliverOne( envelope ); | 361 | deliverOne( envelope ); |
363 | m_pendingMessagesGuard.lock(); | 362 | m_pendingMessagesGuard.lock(); |
364 | } | 363 | } |
365 | } | 364 | } |
366 | 365 | ||
367 | void Channel::deliverOne( const MsgEnvelope &envelope ) | 366 | void Channel::deliverOne( const MsgEnvelope &envelope ) |
368 | { | 367 | { |
369 | ChannelMessage *msg = envelope.msg; | 368 | ChannelMessage *msg = envelope.msg; |
370 | 369 | ||
371 | assert( msg ); | 370 | assert( msg ); |
372 | 371 | ||
373 | if ( envelope.type == WaitForReply ) | 372 | if ( envelope.type == WaitForReply ) |
374 | { | 373 | { |
375 | msg->m_guard.lock(); | 374 | msg->m_guard.lock(); |
376 | msg->m_inEventHandler = true; | 375 | msg->m_inEventHandler = true; |
377 | } | 376 | } |
378 | 377 | ||
379 | receiveMessage( msg, envelope.type ); | 378 | receiveMessage( msg, envelope.type ); |
380 | 379 | ||
381 | if ( envelope.type == WaitForReply ) | 380 | if ( envelope.type == WaitForReply ) |
382 | { | 381 | { |
383 | msg->m_inEventHandler = false; | 382 | msg->m_inEventHandler = false; |
384 | if ( msg->m_replied ) | 383 | if ( msg->m_replied ) |
385 | { | 384 | { |
386 | msg->m_condition.wakeOne(); | 385 | msg->m_condition.wakeOne(); |
387 | // this is a bit tricky. we unlock only when we reply. | 386 | // this is a bit tricky. we unlock only when we reply. |
388 | // reply() does an unlock as well. | 387 | // reply() does an unlock as well. |
389 | msg->m_guard.unlock(); | 388 | msg->m_guard.unlock(); |
390 | } | 389 | } |
391 | } | 390 | } |
392 | } | 391 | } |
393 | 392 | ||
394 | /* vim: et sw=4 ts=4 | 393 | /* vim: et sw=4 ts=4 |
395 | */ | 394 | */ |
diff --git a/noncore/multimedia/opieplayer2/threadutil.h b/noncore/multimedia/opieplayer2/threadutil.h index 2e83d3a..f97a18b 100644 --- a/noncore/multimedia/opieplayer2/threadutil.h +++ b/noncore/multimedia/opieplayer2/threadutil.h | |||
@@ -8,192 +8,196 @@ | |||
8 | 8 | ||
9 | This library is distributed in the hope that it will be useful, | 9 | This library is distributed in the hope that it will be useful, |
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | Library General Public License for more details. | 12 | Library General Public License for more details. |
13 | 13 | ||
14 | You should have received a copy of the GNU Library General Public License | 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 | 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, | 16 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
17 | Boston, MA 02111-1307, USA. | 17 | Boston, MA 02111-1307, USA. |
18 | */ | 18 | */ |
19 | 19 | ||
20 | #ifndef THREADUTIL_H | 20 | #ifndef THREADUTIL_H |
21 | #define THREADUTIL_H | 21 | #define THREADUTIL_H |
22 | 22 | ||
23 | #include <qvaluelist.h> | 23 | #include <qvaluelist.h> |
24 | #include <qobject.h> | 24 | #include <qobject.h> |
25 | #include <qguardedptr.h> | 25 | #include <qguardedptr.h> |
26 | 26 | ||
27 | class QSocketNotifier; | 27 | class QSocketNotifier; |
28 | 28 | ||
29 | namespace ThreadUtil | 29 | namespace ThreadUtil |
30 | { | 30 | { |
31 | 31 | ||
32 | class Mutex | 32 | class Mutex |
33 | { | 33 | { |
34 | friend class WaitCondition; | 34 | friend class WaitCondition; |
35 | public: | 35 | public: |
36 | Mutex(); | 36 | Mutex(); |
37 | ~Mutex(); | 37 | ~Mutex(); |
38 | 38 | ||
39 | void lock(); | 39 | void lock(); |
40 | void unlock(); | 40 | void unlock(); |
41 | bool tryLock(); | 41 | bool tryLock(); |
42 | bool isLocked(); | 42 | bool isLocked(); |
43 | 43 | ||
44 | private: | 44 | private: |
45 | struct Data; | 45 | struct Data; |
46 | Data *d; | 46 | Data *d; |
47 | 47 | ||
48 | Mutex( const Mutex & ); | 48 | Mutex( const Mutex & ); |
49 | Mutex &operator=( const Mutex & ); | 49 | Mutex &operator=( const Mutex & ); |
50 | }; | 50 | }; |
51 | 51 | ||
52 | class AutoLock | 52 | class AutoLock |
53 | { | 53 | { |
54 | public: | 54 | public: |
55 | AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); } | 55 | AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); } |
56 | ~AutoLock() { m_mutex.unlock(); } | 56 | ~AutoLock() { m_mutex.unlock(); } |
57 | 57 | ||
58 | Mutex *operator &() const { return &m_mutex; } | 58 | Mutex *operator &() const { return &m_mutex; } |
59 | 59 | ||
60 | private: | 60 | private: |
61 | Mutex &m_mutex; | 61 | Mutex &m_mutex; |
62 | }; | 62 | }; |
63 | 63 | ||
64 | class WaitCondition | 64 | class WaitCondition |
65 | { | 65 | { |
66 | public: | 66 | public: |
67 | WaitCondition(); | 67 | WaitCondition(); |
68 | ~WaitCondition(); | 68 | ~WaitCondition(); |
69 | 69 | ||
70 | bool wait(); | 70 | bool wait(); |
71 | bool wait( Mutex &mutex ); | 71 | bool wait( Mutex &mutex ); |
72 | 72 | ||
73 | void wakeOne(); | 73 | void wakeOne(); |
74 | void wakeAll(); | 74 | void wakeAll(); |
75 | 75 | ||
76 | private: | 76 | private: |
77 | struct Data; | 77 | struct Data; |
78 | Data *d; | 78 | Data *d; |
79 | 79 | ||
80 | WaitCondition( const WaitCondition & ); | 80 | WaitCondition( const WaitCondition & ); |
81 | WaitCondition &operator=( const WaitCondition & ); | 81 | WaitCondition &operator=( const WaitCondition & ); |
82 | }; | 82 | }; |
83 | 83 | ||
84 | class Thread | 84 | class Thread |
85 | { | 85 | { |
86 | public: | 86 | public: |
87 | struct Data; | 87 | struct Data; |
88 | friend struct Data; | 88 | friend struct Data; |
89 | 89 | ||
90 | Thread(); | 90 | Thread(); |
91 | virtual ~Thread(); | 91 | virtual ~Thread(); |
92 | 92 | ||
93 | void start(); | 93 | void start(); |
94 | void terminate(); | 94 | void terminate(); |
95 | 95 | ||
96 | bool wait(); | 96 | bool wait(); |
97 | 97 | ||
98 | bool isRunning() const; | 98 | bool isRunning() const; |
99 | 99 | ||
100 | static void exit(); | 100 | static void exit(); |
101 | protected: | 101 | protected: |
102 | virtual void run() = 0; | 102 | virtual void run() = 0; |
103 | 103 | ||
104 | private: | 104 | private: |
105 | Data *d; | 105 | Data *d; |
106 | }; | 106 | }; |
107 | 107 | ||
108 | class OnewayNotifier : public QObject | 108 | class OnewayNotifier : public QObject |
109 | { | 109 | { |
110 | Q_OBJECT | 110 | Q_OBJECT |
111 | public: | 111 | public: |
112 | OnewayNotifier(); | 112 | OnewayNotifier(); |
113 | ~OnewayNotifier(); | 113 | ~OnewayNotifier(); |
114 | 114 | ||
115 | void notify(); | 115 | void notify(); |
116 | 116 | ||
117 | signals: | 117 | signals: |
118 | void awake(); | 118 | void awake(); |
119 | 119 | ||
120 | private slots: | 120 | private slots: |
121 | void wakeUp(); | 121 | void wakeUp(); |
122 | 122 | ||
123 | private: | 123 | private: |
124 | int m_readFd; | 124 | int m_readFd; |
125 | int m_writeFd; | 125 | int m_writeFd; |
126 | QSocketNotifier *m_notifier; | 126 | QSocketNotifier *m_notifier; |
127 | }; | 127 | }; |
128 | 128 | ||
129 | 129 | ||
130 | class Channel; | 130 | class Channel; |
131 | 131 | ||
132 | class ChannelMessage | 132 | class ChannelMessage |
133 | { | 133 | { |
134 | friend class Channel; | 134 | friend class Channel; |
135 | public: | 135 | public: |
136 | ChannelMessage( int type = -1 ); | 136 | ChannelMessage( int type = -1, int data = -1, const char* msg = 0 ); |
137 | virtual ~ChannelMessage(); | 137 | virtual ~ChannelMessage(); |
138 | 138 | ||
139 | int type() const { return m_type; } | 139 | int type() const { return m_type; } |
140 | int data() const { return m_data; } | ||
141 | const char* msg()const { return m_msg; } | ||
140 | 142 | ||
141 | void reply(); | 143 | void reply(); |
142 | 144 | ||
143 | private: | 145 | private: |
144 | ChannelMessage( const ChannelMessage & ); | 146 | ChannelMessage( const ChannelMessage & ); |
145 | ChannelMessage &operator=( const ChannelMessage ); | 147 | ChannelMessage &operator=( const ChannelMessage ); |
146 | 148 | ||
147 | int m_type; | 149 | int m_type; |
150 | int m_data; | ||
151 | const char *m_msg; | ||
148 | bool m_isCall : 1; | 152 | bool m_isCall : 1; |
149 | bool m_replied : 1; | 153 | bool m_replied : 1; |
150 | bool m_inEventHandler : 1; | 154 | bool m_inEventHandler : 1; |
151 | Mutex m_guard; | 155 | Mutex m_guard; |
152 | WaitCondition m_condition; | 156 | WaitCondition m_condition; |
153 | }; | 157 | }; |
154 | 158 | ||
155 | class Channel : public QObject | 159 | class Channel : public QObject |
156 | { | 160 | { |
157 | Q_OBJECT | 161 | Q_OBJECT |
158 | public: | 162 | public: |
159 | enum SendType { OneWay, WaitForReply }; | 163 | enum SendType { OneWay, WaitForReply }; |
160 | Channel( QObject *parent = 0, const char *name = 0 ); | 164 | Channel( QObject *parent = 0, const char *name = 0 ); |
161 | virtual ~Channel(); | 165 | virtual ~Channel(); |
162 | 166 | ||
163 | void send( ChannelMessage *message, SendType type ); | 167 | void send( ChannelMessage *message, SendType type ); |
164 | 168 | ||
165 | protected: | 169 | protected: |
166 | virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0; | 170 | virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0; |
167 | 171 | ||
168 | private slots: | 172 | private slots: |
169 | void deliver(); | 173 | void deliver(); |
170 | 174 | ||
171 | private: | 175 | private: |
172 | OnewayNotifier m_notifier; | 176 | OnewayNotifier m_notifier; |
173 | 177 | ||
174 | struct MsgEnvelope | 178 | struct MsgEnvelope |
175 | { | 179 | { |
176 | MsgEnvelope() : type( OneWay ), msg( 0 ) {} | 180 | MsgEnvelope() : type( OneWay ), msg( 0 ) {} |
177 | MsgEnvelope( SendType _type , ChannelMessage *_msg ) | 181 | MsgEnvelope( SendType _type , ChannelMessage *_msg ) |
178 | : type( _type ), msg( _msg ) {} | 182 | : type( _type ), msg( _msg ) {} |
179 | 183 | ||
180 | SendType type; | 184 | SendType type; |
181 | ChannelMessage *msg; | 185 | ChannelMessage *msg; |
182 | }; | 186 | }; |
183 | 187 | ||
184 | void deliverOne( const MsgEnvelope &envelope ); | 188 | void deliverOne( const MsgEnvelope &envelope ); |
185 | 189 | ||
186 | typedef QValueList<MsgEnvelope> MsgEnvelopeList; | 190 | typedef QValueList<MsgEnvelope> MsgEnvelopeList; |
187 | 191 | ||
188 | MsgEnvelopeList m_pendingMessages; | 192 | MsgEnvelopeList m_pendingMessages; |
189 | Mutex m_pendingMessagesGuard; | 193 | Mutex m_pendingMessagesGuard; |
190 | 194 | ||
191 | struct Private; | 195 | struct Private; |
192 | Private *d; | 196 | Private *d; |
193 | }; | 197 | }; |
194 | 198 | ||
195 | } | 199 | } |
196 | 200 | ||
197 | #endif // THREADUTIL_H | 201 | #endif // THREADUTIL_H |
198 | /* vim: et sw=4 ts=4 | 202 | /* vim: et sw=4 ts=4 |
199 | */ | 203 | */ |