X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/60ec3eac7d6877da641494e76d043651a048aea7..11191e49b6c976338265d026ae33477a1d97fb9b:/lib/service/servicedvb.cpp diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp index 542e6359..75b55215 100644 --- a/lib/service/servicedvb.cpp +++ b/lib/service/servicedvb.cpp @@ -5,23 +5,28 @@ #include #include #include - +#include // access to python config #include #include #include +#include #include #include #include #include #include + /* for subtitles */ +#include + #include +#include #include #include -#include +#define INTERNAL_TELETEXT #ifndef BYTE_ORDER #error no byte order defined! @@ -143,7 +148,8 @@ public: eStaticServiceDVBPVRInformation(const eServiceReference &ref); RESULT getName(const eServiceReference &ref, std::string &name); int getLength(const eServiceReference &ref); - + RESULT getEvent(const eServiceReference &ref, ePtr &SWIG_OUTPUT, time_t start_time); + int getInfo(const eServiceReference &ref, int w); std::string getInfoString(const eServiceReference &ref,int w); }; @@ -185,6 +191,8 @@ int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w { case iServiceInformation::sDescription: return iServiceInformation::resIsString; + case iServiceInformation::sServiceref: + return iServiceInformation::resIsString; case iServiceInformation::sTimeCreate: if (m_parser.m_time_create) return m_parser.m_time_create; @@ -201,11 +209,31 @@ std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReferen { case iServiceInformation::sDescription: return m_parser.m_description; + case iServiceInformation::sServiceref: + return m_parser.m_ref.toString(); default: return ""; } } +RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr &evt, time_t start_time) +{ + if (!ref.path.empty()) + { + ePtr event = new eServiceEvent; + std::string filename = ref.path; + filename.erase(filename.length()-2, 2); + filename+="eit"; + if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get())) + { + evt = event; + return 0; + } + } + evt = 0; + return -1; +} + class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations { DECLARE_REF(eDVBPVRServiceOfflineOperations); @@ -233,11 +261,17 @@ RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate) if (getListOfFilenames(res)) return -1; - /* TODO: deferred removing.. */ + eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance(); + if (!eraser) + eDebug("FATAL !! can't get background file eraser"); + for (std::list::iterator i(res.begin()); i != res.end(); ++i) { eDebug("Removing %s...", i->c_str()); - ::unlink(i->c_str()); + if (eraser) + eraser->erase(i->c_str()); + else + ::unlink(i->c_str()); } return 0; @@ -248,10 +282,25 @@ RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::listaddServiceFactory(eServiceFactoryDVB::id, this); + + m_StaticServiceDVBInfo = new eStaticServiceDVBInformation; + m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation; } eServiceFactoryDVB::~eServiceFactoryDVB() @@ -323,31 +375,6 @@ RESULT eDVBServiceList::startQuery() return 0; } -RESULT eDVBServiceList::getContent(PyObject *list, bool sorted) -{ - eServiceReferenceDVB ref; - - if (!m_query || !list || !PyList_Check(list)) - return -1; - - std::list tmplist; - - while (!m_query->getNextResult(ref)) - tmplist.push_back(ref); - - if (sorted) - tmplist.sort(iListableServiceCompare(this)); - - for (std::list::iterator it(tmplist.begin()); - it != tmplist.end(); ++it) - { - PyObject *refobj = New_eServiceReference(*it); - PyList_Append(list, refobj); - Py_DECREF(refobj); - } - return 0; -} - RESULT eDVBServiceList::getContent(std::list &list, bool sorted) { eServiceReferenceDVB ref; @@ -364,6 +391,91 @@ RESULT eDVBServiceList::getContent(std::list &list, bool sort return 0; } +// The first argument of this function is a format string to specify the order and +// the content of the returned list +// useable format options are +// R = Service Reference (as swig object .. this is very slow) +// S = Service Reference (as python string object .. same as ref.toString()) +// N = Service Name (as python string object) +// when exactly one return value per service is selected in the format string, +// then each value is directly a list entry +// when more than one value is returned per service, then the list is a list of +// python tuples +// unknown format string chars are returned as python None values ! +PyObject *eDVBServiceList::getContent(const char* format, bool sorted) +{ + PyObject *ret=0; + std::list tmplist; + int retcount=1; + + if (!format || !(retcount=strlen(format))) + format = "R"; // just return service reference swig object ... + + if (!getContent(tmplist, sorted)) + { + int services=tmplist.size(); + ePtr sptr; + eServiceCenterPtr service_center; + + if (strchr(format, 'N')) + eServiceCenter::getPrivInstance(service_center); + + ret = PyList_New(services); + std::list::iterator it(tmplist.begin()); + + for (int cnt=0; cnt < services; ++cnt) + { + eServiceReference &ref=*it++; + PyObject *tuple = retcount > 1 ? PyTuple_New(retcount) : 0; + for (int i=0; i < retcount; ++i) + { + PyObject *tmp=0; + switch(format[i]) + { + case 'R': // service reference (swig)object + tmp = New_eServiceReference(ref); + break; + case 'S': // service reference string + tmp = PyString_FromString(ref.toString().c_str()); + break; + case 'N': // service name + if (service_center) + { + service_center->info(ref, sptr); + if (sptr) + { + std::string name; + sptr->getName(ref, name); + if (name.length()) + tmp = PyString_FromString(name.c_str()); + } + } + if (!tmp) + tmp = PyString_FromString(""); + break; + default: + if (tuple) + { + tmp = Py_None; + Py_INCREF(Py_None); + } + break; + } + if (tmp) + { + if (tuple) + PyTuple_SET_ITEM(tuple, i, tmp); + else + PyList_SET_ITEM(ret, cnt, tmp); + } + } + if (tuple) + PyList_SET_ITEM(ret, cnt, tuple); + } + } + return ret ? ret : PyList_New(0); +} + RESULT eDVBServiceList::getNext(eServiceReference &ref) { if (!m_query) @@ -398,11 +510,11 @@ RESULT eDVBServiceList::startEdit(ePtr &res) return -1; } -RESULT eDVBServiceList::addService(eServiceReference &ref) +RESULT eDVBServiceList::addService(eServiceReference &ref, eServiceReference before) { if (!m_bouquet) return -1; - return m_bouquet->addService(ref); + return m_bouquet->addService(ref, before); } RESULT eDVBServiceList::removeService(eServiceReference &ref) @@ -476,9 +588,9 @@ RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr service; if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... ) - ptr = new eStaticServiceDVBInformation; + ptr = m_StaticServiceDVBInfo; else /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */ ptr = service; @@ -539,9 +651,10 @@ RESULT eServiceFactoryDVB::lookupService(ePtr &service, const eServ } eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service): - m_reference(ref), m_dvb_service(service), m_is_paused(0) + m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0) { - m_is_pvr = !ref.path.empty(); + m_is_primary = 1; + m_is_pvr = !m_reference.path.empty(); m_timeshift_enabled = m_timeshift_active = 0; m_skipmode = 0; @@ -552,10 +665,15 @@ eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *serv m_cuesheet_changed = 0; m_cutlist_enabled = 1; + + m_subtitle_widget = 0; + + CONNECT(m_subtitle_sync_timer.timeout, eDVBServicePlay::checkSubtitleTiming); } eDVBServicePlay::~eDVBServicePlay() { + delete m_subtitle_widget; } void eDVBServicePlay::gotNewEvent() @@ -633,6 +751,9 @@ void eDVBServicePlay::serviceEventTimeshift(int event) if (m_timeshift_active) updateDecoder(); break; + case eDVBServicePMTHandler::eventSOF: + m_event((iPlayableService*)this, evSOF); + break; case eDVBServicePMTHandler::eventEOF: switchToLive(); break; @@ -645,37 +766,28 @@ RESULT eDVBServicePlay::start() /* 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. */ - m_cue = new eCueSheet(); + if (m_is_pvr) + m_cue = new eCueSheet(); m_first_program_info = 1; eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference; r = m_service_handler.tune(service, m_is_pvr, m_cue); - + /* inject EIT if there is a stored one */ if (m_is_pvr) { std::string filename = service.path; filename.erase(filename.length()-2, 2); filename+="eit"; - int fd = ::open( filename.c_str(), O_RDONLY ); - if ( fd > -1 ) + ePtr event = new eServiceEvent; + if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get())) { - __u8 buf[4096]; - int rd = ::read(fd, buf, 4096); - ::close(fd); - if ( rd > 12 /*EIT_LOOP_SIZE*/ ) - { - Event ev(buf); - ePtr event = new eServiceEvent; - ePtr empty; - event->parseFrom(&ev, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()); - m_event_handler.inject(event, 0); - m_event_handler.inject(empty, 1); - eDebug("injected"); - } + ePtr empty; + m_event_handler.inject(event, 0); + m_event_handler.inject(empty, 1); } } - + if (m_is_pvr) loadCuesheet(); @@ -686,17 +798,51 @@ RESULT eDVBServicePlay::start() RESULT eDVBServicePlay::stop() { + /* add bookmark for last play position */ + if (m_is_pvr) + { + pts_t play_position; + if (!getPlayPosition(play_position)) + { + /* remove last position */ + for (std::multiset::iterator i(m_cue_entries.begin()); i != m_cue_entries.end();) + { + if (i->what == 3) /* current play position */ + { + m_cue_entries.erase(i); + i = m_cue_entries.begin(); + continue; + } else + ++i; + } + + m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */ + m_cuesheet_changed = 1; + } + } + stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */ m_service_handler_timeshift.free(); m_service_handler.free(); if (m_is_pvr && m_cuesheet_changed) - saveCuesheet(); + { + struct stat s; + /* save cuesheet only when main file is accessible. */ + if (!::stat(m_reference.path.c_str(), &s)) + saveCuesheet(); + } return 0; } +RESULT eDVBServicePlay::setTarget(int target) +{ + m_is_primary = !target; + return 0; +} + RESULT eDVBServicePlay::connectEvent(const Slot2 &event, ePtr &connection) { connection = new eConnection((iPlayableService*)this, m_event.connect(event)); @@ -888,7 +1034,7 @@ RESULT eDVBServicePlay::isCurrentlySeekable() return m_is_pvr || m_timeshift_active; } -RESULT eDVBServicePlay::frontendStatusInfo(ePtr &ptr) +RESULT eDVBServicePlay::frontendInfo(ePtr &ptr) { ptr = this; return 0; @@ -900,6 +1046,12 @@ RESULT eDVBServicePlay::info(ePtr &ptr) return 0; } +RESULT eDVBServicePlay::audioChannel(ePtr &ptr) +{ + ptr = this; + return 0; +} + RESULT eDVBServicePlay::audioTracks(ePtr &ptr) { ptr = this; @@ -915,7 +1067,8 @@ RESULT eDVBServicePlay::subServices(ePtr &ptr) RESULT eDVBServicePlay::timeshift(ePtr &ptr) { ptr = 0; - if (m_timeshift_enabled || !m_is_pvr) + if (m_have_video_pid && // HACK !!! FIXMEE !! temporary no timeshift on radio services !! + (m_timeshift_enabled || !m_is_pvr)) { if (!m_timeshift_enabled) { @@ -950,6 +1103,24 @@ RESULT eDVBServicePlay::cueSheet(ePtr &ptr) return -1; } +RESULT eDVBServicePlay::subtitle(ePtr &ptr) +{ + ptr = this; + return 0; +} + +RESULT eDVBServicePlay::audioDelay(ePtr &ptr) +{ + ptr = this; + return 0; +} + +RESULT eDVBServicePlay::radioText(ePtr &ptr) +{ + ptr = this; + return 0; +} + RESULT eDVBServicePlay::getName(std::string &name) { if (m_is_pvr) @@ -979,6 +1150,9 @@ int eDVBServicePlay::getInfo(int w) { eDVBServicePMTHandler::program program; + if (w == sCAIDs) + return resIsPyObject; + if (m_service_handler.getProgramInfo(program)) return -1; @@ -1023,9 +1197,10 @@ int eDVBServicePlay::getInfo(int w) } } return -1; - case sIsCrypted: return program.isCrypted; + case sIsCrypted: return program.isCrypted(); case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid; - case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[m_current_audio_stream].pid; + case sVideoType: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type; + case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid; case sPCRPID: return program.pcrPid; case sPMTPID: return program.pmtPid; case sTXTPID: return program.textPid; @@ -1040,15 +1215,28 @@ int eDVBServicePlay::getInfo(int w) } std::string eDVBServicePlay::getInfoString(int w) -{ +{ switch (w) { case sProvider: if (!m_dvb_service) return ""; return m_dvb_service->m_provider_name; default: - return ""; + break; + } + return iServiceInformation::getInfoString(w); +} + +PyObject *eDVBServicePlay::getInfoObject(int w) +{ + switch (w) + { + case sCAIDs: + return m_service_handler.getCaIds(); + default: + break; } + return iServiceInformation::getInfoObject(w); } int eDVBServicePlay::getNumberOfTracks() @@ -1083,6 +1271,8 @@ RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int info.m_description = "MPEG"; else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3) info.m_description = "AC3"; + else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC) + info.m_description = "AAC"; else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS) info.m_description = "DTS"; else @@ -1121,28 +1311,60 @@ int eDVBServicePlay::selectAudioStream(int i) if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type)) return -4; + if (m_radiotext_parser) + m_radiotext_parser->start(program.audioStreams[i].pid); + if (m_dvb_service && !m_is_pvr) { if (program.audioStreams[i].type == eDVBAudio::aMPEG) { - m_dvb_service->setCachePID(eDVBService::cAPID, program.audioStreams[i].pid); - m_dvb_service->setCachePID(eDVBService::cAC3PID, -1); - } else + m_dvb_service->setCacheEntry(eDVBService::cAPID, program.audioStreams[i].pid); + m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1); + } + else { - m_dvb_service->setCachePID(eDVBService::cAPID, -1); - m_dvb_service->setCachePID(eDVBService::cAC3PID, program.audioStreams[i].pid); + m_dvb_service->setCacheEntry(eDVBService::cAPID, -1); + m_dvb_service->setCacheEntry(eDVBService::cAC3PID, program.audioStreams[i].pid); } } - m_current_audio_stream = i; + return 0; +} +int eDVBServicePlay::getCurrentChannel() +{ + return m_decoder ? m_decoder->getAudioChannel() : STEREO; +} + +RESULT eDVBServicePlay::selectChannel(int i) +{ + if (i < LEFT || i > RIGHT || i == STEREO) + i = -1; // Stereo + if (m_dvb_service) + m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i); + if (m_decoder) + m_decoder->setAudioChannel(i); return 0; } -int eDVBServicePlay::getFrontendInfo(int w) +std::string eDVBServicePlay::getRadioText(int x) +{ + if (m_radiotext_parser) + switch(x) + { + case 0: + return m_radiotext_parser->getCurrentText(); + } + return ""; +} + +void eDVBServicePlay::radioTextUpdated() +{ + m_event((iPlayableService*)this, evUpdatedRadioText); +} + +int eDVBServiceBase::getFrontendInfo(int w) { - if (m_is_pvr) - return 0; eUsePtr channel; if(m_service_handler.getChannel(channel)) return 0; @@ -1152,7 +1374,7 @@ int eDVBServicePlay::getFrontendInfo(int w) return fe->readFrontendData(w); } -PyObject *eDVBServicePlay::getFrontendData(bool original) +PyObject *eDVBServiceBase::getFrontendData(bool original) { PyObject *ret=0; @@ -1409,8 +1631,14 @@ void eDVBServicePlay::switchToLive() if (!m_timeshift_active) return; + m_cue = 0; m_decoder = 0; m_decode_demux = 0; + m_teletext_parser = 0; + m_radiotext_parser = 0; + m_new_subtitle_page_connection = 0; + m_radiotext_updated_connection = 0; + /* free the timeshift service handler, we need the resources */ m_service_handler_timeshift.free(); m_timeshift_active = 0; @@ -1427,7 +1655,11 @@ void eDVBServicePlay::switchToTimeshift() m_decode_demux = 0; m_decoder = 0; - + m_teletext_parser = 0; + m_radiotext_parser = 0; + m_new_subtitle_page_connection = 0; + m_radiotext_updated_connection = 0; + m_timeshift_active = 1; m_event((iPlayableService*)this, evSeekableStatusChanged); @@ -1435,14 +1667,23 @@ void eDVBServicePlay::switchToTimeshift() eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference; r.path = m_timeshift_file; + m_cue = new eCueSheet(); m_service_handler_timeshift.tune(r, 1, m_cue); /* use the decoder demux for everything */ + updateDecoder(); /* mainly to switch off PCR */ } void eDVBServicePlay::updateDecoder() { - int vpid = -1, apid = -1, apidtype = -1, pcrpid = -1, tpid = -1; + int vpid = -1, vpidtype = -1, apid = -1, apidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1; + eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler; + bool defaultac3=false; + std::string default_ac3; + + if (!ePythonConfigQuery::getConfigValue("config.av.defaultac3", default_ac3)) + defaultac3 = default_ac3 == "enable"; + eDVBServicePMTHandler::program program; if (h.getProgramInfo(program)) eDebug("getting program info failed."); @@ -1457,7 +1698,10 @@ void eDVBServicePlay::updateDecoder() i != program.videoStreams.end(); ++i) { if (vpid == -1) + { vpid = i->pid; + vpidtype = i->type; + } if (i != program.videoStreams.begin()) eDebugNoNewLine(", "); eDebugNoNewLine("%04x", i->pid); @@ -1472,10 +1716,13 @@ void eDVBServicePlay::updateDecoder() i(program.audioStreams.begin()); i != program.audioStreams.end(); ++i) { - if (apid == -1) + if (apid == -1 || (apidtype == eDVBAudio::aMPEG && defaultac3)) { - apid = i->pid; - apidtype = i->type; + if ( apid == -1 || (i->type != eDVBAudio::aMPEG) ) + { + apid = i->pid; + apidtype = i->type; + } } if (i != program.audioStreams.begin()) eDebugNoNewLine(", "); @@ -1493,22 +1740,91 @@ void eDVBServicePlay::updateDecoder() { h.getDecodeDemux(m_decode_demux); if (m_decode_demux) - m_decode_demux->getMPEGDecoder(m_decoder); + m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary); if (m_cue) m_cue->setDecodingDemux(m_decode_demux, m_decoder); +#ifdef INTERNAL_TELETEXT + m_teletext_parser = new eDVBTeletextParser(m_decode_demux); + m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection); +#endif } if (m_decoder) { - m_decoder->setVideoPID(vpid); - m_current_audio_stream = 0; + 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 + { + eServiceReferenceDVB ref; + m_service_handler.getServiceReference(ref); + eServiceReferenceDVB parent = ref.getParentServiceReference(); + if (!parent) + parent = ref; + if (parent) + { + ePtr res_mgr; + if (!eDVBResourceManager::getInstance(res_mgr)) + { + ePtr db; + if (!res_mgr->getChannelList(db)) + { + ePtr origService; + if (!db->getService(parent, origService)) + { + ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY); + pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY); + } + } + } + } + } + m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay); + m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay); + + m_decoder->setVideoPID(vpid, vpidtype); m_decoder->setAudioPID(apid, apidtype); - if (!(m_is_pvr || m_timeshift_active)) + if (!(m_is_pvr || m_timeshift_active || !m_is_primary)) + { m_decoder->setSyncPCR(pcrpid); + if (apid != -1) + { + ePtr data_demux; + if (!h.getDataDemux(data_demux)) + { + m_radiotext_parser = new eDVBRadioTextParser(data_demux); + m_radiotext_parser->connectUpdatedRadiotext(slot(*this, &eDVBServicePlay::radioTextUpdated), m_radiotext_updated_connection); + m_radiotext_parser->start(apid); + } + } + } else m_decoder->setSyncPCR(-1); + m_decoder->setTextPID(tpid); + + if (m_teletext_parser) + m_teletext_parser->start(tpid); + + if (!m_is_primary) + m_decoder->setTrickmode(1); + m_decoder->start(); + + if (vpid > 0 && vpid < 0x2000) + ; + else + { + std::string radio_pic; + if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic)) + m_decoder->setRadioPic(radio_pic); + } + + m_decoder->setAudioChannel(achannel); + // how we can do this better? // update cache pid when the user changed the audio track or video track // TODO handling of difference audio types.. default audio types.. @@ -1518,19 +1834,21 @@ void eDVBServicePlay::updateDecoder() { if (apidtype == eDVBAudio::aMPEG) { - m_dvb_service->setCachePID(eDVBService::cAPID, apid); - m_dvb_service->setCachePID(eDVBService::cAC3PID, -1); + m_dvb_service->setCacheEntry(eDVBService::cAPID, apid); + m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1); } else { - m_dvb_service->setCachePID(eDVBService::cAPID, -1); - m_dvb_service->setCachePID(eDVBService::cAC3PID, apid); + m_dvb_service->setCacheEntry(eDVBService::cAPID, -1); + m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid); } - m_dvb_service->setCachePID(eDVBService::cVPID, vpid); - m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid); - m_dvb_service->setCachePID(eDVBService::cTPID, tpid); + m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid); + m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype); + m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid); + m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid); } } + m_have_video_pid = (vpid > 0 && vpid < 0x2000); } void eDVBServicePlay::loadCuesheet() @@ -1559,7 +1877,7 @@ void eDVBServicePlay::loadCuesheet() #endif what = ntohl(what); - if (what > 2) + if (what > 3) break; m_cue_entries.insert(cueEntry(where, what)); @@ -1615,7 +1933,7 @@ void eDVBServicePlay::cutlistToCuesheet() if (!m_cutlist_enabled) { m_cue->commitSpans(); - eDebug("cutlists where disabled"); + eDebug("cutlists were disabled"); return; } @@ -1636,7 +1954,7 @@ void eDVBServicePlay::cutlistToCuesheet() continue; } else if (i->what == 1) /* out */ out = i++->where; - else /* mark */ + else /* mark (2) or last play position (3) */ { i++; continue; @@ -1654,6 +1972,141 @@ void eDVBServicePlay::cutlistToCuesheet() m_cue->commitSpans(); } +RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, PyObject *entry) +{ + if (m_subtitle_widget) + disableSubtitles(parent); + + if (!m_teletext_parser) + return -1; + + if (!PyInt_Check(entry)) + return -1; + + m_subtitle_widget = new eSubtitleWidget(parent); + m_subtitle_widget->resize(parent->size()); /* full size */ + + int page = PyInt_AsLong(entry); + + m_teletext_parser->setPage(page); + + return 0; +} + +RESULT eDVBServicePlay::disableSubtitles(eWidget *parent) +{ + delete m_subtitle_widget; + m_subtitle_widget = 0; + return 0; +} + +PyObject *eDVBServicePlay::getSubtitleList() +{ + if (!m_teletext_parser) + { + Py_INCREF(Py_None); + return Py_None; + } + + PyObject *l = PyList_New(0); + + for (std::set::iterator i(m_teletext_parser->m_found_subtitle_pages.begin()); i != m_teletext_parser->m_found_subtitle_pages.end(); ++i) + { + PyObject *tuple = PyTuple_New(2); + char desc[20]; + sprintf(desc, "Page %x", *i); + PyTuple_SetItem(tuple, 0, PyString_FromString(desc)); + PyTuple_SetItem(tuple, 1, PyInt_FromLong(*i)); + PyList_Append(l, tuple); + } + + return l; +} + +void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page) +{ + if (m_subtitle_widget) + { + m_subtitle_pages.push_back(page); + + checkSubtitleTiming(); + } +} + +void eDVBServicePlay::checkSubtitleTiming() +{ + while (1) + { + if (m_subtitle_pages.empty()) + return; + + eDVBTeletextSubtitlePage p = m_subtitle_pages.front(); + + pts_t pos = 0; + + if (m_decoder) + m_decoder->getPTS(0, pos); + + int diff = p.m_pts - pos; + if (diff < 0) + { + eDebug("[late (%d ms)]", -diff / 90); + diff = 0; + } + if (diff > 900000) + { + eDebug("[invalid]"); + diff = 0; + } + + if (!diff) + { + m_subtitle_widget->setPage(p); + m_subtitle_pages.pop_front(); + } else + { + m_subtitle_sync_timer.start(diff / 90, 1); + break; + } + } +} + +int eDVBServicePlay::getAC3Delay() +{ + if (m_dvb_service) + return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY); + else if (m_decoder) + return m_decoder->getAC3Delay(); + else + return 0; +} + +int eDVBServicePlay::getPCMDelay() +{ + if (m_dvb_service) + return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY); + else if (m_decoder) + return m_decoder->getPCMDelay(); + else + return 0; +} + +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); +} + +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); +} + DEFINE_REF(eDVBServicePlay) eAutoInitPtr init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");