return 0;
}
-eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
+eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
{
m_is_primary = 1;
m_is_pvr = !m_reference.path.empty();
m_timeshift_enabled = m_timeshift_active = 0, m_timeshift_changed = 0;
- m_skipmode = 0;
+ m_skipmode = m_fastforward = m_slowmotion = 0;
CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
updateTimeshiftPids();
if (!m_timeshift_active)
updateDecoder();
- if (m_first_program_info && m_is_pvr)
+ if (m_first_program_info & 1 && m_is_pvr)
{
- m_first_program_info = 0;
+ m_first_program_info &= ~1;
seekTo(0);
}
- m_event((iPlayableService*)this, evUpdatedInfo);
+ if (!m_timeshift_active)
+ m_event((iPlayableService*)this, evUpdatedInfo);
break;
}
+ case eDVBServicePMTHandler::eventPreStart:
+ loadCuesheet();
+ break;
case eDVBServicePMTHandler::eventEOF:
m_event((iPlayableService*)this, evEOF);
break;
switch (event)
{
case eDVBServicePMTHandler::eventNewProgramInfo:
+ eDebug("eventNewProgramInfo TS");
if (m_timeshift_active)
+ {
updateDecoder();
+ if (m_first_program_info & 2)
+ {
+ if (m_slowmotion)
+ {
+ eDebug("re-apply slowmotion after timeshift file change");
+ m_decoder->setSlowMotion(m_slowmotion);
+ }
+ if (m_fastforward)
+ {
+ eDebug("re-apply skip %d, ratio %d after timeshift file change", m_skipmode, m_fastforward);
+ if (m_skipmode)
+ m_cue->setSkipmode(m_skipmode * 90000); /* convert to 90000 per second */
+ if (m_fastforward != 1)
+ m_decoder->setFastForward(m_fastforward);
+ else
+ m_decoder->setTrickmode();
+ }
+ else
+ seekTo(0);
+ m_first_program_info &= ~2;
+ }
+ m_event((iPlayableService*)this, evUpdatedInfo);
+ }
break;
case eDVBServicePMTHandler::eventSOF:
- m_event((iPlayableService*)this, evSOF);
+#if 0
+ if (!m_timeshift_file_next.empty())
+ {
+ eDebug("timeshift SOF, switch to next file");
+ m_decoder->pause();
+
+ m_first_program_info |= 2;
+
+ eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
+ r.path = m_timeshift_file_next;
+
+ /* free the timeshift service handler, we need the resources */
+ m_service_handler_timeshift.free();
+ resetTimeshift(1);
+
+ if (m_skipmode < 0)
+ m_cue->seekTo(0, -1000);
+ m_service_handler_timeshift.tune(r, 1, m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
+
+ m_event((iPlayableService*)this, evUser+1);
+ }
+ else
+#endif
+ m_event((iPlayableService*)this, evSOF);
break;
case eDVBServicePMTHandler::eventEOF:
if ((!m_is_paused) && (m_skipmode >= 0))
{
- eDebug("timeshift EOF, so let's go live");
- switchToLive();
+ if (m_timeshift_file_next.empty())
+ {
+ eDebug("timeshift EOF, so let's go live");
+ switchToLive();
+ }
+ else
+ {
+ eDebug("timeshift EOF, switch to next file");
+
+ m_first_program_info |= 2;
+
+ eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
+ r.path = m_timeshift_file_next;
+
+ /* free the timeshift service handler, we need the resources */
+ m_service_handler_timeshift.free();
+ resetTimeshift(1);
+
+ m_service_handler_timeshift.tune(r, 1, m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
+
+ m_event((iPlayableService*)this, evUser+1);
+ }
}
break;
}
RESULT eDVBServicePlay::start()
{
- int r;
+ eServiceReferenceDVB service = (eServiceReferenceDVB&)m_reference;
+
/* in pvr mode, we only want to use one demux. in tv mode, we're using
two (one for decoding, one for data source), as we must be prepared
to start recording from the data demux. */
if (m_is_pvr)
+ {
+ eDVBMetaParser meta;
+ if (!meta.parseFile(m_reference.path))
+ {
+ service = meta.m_ref;
+ service.path = m_reference.path;
+ }
m_cue = new eCueSheet();
+ }
else
m_event(this, evStart);
m_first_program_info = 1;
- eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference;
- r = m_service_handler.tune(service, m_is_pvr, m_cue, false, m_dvb_service);
+ m_service_handler.tune(service, m_is_pvr, m_cue, false, m_dvb_service);
- /* inject EIT if there is a stored one */
if (m_is_pvr)
{
+ /* inject EIT if there is a stored one */
std::string filename = service.path;
filename.erase(filename.length()-2, 2);
filename+="eit";
m_event_handler.inject(event, 0);
m_event_handler.inject(empty, 1);
}
- }
-
- if (m_is_pvr)
- {
- loadCuesheet();
m_event(this, evStart);
}
return 0;
if (length)
{
- int perc = play_position * 100LL / length;
-
- /* only store last play position when between 1% and 99% */
- if ((1 < perc) && (perc < 99))
- m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
+ m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
}
m_cuesheet_changed = 1;
}
eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio);
setFastForward_internal(0);
if (m_decoder)
+ {
+ m_slowmotion = ratio;
return m_decoder->setSlowMotion(ratio);
+ }
else
return -1;
}
return setFastForward_internal(ratio);
}
-RESULT eDVBServicePlay::setFastForward_internal(int ratio)
+RESULT eDVBServicePlay::setFastForward_internal(int ratio, bool final_seek)
{
- int skipmode, ffratio;
-
+ int skipmode, ffratio, ret = 0;
+ pts_t pos=0;
+
if (ratio > 8)
{
skipmode = ratio;
if (m_cue)
m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
}
-
+
m_skipmode = skipmode;
-
+
+ if (final_seek)
+ eDebug("trickplay stopped .. ret %d, pos %lld", getPlayPosition(pos), pos);
+
+ m_fastforward = ffratio;
+
if (!m_decoder)
return -1;
-
+
if (ffratio == 0)
; /* return m_decoder->play(); is done in caller*/
else if (ffratio != 1)
- return m_decoder->setFastForward(ffratio);
+ ret = m_decoder->setFastForward(ffratio);
else
- return m_decoder->setTrickmode();
- return 0;
+ ret = m_decoder->setTrickmode();
+
+ if (pos)
+ eDebug("final seek after trickplay ret %d", seekTo(pos));
+
+ return ret;
}
RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
RESULT eDVBServicePlay::pause()
{
eDebug("eDVBServicePlay::pause");
- setFastForward_internal(0);
+ setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
if (m_decoder)
{
+ m_slowmotion = 0;
m_is_paused = 1;
return m_decoder->pause();
} else
RESULT eDVBServicePlay::unpause()
{
eDebug("eDVBServicePlay::unpause");
- setFastForward_internal(0);
+ setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
if (m_decoder)
{
+ m_slowmotion = 0;
m_is_paused = 0;
return m_decoder->play();
} else
RESULT eDVBServicePlay::isCurrentlySeekable()
{
- return m_is_pvr || m_timeshift_active;
+ int ret = 0;
+ if (m_decoder)
+ {
+ ret = (m_is_pvr || m_timeshift_active) ? 3 : 0; // fast forward/backward possible and seeking possible
+ if (m_decoder->getVideoProgressive() == -1)
+ ret &= ~2;
+ }
+ return ret;
}
RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
{
eDVBServicePMTHandler::program program;
eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+ pts_t position = -1;
if (h.getProgramInfo(program))
return -1;
apidtype = program.audioStreams[stream].type;
}
+ if (i != -1 && apid != m_current_audio_pid && (m_is_pvr || m_timeshift_active))
+ eDebug("getPlayPosition ret %d, pos %lld in selectAudioStream", getPlayPosition(position), position);
+
m_current_audio_pid = apid;
if (m_is_primary && m_decoder->setAudioPID(apid, apidtype))
return -4;
}
+ if (position != -1)
+ eDebug("seekTo ret %d", seekTo(position));
+
int rdsPid = apid;
/* if we are not in PVR mode, timeshift is not active and we are not in pip mode, check if we need to enable the rds reader */
return 0;
}
-RESULT eDVBServicePlay::stopTimeshift()
+RESULT eDVBServicePlay::stopTimeshift(bool swToLive)
{
if (!m_timeshift_enabled)
return -1;
- switchToLive();
+ if (swToLive)
+ switchToLive();
m_timeshift_enabled = 0;
}
}
+RESULT eDVBServicePlay::setNextPlaybackFile(const char *f)
+{
+ m_timeshift_file_next = f;
+ return 0;
+}
+
void eDVBServicePlay::switchToLive()
{
if (!m_timeshift_active)
return;
-
+
eDebug("SwitchToLive");
-
+
+ resetTimeshift(0);
+
+ m_is_paused = m_skipmode = m_fastforward = m_slowmotion = 0; /* not supported in live mode */
+
+ /* free the timeshift service handler, we need the resources */
+ m_service_handler_timeshift.free();
+
+ updateDecoder(true);
+}
+
+void eDVBServicePlay::resetTimeshift(int start)
+{
m_cue = 0;
- m_decoder = 0;
m_decode_demux = 0;
+ m_decoder = 0;
m_teletext_parser = 0;
m_rds_decoder = 0;
m_subtitle_parser = 0;
- m_new_dvb_subtitle_page_connection = 0;
m_new_subtitle_page_connection = 0;
+ m_new_dvb_subtitle_page_connection = 0;
m_rds_decoder_event_connection = 0;
m_video_event_connection = 0;
- m_is_paused = m_skipmode = 0; /* not supported in live mode */
-
- /* free the timeshift service handler, we need the resources */
- m_service_handler_timeshift.free();
- m_timeshift_active = 0;
m_timeshift_changed = 1;
+ m_timeshift_file_next.clear();
- m_event((iPlayableService*)this, evSeekableStatusChanged);
-
- updateDecoder();
+ if (start)
+ {
+ m_cue = new eCueSheet();
+ m_timeshift_active = 1;
+ }
+ else
+ m_timeshift_active = 0;
}
void eDVBServicePlay::switchToTimeshift()
if (m_timeshift_active)
return;
- m_decode_demux = 0;
- m_decoder = 0;
- m_teletext_parser = 0;
- m_rds_decoder = 0;
- m_subtitle_parser = 0;
- m_new_subtitle_page_connection = 0;
- m_new_dvb_subtitle_page_connection = 0;
- m_rds_decoder_event_connection = 0;
- m_video_event_connection = 0;
-
- m_timeshift_active = 1;
- m_timeshift_changed = 1;
+ resetTimeshift(1);
eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
r.path = m_timeshift_file;
- m_cue = new eCueSheet();
+ m_cue->seekTo(0, -1000);
m_service_handler_timeshift.tune(r, 1, m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
pause();
- updateDecoder(); /* mainly to switch off PCR, and to set pause */
-
- m_event((iPlayableService*)this, evSeekableStatusChanged);
+ updateDecoder(true); /* mainly to switch off PCR, and to set pause */
}
-void eDVBServicePlay::updateDecoder()
+void eDVBServicePlay::updateDecoder(bool sendSeekableStateChanged)
{
int vpid = -1, vpidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
+ bool mustPlay = false;
eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
if (!m_decoder)
{
h.getDecodeDemux(m_decode_demux);
- if (m_timeshift_changed)
- m_decoder = 0;
if (m_decode_demux)
{
m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
Py_DECREF(subs);
}
}
- m_decoder->play(); /* pids will be set later */
}
if (m_cue)
m_cue->setDecodingDemux(m_decode_demux, m_decoder);
- m_decoder->play(); /* pids will be set later. */
+ mustPlay = true;
}
m_timeshift_changed = 0;
if (m_decoder)
{
+ bool wasSeekable = m_decoder->getVideoProgressive() != -1;
if (m_dvb_service)
{
achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
}
}
- std::string config_delay;
- int config_delay_int = 0;
- if(ePythonConfigQuery::getConfigValue("config.av.generalAC3delay", config_delay) == 0)
- config_delay_int = atoi(config_delay.c_str());
- m_decoder->setAC3Delay(ac3_delay == -1 ? config_delay_int : ac3_delay + config_delay_int);
-
- if(ePythonConfigQuery::getConfigValue("config.av.generalPCMdelay", config_delay) == 0)
- config_delay_int = atoi(config_delay.c_str());
- else
- config_delay_int = 0;
- m_decoder->setPCMDelay(pcm_delay == -1 ? config_delay_int : pcm_delay + config_delay_int);
+ setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
+ setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
m_decoder->setVideoPID(vpid, vpidtype);
selectAudioStream();
m_decoder->setRadioPic(radio_pic);
}
- m_decoder->set();
+ if (mustPlay)
+ m_decoder->play();
+ else
+ m_decoder->set();
+
m_decoder->setAudioChannel(achannel);
/* don't worry about non-existing services, nor pvr services */
m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
}
+ if (!sendSeekableStateChanged && (m_decoder->getVideoProgressive() != -1) != wasSeekable)
+ sendSeekableStateChanged = true;
}
m_have_video_pid = (vpid > 0 && vpid < 0x2000);
+
+ if (sendSeekableStateChanged)
+ m_event((iPlayableService*)this, evSeekableStatusChanged);
}
void eDVBServicePlay::loadCuesheet()
{
if (i == m_cue_entries.end())
{
- if (!have_any_span)
+ if (!have_any_span && !in)
break;
out = length;
} else {
{
have_any_span = 1;
m_cue->addSourceSpan(in, out);
+ in = out = 0;
}
in = length;
{
if (m_dvb_service)
m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
- if (m_decoder)
- m_decoder->setAC3Delay(delay);
+ if (m_decoder) {
+ std::string config_delay;
+ int config_delay_int = 0;
+ if(ePythonConfigQuery::getConfigValue("config.av.generalAC3delay", config_delay) == 0)
+ config_delay_int = atoi(config_delay.c_str());
+ m_decoder->setAC3Delay(delay + config_delay_int);
+ }
}
void eDVBServicePlay::setPCMDelay(int delay)
{
if (m_dvb_service)
m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
- if (m_decoder)
- m_decoder->setPCMDelay(delay);
+ if (m_decoder) {
+ std::string config_delay;
+ int config_delay_int = 0;
+ if(ePythonConfigQuery::getConfigValue("config.av.generalPCMdelay", config_delay) == 0)
+ config_delay_int = atoi(config_delay.c_str());
+ else
+ config_delay_int = 0;
+ m_decoder->setPCMDelay(delay + config_delay_int);
+ }
}
void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
git.cweiske.de / enigma2.git / blobdiff