}
}
- // timer
+DEFINE_REF(eTimer);
+
void eTimer::start(long msek, bool singleShot)
{
if (bActive)
{
/* process all timers which are ready. first remove them out of the list. */
while (!m_timer_list.empty() && (poll_timeout = timeout_usec( m_timer_list.begin()->getNextActivation() ) ) <= 0 )
- m_timer_list.begin()->activate();
+ {
+ eTimer *tmr = m_timer_list.begin();
+ tmr->AddRef();
+ tmr->activate();
+ tmr->Release();
+ }
if (poll_timeout < 0)
poll_timeout = 0;
else /* convert us to ms */
if (self->in_weakreflist != NULL)
PyObject_ClearWeakRefs((PyObject *) self);
eTimerPy_clear(self);
- delete self->tm;
+ self->tm->Release();
self->ob_type->tp_free((PyObject*)self);
}
eTimerPy_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
eTimerPy *self = (eTimerPy *)type->tp_alloc(type, 0);
- self->tm = new eTimer(eApp);
+ self->tm = eTimer::create(eApp);
+ self->tm->AddRef();
self->in_weakreflist = NULL;
return (PyObject *)self;
}
*
* This class emits the signal \c eTimer::timeout after the specified timeout.
*/
-class eTimer
+class eTimer: iObject
{
+ DECLARE_REF(eTimer);
friend class eMainloop;
eMainloop &context;
timespec nextActivation;
bool bSingleShot;
bool bActive;
void activate();
+
+ eTimer(eMainloop *context): context(*context), bActive(false) { }
+ void operator delete(void *pmem) { ::operator delete(pmem); }
public:
/**
* \brief Constructs a timer.
* The timer is not yet active, it has to be started with \c start.
* \param context The thread from which the signal should be emitted.
*/
- eTimer(eMainloop *context=eApp): context(*context), bActive(false) { }
+ static eTimer *create(eMainloop *context=eApp) { return new eTimer(context); }
~eTimer() { if (bActive) stop(); }
PSignal0<void> timeout;
void changeInterval(long msek);
void startLongTimer( int seconds );
bool operator<(const eTimer& t) const { return nextActivation < t.nextActivation; }
+ eSmartPtrList<iObject> m_clients;
};
#endif // SWIG
eBackgroundFileEraser *eBackgroundFileEraser::instance;
eBackgroundFileEraser::eBackgroundFileEraser()
- :messages(this,1), stop_thread_timer(this)
+ :messages(this,1), stop_thread_timer(eTimer::create(this))
{
if (!instance)
instance=this;
CONNECT(messages.recv_msg, eBackgroundFileEraser::gotMessage);
- CONNECT(stop_thread_timer.timeout, eBackgroundFileEraser::idle);
+ CONNECT(stop_thread_timer->timeout, eBackgroundFileEraser::idle);
}
void eBackgroundFileEraser::idle()
runLoop();
- stop_thread_timer.stop();
+ stop_thread_timer->stop();
}
void eBackgroundFileEraser::erase(const char *filename)
eDebug("file %s erased", msg.filename);
free((char*)msg.filename);
}
- stop_thread_timer.start(1000, true); // stop thread in one seconds
+ stop_thread_timer->start(1000, true); // stop thread in one seconds
break;
case Message::quit:
quit(0);
void gotMessage(const Message &message);
void thread();
void idle();
- eTimer stop_thread_timer;
+ ePtr<eTimer> stop_thread_timer;
#ifndef SWIG
public:
#endif
}
eTSMPEGDecoder::eTSMPEGDecoder(eDVBDemux *demux, int decoder)
- :m_demux(demux), m_changed(0), m_decoder(decoder), m_video_clip_fd(-1), m_showSinglePicTimer(eApp)
+ :m_demux(demux), m_changed(0), m_decoder(decoder), m_video_clip_fd(-1), m_showSinglePicTimer(eTimer::create(eApp))
{
demux->connectEvent(slot(*this, &eTSMPEGDecoder::demux_event), m_demux_event_conn);
- CONNECT(m_showSinglePicTimer.timeout, eTSMPEGDecoder::finishShowSinglePic);
+ CONNECT(m_showSinglePicTimer->timeout, eTSMPEGDecoder::finishShowSinglePic);
m_is_ff = m_is_sm = m_is_trickmode = 0;
}
if (!seq_end_avail)
write(m_video_clip_fd, seq_end, sizeof(seq_end));
write(m_video_clip_fd, stuffing, 8192);
- m_showSinglePicTimer.start(150, true);
+ m_showSinglePicTimer->start(150, true);
}
close(f);
}
void video_event(struct videoEvent);
Signal1<void, struct videoEvent> m_video_event;
int m_video_clip_fd;
- eTimer m_showSinglePicTimer;
+ ePtr<eTimer> m_showSinglePicTimer;
void finishShowSinglePic(); // called by timer
public:
enum { pidNone = -1 };
}
eDVBResourceManager::eDVBResourceManager()
- :m_releaseCachedChannelTimer(eApp)
+ :m_releaseCachedChannelTimer(eTimer::create(eApp))
{
avail = 1;
busy = 0;
eDVBCAService::registerChannelCallback(this);
- CONNECT(m_releaseCachedChannelTimer.timeout, eDVBResourceManager::releaseCachedChannel);
+ CONNECT(m_releaseCachedChannelTimer->timeout, eDVBResourceManager::releaseCachedChannel);
}
void eDVBResourceManager::feStateChanged()
}
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
}
eDebugNoSimulate("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
case iDVBChannel::state_ok:
{
eDebug("stop release channel timer");
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
break;
}
case iDVBChannel::state_last_instance:
{
eDebug("start release channel timer");
- m_releaseCachedChannelTimer.start(3000, true);
+ m_releaseCachedChannelTimer->start(3000, true);
break;
}
default: // ignore all other events
{
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
}
int err = allocateFrontendByIndex(fe, slot_index);
{
ePtr<eDVBAllocatedDemux> demux;
- if (m_cached_channel && m_releaseCachedChannelTimer.isActive())
+ if (m_cached_channel && m_releaseCachedChannelTimer->isActive())
{
m_cached_channel_state_changed_conn.disconnect();
m_cached_channel=0;
- m_releaseCachedChannelTimer.stop();
+ m_releaseCachedChannelTimer->stop();
}
channel = new eDVBChannel(this, 0);
class eDVBRegisteredFrontend: public iObject, public Object
{
DECLARE_REF(eDVBRegisteredFrontend);
- eTimer *disable;
+ ePtr<eTimer> disable;
void closeFrontend()
{
if (!m_inuse && m_frontend->closeFrontend()) // frontend busy
public:
Signal0<void> stateChanged;
eDVBRegisteredFrontend(eDVBFrontend *fe, iDVBAdapter *adap)
- :disable(new eTimer(eApp)), m_adapter(adap), m_frontend(fe), m_inuse(0)
+ :disable(eTimer::create(eApp)), m_adapter(adap), m_frontend(fe), m_inuse(0)
{
CONNECT(disable->timeout, eDVBRegisteredFrontend::closeFrontend);
}
- ~eDVBRegisteredFrontend()
- {
- delete disable;
- }
void dec_use()
{
if (!--m_inuse)
eUsePtr<iDVBChannel> m_cached_channel;
Connection m_cached_channel_state_changed_conn;
- eTimer m_releaseCachedChannelTimer;
+ ePtr<eTimer> m_releaseCachedChannelTimer;
void DVBChannelStateChanged(iDVBChannel*);
void feStateChanged();
#ifndef SWIG
}
TDT::TDT(eDVBChannel *chan, int update_count)
- :chan(chan), update_count(update_count)
+ :chan(chan), m_interval_timer(eTimer::create()), update_count(update_count)
{
CONNECT(tableReady, TDT::ready);
- CONNECT(m_interval_timer.timeout, TDT::start);
+ CONNECT(m_interval_timer->timeout, TDT::start);
if (chan)
chan->getDemux(demux, 0);
}
void TDT::startTimer( int interval )
{
- m_interval_timer.start(interval, true);
+ m_interval_timer->start(interval, true);
}
eDVBLocalTimeHandler *eDVBLocalTimeHandler::instance;
{
eDVBChannel *chan;
ePtr<iDVBDemux> demux;
- eTimer m_interval_timer;
+ ePtr<eTimer> m_interval_timer;
int createTable(unsigned int nr, const __u8 *data, unsigned int max);
void ready(int);
int update_count;
DEFINE_REF(eEPGCache)
eEPGCache::eEPGCache()
- :messages(this,1), cleanTimer(this)//, paused(0)
+ :messages(this,1), cleanTimer(eTimer::create(this))//, paused(0)
{
eDebug("[EPGC] Initialized EPGCache");
CONNECT(messages.recv_msg, eEPGCache::gotMessage);
CONNECT(eDVBLocalTimeHandler::getInstance()->m_timeUpdated, eEPGCache::timeUpdated);
- CONNECT(cleanTimer.timeout, eEPGCache::cleanLoop);
+ CONNECT(cleanTimer->timeout, eEPGCache::cleanLoop);
ePtr<eDVBResourceManager> res_mgr;
eDVBResourceManager::getInstance(res_mgr);
eDebug("[EPGC] stop cleanloop");
eDebug("[EPGC] %i bytes for cache used", eventData::CacheSize);
}
- cleanTimer.start(CLEAN_INTERVAL,true);
+ cleanTimer->start(CLEAN_INTERVAL,true);
}
eEPGCache::~eEPGCache()
int update = ( It != channelLastUpdated.end() ? ( UPDATE_INTERVAL - ( (::time(0)-It->second) * 1000 ) ) : ZAP_DELAY );
if (update < ZAP_DELAY)
update = ZAP_DELAY;
- data->startPrivateTimer.start(update, 1);
+ data->startPrivateTimer->start(update, 1);
if (update >= 60000)
eDebug("[EPGC] next private update in %i min", update/60000);
else if (update >= 1000)
eEPGCache::channel_data::channel_data(eEPGCache *ml)
:cache(ml)
- ,abortTimer(ml), zapTimer(ml), state(0)
+ ,abortTimer(eTimer::create(ml)), zapTimer(eTimer::create(ml)), state(0)
,isRunning(0), haveData(0)
#ifdef ENABLE_PRIVATE_EPG
- ,startPrivateTimer(ml)
+ ,startPrivateTimer(eTimer::create(ml))
#endif
#ifdef ENABLE_MHW_EPG
- ,m_MHWTimeoutTimer(ml)
+ ,m_MHWTimeoutTimer(eTimer::create(ml))
#endif
{
#ifdef ENABLE_MHW_EPG
- CONNECT(m_MHWTimeoutTimer.timeout, eEPGCache::channel_data::MHWTimeout);
+ CONNECT(m_MHWTimeoutTimer->timeout, eEPGCache::channel_data::MHWTimeout);
#endif
- CONNECT(zapTimer.timeout, eEPGCache::channel_data::startEPG);
- CONNECT(abortTimer.timeout, eEPGCache::channel_data::abortNonAvail);
+ CONNECT(zapTimer->timeout, eEPGCache::channel_data::startEPG);
+ CONNECT(abortTimer->timeout, eEPGCache::channel_data::abortNonAvail);
#ifdef ENABLE_PRIVATE_EPG
- CONNECT(startPrivateTimer.timeout, eEPGCache::channel_data::startPrivateReader);
+ CONNECT(startPrivateTimer->timeout, eEPGCache::channel_data::startPrivateReader);
#endif
pthread_mutex_init(&channel_active, 0);
}
if (!isRunning) // epg ready
{
eDebug("[EPGC] stop caching events(%ld)", ::time(0));
- zapTimer.start(UPDATE_INTERVAL, 1);
+ zapTimer->start(UPDATE_INTERVAL, 1);
eDebug("[EPGC] next update in %i min", UPDATE_INTERVAL / 60000);
for (int i=0; i < 3; ++i)
{
m_ScheduleOtherReader->start(mask);
isRunning |= SCHEDULE_OTHER;
- abortTimer.start(7000,true);
+ abortTimer->start(7000,true);
}
void eEPGCache::channel_data::abortNonAvail()
}
#endif
if ( isRunning )
- abortTimer.start(90000, true);
+ abortTimer->start(90000, true);
else
{
++state;
if (update < ZAP_DELAY)
update = ZAP_DELAY;
- zapTimer.start(update, 1);
+ zapTimer->start(update, 1);
if (update >= 60000)
eDebug("[EPGC] next update in %i min", update/60000);
else if (update >= 1000)
seenSections[i].clear();
calcedSections[i].clear();
}
- abortTimer.stop();
- zapTimer.stop();
+ abortTimer->stop();
+ zapTimer->stop();
if (isRunning)
{
eDebug("[EPGC] abort caching events !!");
void eEPGCache::channel_data::startTimeout(int msec)
{
- m_MHWTimeoutTimer.start(msec,true);
+ m_MHWTimeoutTimer->start(msec,true);
m_MHWTimeoutet=false;
}
pthread_mutex_t channel_active;
channel_data(eEPGCache*);
eEPGCache *cache;
- eTimer abortTimer, zapTimer;
+ ePtr<eTimer> abortTimer, zapTimer;
int prevChannelState;
__u8 state, isRunning, haveData;
ePtr<eDVBChannel> channel;
ePtr<iDVBSectionReader> m_NowNextReader, m_ScheduleReader, m_ScheduleOtherReader;
tidMap seenSections[3], calcedSections[3];
#ifdef ENABLE_PRIVATE_EPG
- eTimer startPrivateTimer;
+ ePtr<eTimer> startPrivateTimer;
int m_PrevVersion;
int m_PrivatePid;
uniqueEPGKey m_PrivateService;
ePtr<eConnection> m_MHWConn, m_MHWConn2;
ePtr<iDVBSectionReader> m_MHWReader, m_MHWReader2;
eDVBSectionFilterMask m_MHWFilterMask, m_MHWFilterMask2;
- eTimer m_MHWTimeoutTimer;
+ ePtr<eTimer> m_MHWTimeoutTimer;
bool m_MHWTimeoutet;
void MHWTimeout() { m_MHWTimeoutet=true; }
void readMHWData(const __u8 *data);
friend class channel_data;
static eEPGCache *instance;
- eTimer cleanTimer;
+ ePtr<eTimer> cleanTimer;
std::map<iDVBChannel*, channel_data*> m_knownChannels;
ePtr<eConnection> m_chanAddedConn;
}
eGTable::eGTable(bool debug):
- m_timeout(0), m_debug(debug), error(0)
+ m_debug(debug), error(0)
{
}
if (m_table.flags & eDVBTableSpec::tfHaveTimeout)
{
- if (m_timeout)
- delete m_timeout;
- m_timeout = new eTimer(eApp);
+ m_timeout = eTimer::create(eApp);
m_timeout->start(m_table.timeout, 1); // begin timeout
CONNECT(m_timeout->timeout, eGTable::timeout);
}
eGTable::~eGTable()
{
- if (m_timeout)
- delete m_timeout;
}
void eAUGTable::slotTableReady(int error)
unsigned int m_tries;
- eTimer *m_timeout;
+ ePtr<eTimer> m_timeout;
void sectionRead(const __u8 *data);
void timeout();
sprintf(m_filename, "/dev/dvb/adapter%d/frontend%d", adap, fe);
#endif
- m_timeout = new eTimer(eApp);
+ m_timeout = eTimer::create(eApp);
CONNECT(m_timeout->timeout, eDVBFrontend::timeout);
- m_tuneTimer = new eTimer(eApp);
+ m_tuneTimer = eTimer::create(eApp);
CONNECT(m_tuneTimer->timeout, eDVBFrontend::tuneLoop);
for (int i=0; i<eDVBFrontend::NUM_DATA_ENTRIES; ++i)
{
m_data[LINKED_PREV_PTR] = m_data[LINKED_NEXT_PTR] = -1;
closeFrontend();
- delete m_timeout;
- delete m_tuneTimer;
}
void eDVBFrontend::feEvent(int w)
ePtr<iDVBSatelliteEquipmentControl> m_sec;
ePtr<eSocketNotifier> m_sn;
int m_tuning;
- eTimer *m_timeout;
- eTimer *m_tuneTimer;
+ ePtr<eTimer> m_timeout, m_tuneTimer;
eSecCommandList m_sec_sequence;
ePtr<eConnection> eDVBCAService::m_chanAddedConn;
eDVBCAService::eDVBCAService()
- : m_prev_build_hash(0), m_sendstate(0), m_retryTimer(eApp)
+ : m_prev_build_hash(0), m_sendstate(0), m_retryTimer(eTimer::create(eApp))
{
memset(m_used_demux, 0xFF, sizeof(m_used_demux));
- CONNECT(m_retryTimer.timeout, eDVBCAService::sendCAPMT);
+ CONNECT(m_retryTimer->timeout, eDVBCAService::sendCAPMT);
Connect();
}
{
case 0xFFFFFFFF:
++m_sendstate;
- m_retryTimer.start(0,true);
+ m_retryTimer->start(0,true);
// eDebug("[eDVBCAService] send failed .. immediate retry");
break;
default:
- m_retryTimer.start(5000,true);
+ m_retryTimer->start(5000,true);
// eDebug("[eDVBCAService] send failed .. retry in 5 sec");
break;
}
struct sockaddr_un m_servaddr;
unsigned int m_sendstate;
unsigned char m_capmt[2048];
- eTimer m_retryTimer;
+ ePtr<eTimer> m_retryTimer;
void sendCAPMT();
void Connect();
void socketCB(int what);
eDVBRdsDecoder::eDVBRdsDecoder(iDVBDemux *demux)
:msgPtr(0), bsflag(0), qdar_pos(0), t_ptr(0), qdarmvi_show(0), state(0)
- ,m_abortTimer(eApp)
+ ,m_abortTimer(eTimer::create(eApp))
{
setStreamID(0xC0, 0xC0);
eDebug("failed to create PES reader!");
else
m_pes_reader->connectRead(slot(*this, &eDVBRdsDecoder::processData), m_read_connection);
- CONNECT(m_abortTimer.timeout, eDVBRdsDecoder::abortNonAvail);
+ CONNECT(m_abortTimer->timeout, eDVBRdsDecoder::abortNonAvail);
}
eDVBRdsDecoder::~eDVBRdsDecoder()
if (data[offs] == 0xFD)
{
- m_abortTimer.stop();
+ m_abortTimer->stop();
int ancillary_len = 1 + data[offs - 1];
offs -= ancillary_len;
gotAncillaryData(data+offs, ancillary_len);
{
int ret = -1;
if (m_pes_reader && !(ret = m_pes_reader->start(pid)))
- m_abortTimer.startLongTimer(20);
+ m_abortTimer->startLongTimer(20);
return ret;
}
ePtr<iDVBPESReader> m_pes_reader;
ePtr<eConnection> m_read_connection;
Signal1<void, int> m_event;
- eTimer m_abortTimer;
+ ePtr<eTimer> m_abortTimer;
};
#endif
*/
eSubtitleWidget::eSubtitleWidget(eWidget *parent)
- : eWidget(parent), m_hide_subtitles_timer(eApp)
+ : eWidget(parent), m_hide_subtitles_timer(eTimer::create(eApp))
{
setBackgroundColor(gRGB(0,0,0,255));
m_page_ok = 0;
m_dvb_page_ok = 0;
- CONNECT(m_hide_subtitles_timer.timeout, eSubtitleWidget::clearPage);
+ CONNECT(m_hide_subtitles_timer->timeout, eSubtitleWidget::clearPage);
}
#define startX 50
m_visible_region.rects.push_back(area);
}
}
- m_hide_subtitles_timer.start(7500, true);
+ m_hide_subtitles_timer->start(7500, true);
invalidate(m_visible_region); // invalidate new regions
}
m_visible_region.rects.push_back(eRect(it->m_position, it->m_pixmap->size()));
}
m_dvb_page_ok = 1;
- m_hide_subtitles_timer.start(7500, true);
+ m_hide_subtitles_timer->start(7500, true);
invalidate(m_visible_region); // invalidate new regions
}
}
}
int timeout_ms = m_pango_page.m_timeout;
- m_hide_subtitles_timer.start(timeout_ms, true);
+ m_hide_subtitles_timer->start(timeout_ms, true);
invalidate(m_visible_region); // invalidate new regions
}
int m_pango_page_ok;
ePangoSubtitlePage m_pango_page;
- eTimer m_hide_subtitles_timer;
+ ePtr<eTimer> m_hide_subtitles_timer;
gRegion m_visible_region;
{
if (m_mainloop)
{
- delete m_timer;
m_timer = 0;
m_mainloop = 0;
}
m_mainloop = &ml;
- m_timer = new eTimer(m_mainloop);
+ m_timer = eTimer::create(m_mainloop);
CONNECT(m_timer->timeout, eWidgetDesktop::paint);
if (m_require_redraw)
removeBufferForWidget(*i, l);
}
-eWidgetDesktop::eWidgetDesktop(eSize size): m_mainloop(0), m_timer(0)
+eWidgetDesktop::eWidgetDesktop(eSize size): m_mainloop(0)
{
m_screen.m_dirty_region = gRegion(eRect(ePoint(0, 0), size));
m_screen.m_screen_size = size;
void paintBackground(eWidgetDesktopCompBuffer *comp);
eMainloop *m_mainloop;
- eTimer *m_timer;
+ ePtr<eTimer> m_timer;
int m_comp_mode;
int m_require_redraw;
m_tune_state = -1;
- CONNECT(m_subtitle_sync_timer.timeout, eDVBServicePlay::checkSubtitleTiming);
+ m_subtitle_sync_timer = eTimer::create(eApp);
+
+ CONNECT(m_subtitle_sync_timer->timeout, eDVBServicePlay::checkSubtitleTiming);
}
eDVBServicePlay::~eDVBServicePlay()
} else
{
eDebug("start subtitle delay %d", diff / 90);
- m_subtitle_sync_timer.start(diff / 90, 1);
+ m_subtitle_sync_timer->start(diff / 90, 1);
break;
}
}
ePtr<eConnection> m_new_dvb_subtitle_page_connection;
std::list<eDVBSubtitlePage> m_dvb_subtitle_pages;
- eTimer m_subtitle_sync_timer;
+ ePtr<eTimer> m_subtitle_sync_timer;
void checkSubtitleTiming();
/* radiotext */
eServiceMP3::eServiceMP3(const char *filename): m_filename(filename), m_pump(eApp, 1)
{
+ m_seekTimeout = eTimer::create(eApp);
m_stream_tags = 0;
- m_audioStreams.clear();
- m_subtitleStreams.clear();
m_currentAudioStream = 0;
m_currentSubtitleStream = 0;
m_subtitle_widget = 0;
m_currentTrickRatio = 0;
- CONNECT(m_seekTimeout.timeout, eServiceMP3::seekTimeoutCB);
+ CONNECT(m_seekTimeout->timeout, eServiceMP3::seekTimeoutCB);
CONNECT(m_pump.recv_msg, eServiceMP3::gstPoll);
GstElement *source = 0;
{
m_currentTrickRatio = ratio;
if (ratio)
- m_seekTimeout.start(1000, 0);
+ m_seekTimeout->start(1000, 0);
else
- m_seekTimeout.stop();
+ m_seekTimeout->stop();
return 0;
}
if (ppos < 0)
{
ppos = 0;
- m_seekTimeout.stop();
+ m_seekTimeout->stop();
}
if (ppos > len)
{
ppos = 0;
stop();
- m_seekTimeout.stop();
+ m_seekTimeout->stop();
return;
}
seekTo(ppos);
std::vector<subtitleStream> m_subtitleStreams;
eSubtitleWidget *m_subtitle_widget;
int m_currentTrickRatio;
- eTimer m_seekTimeout;
+ ePtr<eTimer> m_seekTimeout;
void seekTimeoutCB();
friend class eServiceFactoryMP3;
std::string m_filename;