X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/5698c2b573e69c2e62ee8212893f620f0588c208..f1905e060a3a947ac2d3825e43b3052b361c71e6:/lib/service/servicedvb.cpp?ds=sidebyside diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp index 8a609095..9cac25fa 100644 --- a/lib/service/servicedvb.cpp +++ b/lib/service/servicedvb.cpp @@ -97,50 +97,9 @@ int eStaticServiceDVBInformation::isPlayable(const eServiceReference &ref, const } extern void PutToDict(ePyObject &dict, const char*key, long value); // defined in dvb/frontend.cpp -extern void PutToDict(ePyObject &dict, const char*key, ePyObject item); // defined in dvb/frontend.cpp -extern void PutToDict(ePyObject &dict, const char*key, const char *value); // defined in dvb/frontend.cpp - -void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm) -{ - PutToDict(dict, "tuner_type", "DVB-S"); - PutToDict(dict, "frequency", feparm.frequency); - PutToDict(dict, "symbol_rate", feparm.symbol_rate); - PutToDict(dict, "orbital_position", feparm.orbital_position); - PutToDict(dict, "inversion", feparm.inversion); - PutToDict(dict, "fec_inner", feparm.fec); - PutToDict(dict, "modulation", feparm.modulation); - PutToDict(dict, "polarization", feparm.polarisation); - if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S2) - { - PutToDict(dict, "rolloff", feparm.rolloff); - PutToDict(dict, "pilot", feparm.pilot); - } - PutToDict(dict, "system", feparm.system); -} - -void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm) -{ - PutToDict(dict, "tuner_type", "DVB-T"); - PutToDict(dict, "frequency", feparm.frequency); - PutToDict(dict, "bandwidth", feparm.bandwidth); - PutToDict(dict, "code_rate_lp", feparm.code_rate_LP); - PutToDict(dict, "code_rate_hp", feparm.code_rate_HP); - PutToDict(dict, "constellation", feparm.modulation); - PutToDict(dict, "transmission_mode", feparm.transmission_mode); - PutToDict(dict, "guard_interval", feparm.guard_interval); - PutToDict(dict, "hierarchy_information", feparm.hierarchy); - PutToDict(dict, "inversion", feparm.inversion); -} - -void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm) -{ - PutToDict(dict, "tuner_type", "DVB-C"); - PutToDict(dict, "frequency", feparm.frequency); - PutToDict(dict, "symbol_rate", feparm.symbol_rate); - PutToDict(dict, "modulation", feparm.modulation); - PutToDict(dict, "inversion", feparm.inversion); - PutToDict(dict, "fec_inner", feparm.fec_inner); -} +extern void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm); // defined in dvb/frontend.cpp +extern void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm); // defined in dvb/frontend.cpp +extern void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm); // defined in dvb/frontend.cpp PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what) { @@ -336,6 +295,7 @@ public: int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; } int getInfo(const eServiceReference &ref, int w); std::string getInfoString(const eServiceReference &ref,int w); + PyObject *getInfoObject(const eServiceReference &r, int what); }; DEFINE_REF(eStaticServiceDVBPVRInformation); @@ -400,6 +360,8 @@ int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w return iServiceInformation::resIsString; case iServiceInformation::sServiceref: return iServiceInformation::resIsString; + case iServiceInformation::sFileSize: + return m_parser.m_filesize; case iServiceInformation::sTimeCreate: if (m_parser.m_time_create) return m_parser.m_time_create; @@ -425,6 +387,17 @@ std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReferen } } +PyObject *eStaticServiceDVBPVRInformation::getInfoObject(const eServiceReference &r, int what) +{ + switch (what) + { + case iServiceInformation::sFileSize: + return PyLong_FromLongLong(m_parser.m_filesize); + default: + Py_RETURN_NONE; + } +} + RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr &evt, time_t start_time) { if (!ref.path.empty()) @@ -452,6 +425,7 @@ public: RESULT deleteFromDisk(int simulate); RESULT getListOfFilenames(std::list &); + RESULT reindex(); }; DEFINE_REF(eDVBPVRServiceOfflineOperations); @@ -514,6 +488,43 @@ RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list extensions; extensions.push_back("ts"); + extensions.push_back("trp"); sc->addServiceFactory(eServiceFactoryDVB::id, this, extensions); } @@ -859,43 +871,54 @@ RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr< RESULT eServiceFactoryDVB::lookupService(ePtr &service, const eServiceReference &ref) { - // TODO: handle the listing itself - // if (ref.... == -1) .. return "... bouquets ..."; - // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists - // TODO: cache - ePtr db; - ePtr res; - - int err; - if ((err = eDVBResourceManager::getInstance(res)) != 0) + if (!ref.path.empty()) // playback { - eDebug("no resource manager"); - return err; + eDVBMetaParser parser; + int ret=parser.parseFile(ref.path); + service = new eDVBService; + if (!ret) + eDVBDB::getInstance()->parseServiceData(service, parser.m_service_data); } - if ((err = res->getChannelList(db)) != 0) + else { - eDebug("no channel list"); - return err; - } + // TODO: handle the listing itself + // if (ref.... == -1) .. return "... bouquets ..."; + // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists + // TODO: cache + ePtr db; + ePtr res; + + int err; + if ((err = eDVBResourceManager::getInstance(res)) != 0) + { + eDebug("no resource manager"); + return err; + } + if ((err = res->getChannelList(db)) != 0) + { + eDebug("no channel list"); + return err; + } /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */ - if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0) - { - eDebug("getService failed!"); - return err; + if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0) + { + eDebug("getService failed!"); + return err; + } } 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_skipmode = 0; + m_timeshift_enabled = m_timeshift_active = 0, m_timeshift_changed = 0; + m_skipmode = m_fastforward = m_slowmotion = 0; CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent); CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift); @@ -915,6 +938,29 @@ eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *serv eDVBServicePlay::~eDVBServicePlay() { + if (m_is_pvr) + { + eDVBMetaParser meta; + int ret=meta.parseFile(m_reference.path); + if (!ret) + { + char tmp[255]; + meta.m_service_data=""; + sprintf(tmp, "f:%x", m_dvb_service->m_flags); + meta.m_service_data += tmp; + // cached pids + for (int x=0; x < eDVBService::cacheMax; ++x) + { + int entry = m_dvb_service->getCacheEntry((eDVBService::cacheID)x); + if (entry != -1) + { + sprintf(tmp, ",c:%02d%04x", x, entry); + meta.m_service_data += tmp; + } + } + meta.updateMeta(m_reference.path); + } + } delete m_subtitle_widget; } @@ -976,14 +1022,18 @@ void eDVBServicePlay::serviceEvent(int event) 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; @@ -998,17 +1048,85 @@ void eDVBServicePlay::serviceEventTimeshift(int event) 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; } @@ -1016,22 +1134,30 @@ void eDVBServicePlay::serviceEventTimeshift(int event) 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); + 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"; @@ -1042,11 +1168,6 @@ RESULT eDVBServicePlay::start() m_event_handler.inject(event, 0); m_event_handler.inject(empty, 1); } - } - - if (m_is_pvr) - { - loadCuesheet(); m_event(this, evStart); } return 0; @@ -1077,11 +1198,7 @@ RESULT eDVBServicePlay::stop() 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; } @@ -1132,11 +1249,14 @@ RESULT eDVBServicePlay::pause(ePtr &ptr) RESULT eDVBServicePlay::setSlowMotion(int ratio) { - assert(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */ + ASSERT(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */ eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio); setFastForward_internal(0); if (m_decoder) + { + m_slowmotion = ratio; return m_decoder->setSlowMotion(ratio); + } else return -1; } @@ -1144,14 +1264,15 @@ RESULT eDVBServicePlay::setSlowMotion(int ratio) RESULT eDVBServicePlay::setFastForward(int ratio) { eDebug("eDVBServicePlay::setFastForward(%d)", ratio); - assert(ratio); + ASSERT(ratio); 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; @@ -1176,18 +1297,28 @@ RESULT eDVBServicePlay::setFastForward_internal(int 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(); + ; /* 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(); + ret = m_decoder->setTrickmode(); + + if (pos) + eDebug("final seek after trickplay ret %d", seekTo(pos)); + + return ret; } RESULT eDVBServicePlay::seek(ePtr &ptr) @@ -1216,9 +1347,10 @@ RESULT eDVBServicePlay::getLength(pts_t &len) 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 @@ -1228,9 +1360,10 @@ RESULT eDVBServicePlay::pause() 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 @@ -1320,7 +1453,14 @@ RESULT eDVBServicePlay::setTrickmode(int trick) 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 &ptr) @@ -1424,7 +1564,7 @@ RESULT eDVBServicePlay::getName(std::string &name) ePtr i = new eStaticServiceDVBPVRInformation(m_reference); return i->getName(m_reference, name); } - if (m_dvb_service) + else if (m_dvb_service) { m_dvb_service->getName(m_reference, name); if (name.empty()) @@ -1479,7 +1619,7 @@ int eDVBServicePlay::getInfo(int w) int aspect = -1; if (m_decoder) aspect = m_decoder->getVideoAspect(); - if (no_program_info) + if (aspect == -1 && no_program_info) break; else if (aspect == -1 && !program.videoStreams.empty() && program.videoStreams[0].component_tag != -1) { @@ -1523,10 +1663,34 @@ int eDVBServicePlay::getInfo(int w) break; } case sIsCrypted: if (no_program_info) return -1; return program.isCrypted(); - case sVideoPID: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid; + case sVideoPID: + if (m_dvb_service) + { + int vpid = m_dvb_service->getCacheEntry(eDVBService::cVPID); + if (vpid != -1) + return vpid; + } + if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid; case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type; - case sAudioPID: if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid; - case sPCRPID: if (no_program_info) return -1; return program.pcrPid; + case sAudioPID: + if (m_dvb_service) + { + int apid = m_dvb_service->getCacheEntry(eDVBService::cAPID); + if (apid != -1) + return apid; + apid = m_dvb_service->getCacheEntry(eDVBService::cAC3PID); + if (apid != -1) + return apid; + } + if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid; + case sPCRPID: + if (m_dvb_service) + { + int pcrpid = m_dvb_service->getCacheEntry(eDVBService::cPCRPID); + if (pcrpid != -1) + return pcrpid; + } + if (no_program_info) return -1; return program.pcrPid; case sPMTPID: if (no_program_info) return -1; return program.pmtPid; case sTXTPID: if (no_program_info) return -1; return program.textPid; case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get(); @@ -1601,7 +1765,7 @@ RESULT eDVBServicePlay::selectTrack(unsigned int i) { int ret = selectAudioStream(i); - if (m_decoder->play()) + if (m_decoder->set()) return -5; return ret; @@ -1654,6 +1818,7 @@ int eDVBServicePlay::selectAudioStream(int i) { 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; @@ -1676,29 +1841,40 @@ int eDVBServicePlay::selectAudioStream(int i) 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_decoder->setAudioPID(apid, apidtype)) + if (m_is_primary && m_decoder->setAudioPID(apid, apidtype)) { eDebug("set audio pid failed"); 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 */ if (!(m_is_pvr || m_timeshift_active || !m_is_primary)) - if (!m_rds_decoder) + { + int different_pid = program.videoStreams.empty() && program.audioStreams.size() == 1 && program.audioStreams[stream].rdsPid != -1; + if (different_pid) + rdsPid = program.audioStreams[stream].rdsPid; + if (!m_rds_decoder || m_rds_decoder->getPid() != rdsPid) { + m_rds_decoder = 0; ePtr data_demux; if (!h.getDataDemux(data_demux)) { - m_rds_decoder = new eDVBRdsDecoder(data_demux); + m_rds_decoder = new eDVBRdsDecoder(data_demux, different_pid); m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection); + m_rds_decoder->start(rdsPid); } } - - /* if we decided that we need one, update the pid */ - if (m_rds_decoder) - m_rds_decoder->start(apid); + } /* store new pid as default only when: a.) we have an entry in the service db for the current service, @@ -1707,7 +1883,7 @@ int eDVBServicePlay::selectAudioStream(int i) anything in the best case, or destroy the default setting in case the real default is not yet available.) */ - if (m_dvb_service && !m_is_pvr && ((i != -1) + if (m_dvb_service && ((i != -1) || ((m_dvb_service->getCacheEntry(eDVBService::cAPID) == -1) && (m_dvb_service->getCacheEntry(eDVBService::cAC3PID)==-1)))) { if (apidtype == eDVBAudio::aMPEG) @@ -1715,11 +1891,16 @@ int eDVBServicePlay::selectAudioStream(int i) m_dvb_service->setCacheEntry(eDVBService::cAPID, apid); m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1); } - else + else if (apidtype == eDVBAudio::aAC3) { m_dvb_service->setCacheEntry(eDVBService::cAPID, -1); m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid); } + else + { + m_dvb_service->setCacheEntry(eDVBService::cAPID, -1); + m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1); + } } h.resetCachedProgram(); @@ -1877,20 +2058,7 @@ PyObject *eDVBServiceBase::getTransponderData(bool original) { ePtr fe; if(!channel->getFrontend(fe)) - { fe->getTransponderData(ret, original); - ePtr feparm; - channel->getCurrentFrontendParameters(feparm); - if (feparm) - { - eDVBFrontendParametersSatellite osat; - if (!feparm->getDVBS(osat)) - { - PutToDict(ret, "orbital_position", osat.orbital_position); - PutToDict(ret, "polarization", osat.polarisation); - } - } - } } } else @@ -1987,12 +2155,13 @@ RESULT eDVBServicePlay::startTimeshift() return 0; } -RESULT eDVBServicePlay::stopTimeshift() +RESULT eDVBServicePlay::stopTimeshift(bool swToLive) { if (!m_timeshift_enabled) return -1; - switchToLive(); + if (swToLive) + switchToLive(); m_timeshift_enabled = 0; @@ -2141,38 +2310,32 @@ void eDVBServicePlay::updateTimeshiftPids() } } +RESULT eDVBServicePlay::setNextPlaybackFile(const char *f) +{ + m_timeshift_file_next = f; + return 0; +} + void eDVBServicePlay::switchToLive() { if (!m_timeshift_active) return; - + eDebug("SwitchToLive"); - - m_cue = 0; - m_decoder = 0; - m_decode_demux = 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_rds_decoder_event_connection = 0; - m_video_event_connection = 0; - /* free the timeshift service handler, we need the resources */ - m_service_handler_timeshift.free(); - m_timeshift_active = 0; + resetTimeshift(0); + + m_is_paused = m_skipmode = m_fastforward = m_slowmotion = 0; /* not supported in live mode */ - m_event((iPlayableService*)this, evSeekableStatusChanged); + /* free the timeshift service handler, we need the resources */ + m_service_handler_timeshift.free(); - updateDecoder(); + updateDecoder(true); } -void eDVBServicePlay::switchToTimeshift() +void eDVBServicePlay::resetTimeshift(int start) { - if (m_timeshift_active) - return; - + m_cue = 0; m_decode_demux = 0; m_decoder = 0; m_teletext_parser = 0; @@ -2182,25 +2345,40 @@ void eDVBServicePlay::switchToTimeshift() m_new_dvb_subtitle_page_connection = 0; m_rds_decoder_event_connection = 0; m_video_event_connection = 0; + m_timeshift_changed = 1; + m_timeshift_file_next.clear(); - m_timeshift_active = 1; + if (start) + { + m_cue = new eCueSheet(); + m_timeshift_active = 1; + } + else + m_timeshift_active = 0; +} + +void eDVBServicePlay::switchToTimeshift() +{ + if (m_timeshift_active) + return; + + 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; @@ -2256,29 +2434,47 @@ void eDVBServicePlay::updateDecoder() m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary); if (m_decoder) m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection); - m_teletext_parser = new eDVBTeletextParser(m_decode_demux); - m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection); - m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux); - m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection); - } else - { - m_teletext_parser = 0; - m_subtitle_parser = 0; + if (m_is_primary) + { + m_teletext_parser = new eDVBTeletextParser(m_decode_demux); + m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection); + m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux); + m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection); + if (m_timeshift_changed) + { + ePyObject subs = getCachedSubtitle(); + if (subs != Py_None) + { + int type = PyInt_AsLong(PyTuple_GET_ITEM(subs, 0)), + pid = PyInt_AsLong(PyTuple_GET_ITEM(subs, 1)), + comp_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 2)), // ttx page + anc_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 3)); // ttx magazine + if (type == 0) // dvb + m_subtitle_parser->start(pid, comp_page, anc_page); + else if (type == 1) // ttx + m_teletext_parser->setPageAndMagazine(comp_page, anc_page); + } + Py_DECREF(subs); + } + } } - if (m_cue) m_cue->setDecodingDemux(m_decode_demux, m_decoder); + 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); ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY); pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY); } - else // subservice or recording + else // subservice { eServiceReferenceDVB ref; m_service_handler.getServiceReference(ref); @@ -2303,8 +2499,9 @@ void eDVBServicePlay::updateDecoder() } } } - m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay); - m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay); + + setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay); + setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay); m_decoder->setVideoPID(vpid, vpidtype); selectAudioStream(); @@ -2314,16 +2511,11 @@ void eDVBServicePlay::updateDecoder() else m_decoder->setSyncPCR(-1); - m_decoder->setTextPID(tpid); - - m_teletext_parser->start(program.textPid); - -/* if (!m_is_primary) - m_decoder->setTrickmode(); - else */ if (m_is_paused) - m_decoder->pause(); - else - m_decoder->play(); + if (m_is_primary) + { + m_decoder->setTextPID(tpid); + m_teletext_parser->start(program.textPid); + } if (vpid > 0 && vpid < 0x2000) ; @@ -2334,10 +2526,15 @@ void eDVBServicePlay::updateDecoder() m_decoder->setRadioPic(radio_pic); } + if (mustPlay) + m_decoder->play(); + else + m_decoder->set(); + m_decoder->setAudioChannel(achannel); /* don't worry about non-existing services, nor pvr services */ - if (m_dvb_service && !m_is_pvr) + if (m_dvb_service) { /* (audio pid will be set in selectAudioTrack */ m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid); @@ -2345,8 +2542,13 @@ void eDVBServicePlay::updateDecoder() 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() @@ -2441,11 +2643,16 @@ void eDVBServicePlay::cutlistToCuesheet() std::multiset::iterator i(m_cue_entries.begin()); + int have_any_span = 0; + while (1) { if (i == m_cue_entries.end()) + { + if (!have_any_span && !in) + break; out = length; - else { + } else { if (i->what == 0) /* in */ { in = i++->where; @@ -2469,7 +2676,11 @@ void eDVBServicePlay::cutlistToCuesheet() out = length; if (in < out) + { + have_any_span = 1; m_cue->addSourceSpan(in, out); + in = out = 0; + } in = length; @@ -2613,7 +2824,7 @@ PyObject *eDVBServicePlay::getCachedSubtitle() PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext else PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb - PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong((data&0xFFFF0000)>>16)); // pid + PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pid)); // pid PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine return tuple; @@ -2748,18 +2959,22 @@ void eDVBServicePlay::checkSubtitleTiming() m_decoder->getPTS(0, pos); eDebug("%lld %lld", pos, show_time); - int diff = show_time - pos; + int diff = show_time - pos; + if (type == TELETEXT && !page.m_have_pts) + { + eDebug("ttx subtitle page without pts... immediate show"); + diff = 0; + } if (diff < 0) { eDebug("[late (%d ms)]", -diff / 90); diff = 0; } -// if (diff > 900000) -// { -// eDebug("[invalid]"); -// diff = 0; -// } - + if (abs(diff) > 1800000) + { + eDebug("[invalid]... immediate show!"); + diff = 0; + } if ((diff/90)<20) { if (type == TELETEXT) @@ -2820,16 +3035,28 @@ void eDVBServicePlay::setAC3Delay(int delay) { 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)