| -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 @@ -13,64 +13,66 @@ .="- .-=="i, .._ License as published by the Free Software - . .-<_> .<> Foundation; either version 2 of the License, ._= =} : or (at your option) any later version. .%`+i> _;_. .i_,=:_. -<s. This program 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 <stdio.h> #include <stdlib.h> #include <qimage.h> #include <qtextstream.h> #include <qpe/resource.h> #include <qfile.h> #include <qgfx_qws.h> #include <qdirectpainter_qws.h> +#include <assert.h> + #include "xinevideowidget.h" #include "frame.h" #include "lib.h" typedef void (*display_xine_frame_t) (void *user_data, uint8_t* frame, int width, int height,int bytes ); extern "C" { xine_vo_driver_t* init_video_out_plugin( xine_cfg_entry_t* conf, void* video); int null_is_showing_video( const xine_vo_driver_t* self ); void null_set_show_video( const xine_vo_driver_t* self, int show ); int null_is_fullscreen( const xine_vo_driver_t* self ); void null_set_fullscreen( const xine_vo_driver_t* self, int screen ); int null_is_scaling( const xine_vo_driver_t* self ); void null_set_scaling( const xine_vo_driver_t* self, int scale ); void null_set_gui_width( const xine_vo_driver_t* self, int width ); void null_set_gui_height( const xine_vo_driver_t* self, int height ); void null_set_mode( const xine_vo_driver_t* self, int depth, int rgb ); void null_set_videoGamma( const xine_vo_driver_t* self , int value ); void null_display_handler( const xine_vo_driver_t* self, display_xine_frame_t t, void* user_data ); } using namespace XINE; Lib::Lib( XineVideoWidget* widget ) { m_video = false; m_wid = widget; printf("Lib"); QCString str( getenv("HOME") ); str += "/Settings/opiexine.cf"; // get the configuration @@ -190,66 +192,77 @@ int Lib::currentTime() { return m_time/1000; } int Lib::length() { xine_get_pos_length( m_stream, &m_pos, &m_time, &m_length ); return m_length/1000; } bool Lib::isSeekable() { return xine_get_stream_info( m_stream, XINE_STREAM_INFO_SEEKABLE ); } void Lib::seekTo( int time ) { //xine_trick_mode ( m_stream, XINE_TRICK_MODE_SEEK_TO_TIME, time ); NOT IMPLEMENTED YET IN XINE :_( // since its now milliseconds we need *1000 xine_play( m_stream, 0, time*1000 ); } Frame Lib::currentFrame() { Frame frame; return frame; }; QString Lib::metaInfo( int number) { return xine_get_meta_info( m_stream, number ); } int Lib::error() { return xine_get_error( m_stream ); }; +void Lib::receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ) +{ + assert( sendType == ThreadUtil::Channel::OneWay ); + handleXineEvent( msg->type() ); + delete msg; +} + void Lib::handleXineEvent( const xine_event_t* t ) { - if ( t->type == XINE_EVENT_UI_PLAYBACK_FINISHED ) { + send( new ThreadUtil::ChannelMessage( t->type ), OneWay ); +} + +void Lib::handleXineEvent( int type ) { + if ( type == XINE_EVENT_UI_PLAYBACK_FINISHED ) { emit stopped(); } } void Lib::setShowVideo( bool video ) { m_video = video; ::null_set_show_video( m_videoOutput, video ); } bool Lib::isShowingVideo() { return ::null_is_showing_video( m_videoOutput ); } bool Lib::hasVideo() { return xine_get_stream_info( m_stream, 18 ); } void Lib::showVideoFullScreen( bool fullScreen ) { ::null_set_fullscreen( m_videoOutput, fullScreen ); } bool Lib::isVideoFullScreen() { return ::null_is_fullscreen( m_videoOutput ); } void Lib::setScaling( bool scale ) { ::null_set_scaling( m_videoOutput, scale ); } void Lib::setGamma( int value ) { //qDebug( QString( "%1").arg(value) ); 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 @@ -12,77 +12,79 @@ :`=1 )Y*s>-.-- : the terms of the GNU General Public .="- .-=="i, .._ License as published by the Free Software - . .-<_> .<> Foundation; either version 2 of the License, ._= =} : or (at your option) any later version. .%`+i> _;_. .i_,=:_. -<s. This program 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 ZECKEXINELIB_H #define ZECKEXINELIB_H #include <qcstring.h> #include <qstring.h> #include <qobject.h> #include <xine.h> //#include "xine.h" +#include "threadutil.h" + class XineVideoWidget; namespace XINE { /** * Lib wrapps the simple interface * of libxine for easy every day use * This will become a full C++ Wrapper * It supports playing, pausing, info, * stooping, seeking. */ class Frame; - class Lib : public QObject { + class Lib : public ThreadUtil::Channel { Q_OBJECT public: Lib(XineVideoWidget* = 0); ~Lib(); QCString version(); int majorVersion()/*const*/; int minorVersion()/*const*/; int subVersion()/*const*/; void resize ( const QSize &s ); int play( const QString& fileName, int startPos = 0, int start_time = 0 ); void stop() /*const*/; void pause()/*const*/; int speed() /*const*/; /** * Set the speed of the stream, if codec supports it * XINE_SPEED_PAUSE 0 * XINE_SPEED_SLOW_4 1 * XINE_SPEED_SLOW_2 2 * XINE_SPEED_NORMAL 4 * XINE_SPEED_FAST_2 8 *XINE_SPEED_FAST_4 16 */ void setSpeed( int speed = XINE_SPEED_PAUSE ); int status() /*const*/; @@ -147,56 +149,60 @@ namespace XINE { */ bool hasVideo(); /** * */ void setScaling( bool ); /** * Set the Gamma value for video output * @param int the value between -100 and 100, 0 is original */ void setGamma( int ); /** * test */ Frame currentFrame()/*const*/; /** * Returns the error code * XINE_ERROR_NONE 0 * XINE_ERROR_NO_INPUT_PLUGIN 1 * XINE_ERROR_NO_DEMUXER_PLUGIN 2 * XINE_ERROR_DEMUXER_FAILED 3 */ int error() /*const*/; signals: void stopped(); + protected: + virtual void receiveMessage( ThreadUtil::ChannelMessage *msg, SendType sendType ); + private: int m_bytes_per_pixel; int m_length, m_pos, m_time; int m_major_version, m_minor_version, m_sub_version; bool m_video:1; XineVideoWidget *m_wid; xine_t *m_xine; xine_stream_t *m_stream; xine_cfg_entry_t *m_config; xine_vo_driver_t *m_videoOutput; xine_ao_driver_t* m_audioOutput; xine_event_queue_t *m_queue; void handleXineEvent( const xine_event_t* t ); + void handleXineEvent( int type ); void drawFrame( uint8_t* frame, int width, int height, int bytes ); // C -> C++ bridge for the event system static void xine_event_handler( void* user_data, const xine_event_t* t); static void xine_display_frame( void* user_data, uint8_t* frame , int width, int height, int bytes ); }; }; #endif diff --git a/noncore/multimedia/opieplayer2/threadutil.cpp b/noncore/multimedia/opieplayer2/threadutil.cpp new file mode 100644 index 0000000..63863b4 --- a/dev/null +++ b/noncore/multimedia/opieplayer2/threadutil.cpp @@ -0,0 +1,284 @@ +/* This file is part of the KDE project + Copyright (C) 1999 Simon Hausmann <hausmann@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#include "threadutil.h" + +#include <qsocketnotifier.h> + +#include <pthread.h> +#include <assert.h> +#include <unistd.h> + +using namespace ThreadUtil; + +struct Mutex::Data +{ + Data() + { + pthread_mutex_init( &mutex, 0 ); + } + ~Data() + { + pthread_mutex_destroy( &mutex ); + } + + pthread_mutex_t mutex; +}; + +Mutex::Mutex() + : d( new Data ) +{ +} + +Mutex::~Mutex() +{ + delete d; +} + +void Mutex::lock() +{ + pthread_mutex_lock( &d->mutex ); +} + +void Mutex::unlock() +{ + pthread_mutex_unlock( &d->mutex ); +} + +bool Mutex::tryLock() +{ + return pthread_mutex_trylock( &d->mutex ) == 0; +} + +bool Mutex::isLocked() +{ + if ( !tryLock() ) + return true; + + unlock(); + return false; +} + +struct WaitCondition::Data +{ + Data() + { + int result = pthread_cond_init( &waitCondition, 0 ); + assert( result == 0 ); + } + ~Data() + { + pthread_cond_destroy( &waitCondition ); + } + + pthread_cond_t waitCondition; +}; + +WaitCondition::WaitCondition() + : d( new Data ) +{ +} + +WaitCondition::~WaitCondition() +{ + delete d; +} + +bool WaitCondition::wait() +{ + Mutex m; + m.lock(); + return wait( m ); +} + +bool WaitCondition::wait( Mutex &mutex ) +{ + return pthread_cond_wait( &d->waitCondition, &mutex.d->mutex ); +} + +void WaitCondition::wakeOne() +{ + pthread_cond_signal( &d->waitCondition ); +} + +void WaitCondition::wakeAll() +{ + pthread_cond_broadcast( &d->waitCondition ); +} + +OnewayNotifier::OnewayNotifier() +{ + int fds[ 2 ]; + pipe( fds ); + m_readFd = fds[ 0 ]; + m_writeFd = fds[ 1 ]; + + m_notifier = new QSocketNotifier( m_readFd, QSocketNotifier::Read ); + connect( m_notifier, SIGNAL( activated( int ) ), + this, SLOT( wakeUp() ) ); +} + +OnewayNotifier::~OnewayNotifier() +{ + delete m_notifier; + + ::close( m_readFd ); + ::close( m_writeFd ); +} + +void OnewayNotifier::notify() +{ + const char c = 42; + ::write( m_writeFd, &c, 1 ); +} + +void OnewayNotifier::wakeUp() +{ + char c = 0; + + if ( ::read( m_readFd, &c, 1 ) != 1 ) + return; + + emit awake(); +} + +ChannelMessage::ChannelMessage( int type ) + : m_type( type ), m_isCall( false ), m_replied( false ), + m_inEventHandler( false ) +{ +} + +ChannelMessage::~ChannelMessage() +{ + if ( m_guard.isLocked() ) + m_guard.unlock(); +} + +void ChannelMessage::reply() +{ + if ( !m_isCall ) + { + qDebug( "ChannelMessage::reply() - can't reply oneway message!" ); + return; + } + + if ( m_inEventHandler ) + { + m_replied = true; + return; + } + + m_condition.wakeOne(); + m_guard.unlock(); +} + +struct Channel::Private +{ + Private() + { + ownerThread = pthread_self(); + } + + pthread_t ownerThread; +}; + +Channel::Channel( QObject *parent, const char *name ) + : QObject( parent, name ), d( new Private ) +{ + connect( &m_notifier, SIGNAL( awake() ), + this, SLOT( deliver() ) ); +} + +Channel::~Channel() +{ + delete d; +} + +void Channel::send( ChannelMessage *message, SendType type ) +{ + if ( type == WaitForReply ) + { + message->m_guard.lock(); + message->m_isCall = true; + } + + m_pendingMessagesGuard.lock(); + m_pendingMessages << MsgEnvelope( type, message ); + m_pendingMessagesGuard.unlock(); + + if ( d->ownerThread == pthread_self() ) { + assert( type != WaitForReply ); + + deliver(); + } + else + m_notifier.notify(); + //QThread::postEvent( this, new QCustomEvent( QEvent::User, envelope ) ); + + if ( type == WaitForReply ) + { + message->m_condition.wait( message->m_guard ); + message->m_guard.unlock(); + } +} + +void Channel::deliver() +{ + AutoLock lock( m_pendingMessagesGuard ); + + while ( !m_pendingMessages.isEmpty() ) { + MsgEnvelope envelope = m_pendingMessages.first(); + + m_pendingMessages.remove( m_pendingMessages.begin() ); + + m_pendingMessagesGuard.unlock(); + deliverOne( envelope ); + m_pendingMessagesGuard.lock(); + } +} + +void Channel::deliverOne( const MsgEnvelope &envelope ) +{ + ChannelMessage *msg = envelope.msg; + + assert( msg ); + + if ( envelope.type == WaitForReply ) + { + msg->m_guard.lock(); + msg->m_inEventHandler = true; + } + + receiveMessage( msg, envelope.type ); + + if ( envelope.type == WaitForReply ) + { + msg->m_inEventHandler = false; + if ( msg->m_replied ) + { + msg->m_condition.wakeOne(); + // this is a bit tricky. we unlock only when we reply. + // reply() does an unlock as well. + msg->m_guard.unlock(); + } + } +} + +/* vim: et sw=4 ts=4 + */ diff --git a/noncore/multimedia/opieplayer2/threadutil.h b/noncore/multimedia/opieplayer2/threadutil.h new file mode 100644 index 0000000..bcb9db9 --- a/dev/null +++ b/noncore/multimedia/opieplayer2/threadutil.h @@ -0,0 +1,176 @@ +/* This file is part of the KDE project + Copyright (C) 1999 Simon Hausmann <hausmann@kde.org> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. +*/ + +#ifndef THREADUTIL_H +#define THREADUTIL_H + +#include <qvaluelist.h> +#include <qobject.h> +#include <qguardedptr.h> + +class QSocketNotifier; + +namespace ThreadUtil +{ + + class Mutex + { + friend class WaitCondition; + public: + Mutex(); + ~Mutex(); + + void lock(); + void unlock(); + bool tryLock(); + bool isLocked(); + + private: + struct Data; + Data *d; + + Mutex( const Mutex & ); + Mutex &operator=( const Mutex & ); + }; + + class AutoLock + { + public: + AutoLock( Mutex &mutex ) : m_mutex( mutex ) { m_mutex.lock(); } + ~AutoLock() { m_mutex.unlock(); } + + Mutex *operator &() const { return &m_mutex; } + + private: + Mutex &m_mutex; + }; + + class WaitCondition + { + public: + WaitCondition(); + ~WaitCondition(); + + bool wait(); + bool wait( Mutex &mutex ); + + void wakeOne(); + void wakeAll(); + + private: + struct Data; + Data *d; + + WaitCondition( const WaitCondition & ); + WaitCondition &operator=( const WaitCondition & ); + }; + + class OnewayNotifier : public QObject + { + Q_OBJECT + public: + OnewayNotifier(); + ~OnewayNotifier(); + + void notify(); + + signals: + void awake(); + + private slots: + void wakeUp(); + + private: + int m_readFd; + int m_writeFd; + QSocketNotifier *m_notifier; + }; + + + class Channel; + + class ChannelMessage + { + friend class Channel; + public: + ChannelMessage( int type = -1 ); + virtual ~ChannelMessage(); + + int type() const { return m_type; } + + void reply(); + + private: + ChannelMessage( const ChannelMessage & ); + ChannelMessage &operator=( const ChannelMessage ); + + int m_type; + bool m_isCall : 1; + bool m_replied : 1; + bool m_inEventHandler : 1; + Mutex m_guard; + WaitCondition m_condition; + QGuardedPtr<Channel> m_channel; + }; + + class Channel : public QObject + { + Q_OBJECT + public: + enum SendType { OneWay, WaitForReply }; + Channel( QObject *parent = 0, const char *name = 0 ); + virtual ~Channel(); + + void send( ChannelMessage *message, SendType type ); + + protected: + virtual void receiveMessage( ChannelMessage *message, SendType type ) = 0; + + private slots: + void deliver(); + + private: + OnewayNotifier m_notifier; + + struct MsgEnvelope + { + MsgEnvelope() : type( OneWay ), msg( 0 ) {} + MsgEnvelope( SendType _type , ChannelMessage *_msg ) + : type( _type ), msg( _msg ) {} + + SendType type; + ChannelMessage *msg; + }; + + void deliverOne( const MsgEnvelope &envelope ); + + typedef QValueList<MsgEnvelope> MsgEnvelopeList; + + MsgEnvelopeList m_pendingMessages; + Mutex m_pendingMessagesGuard; + + struct Private; + Private *d; + }; + +} + +#endif // THREADUTIL_H +/* vim: et sw=4 ts=4 + */ |