#include <string>
#include <lib/service/servicedvb.h>
#include <lib/service/service.h>
+#include <lib/base/estring.h>
#include <lib/base/init_num.h>
#include <lib/base/init.h>
#include <lib/base/nconfig.h> // access to python config
#include <lib/gui/esubtitle.h>
#include <sys/vfs.h>
+#include <sys/stat.h>
#include <byteswap.h>
#include <netinet/in.h>
return m_parser.m_description;
case iServiceInformation::sServiceref:
return m_parser.m_ref.toString();
+ case iServiceInformation::sTags:
+ return m_parser.m_tags;
default:
return "";
}
eServiceCenter::getPrivInstance(sc);
if (sc)
sc->addServiceFactory(eServiceFactoryDVB::id, this);
+
+ m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
+ m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
}
eServiceFactoryDVB::~eServiceFactoryDVB()
// 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())
+// C = Service Reference (as python string object .. same as ref.toCompareString())
// 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
case 'R': // service reference (swig)object
tmp = New_eServiceReference(ref);
break;
+ case 'C': // service reference compare string
+ tmp = PyString_FromString(ref.toCompareString().c_str());
+ break;
case 'S': // service reference string
tmp = PyString_FromString(ref.toString().c_str());
break;
if ((ref.flags & eServiceReference::flagDirectory) == eServiceReference::flagDirectory) // bouquet
{
if ( !ref.name.empty() ) // satellites or providers list
- ptr = new eStaticServiceDVBInformation;
+ ptr = m_StaticServiceDVBInfo;
else // a dvb bouquet
- ptr = new eStaticServiceDVBBouquetInformation;
+ ptr = m_StaticServiceDVBBouquetInfo;
}
else if (!ref.path.empty()) /* do we have a PVR service? */
ptr = new eStaticServiceDVBPVRInformation(ref);
{
ePtr<eDVBService> 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;
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;
}
return 0;
}
+RESULT eDVBServicePlay::radioText(ePtr<iRadioText> &ptr)
+{
+ ptr = this;
+ return 0;
+}
+
RESULT eDVBServicePlay::getName(std::string &name)
{
if (m_is_pvr)
if (w == sCAIDs)
return resIsPyObject;
- if (m_service_handler.getProgramInfo(program))
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+
+ if (h.getProgramInfo(program))
return -1;
switch (w)
case sIsCrypted: return program.isCrypted();
case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].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[m_current_audio_stream].pid;
+ 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;
int eDVBServicePlay::getNumberOfTracks()
{
eDVBServicePMTHandler::program program;
- if (m_service_handler.getProgramInfo(program))
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+ if (h.getProgramInfo(program))
return 0;
return program.audioStreams.size();
}
RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
{
eDVBServicePMTHandler::program program;
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
- if (m_service_handler.getProgramInfo(program))
+ if (h.getProgramInfo(program))
return -1;
if (i >= program.audioStreams.size())
int eDVBServicePlay::selectAudioStream(int i)
{
eDVBServicePMTHandler::program program;
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
- if (m_service_handler.getProgramInfo(program))
+ if (h.getProgramInfo(program))
return -1;
if ((unsigned int)i >= program.audioStreams.size())
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->setCacheEntry(eDVBService::cAPID, program.audioStreams[i].pid);
m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
- } else
+ }
+ else
{
m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
m_dvb_service->setCacheEntry(eDVBService::cAC3PID, program.audioStreams[i].pid);
}
}
- m_current_audio_stream = i;
+ h.resetCachedProgram();
return 0;
}
return 0;
}
+std::string eDVBServicePlay::getRadioText(int x)
+{
+ if (m_radiotext_parser)
+ switch(x)
+ {
+ case 0:
+ return convertLatin1UTF8(m_radiotext_parser->getCurrentText());
+ }
+ return "";
+}
+
+void eDVBServicePlay::radioTextUpdated()
+{
+ m_event((iPlayableService*)this, evUpdatedRadioText);
+}
+
int eDVBServiceBase::getFrontendInfo(int w)
{
eUsePtr<iDVBChannel> channel;
return;
eDVBServicePMTHandler::program program;
- if (m_service_handler.getProgramInfo(program))
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+
+ if (h.getProgramInfo(program))
return;
else
{
m_decoder = 0;
m_decode_demux = 0;
m_teletext_parser = 0;
+ m_radiotext_parser = 0;
+ m_subtitle_parser = 0;
+ m_new_dvb_subtitle_page_connection = 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;
-
+
m_event((iPlayableService*)this, evSeekableStatusChanged);
-
+
updateDecoder();
}
{
if (m_timeshift_active)
return;
-
+
m_decode_demux = 0;
m_decoder = 0;
m_teletext_parser = 0;
+ m_radiotext_parser = 0;
+ m_subtitle_parser = 0;
m_new_subtitle_page_connection = 0;
-
+ m_new_dvb_subtitle_page_connection = 0;
+ m_radiotext_updated_connection = 0;
+
m_timeshift_active = 1;
m_event((iPlayableService*)this, evSeekableStatusChanged);
-
+
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 */
std::string default_ac3;
if (!ePythonConfigQuery::getConfigValue("config.av.defaultac3", default_ac3))
- defaultac3 = default_ac3 == "enable";
+ defaultac3 = default_ac3 == "True";
eDVBServicePMTHandler::program program;
if (h.getProgramInfo(program))
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
- i(program.videoStreams.begin());
+ i(program.videoStreams.begin());
i != program.videoStreams.end(); ++i)
{
if (vpid == -1)
{
eDebugNoNewLine(" (");
for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
- i(program.audioStreams.begin());
+ i(program.audioStreams.begin());
i != program.audioStreams.end(); ++i)
{
if (apid == -1 || (apidtype == eDVBAudio::aMPEG && defaultac3))
m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
#endif
+ m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
+ m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
}
if (m_decoder)
m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
m_decoder->setVideoPID(vpid, vpidtype);
- m_current_audio_stream = 0;
m_decoder->setAudioPID(apid, apidtype);
if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
+ {
m_decoder->setSyncPCR(pcrpid);
+ if (apid != -1)
+ {
+ ePtr<iDVBDemux> 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);
+ m_teletext_parser->start(program.textPid);
if (!m_is_primary)
m_decoder->setTrickmode(1);
if (m_subtitle_widget)
disableSubtitles(parent);
- if (!m_teletext_parser)
- return -1;
-
if (!PyInt_Check(entry))
return -1;
-
+
+ int page = PyInt_AsLong(entry);
+
+ if (page > 0 && !m_teletext_parser)
+ return -1;
+ if (page < 0 && !m_subtitle_parser)
+ 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);
+
+ if (page > 0)
+ {
+/* eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+ eDVBServicePMTHandler::program program;
+ if (h.getProgramInfo(program))
+ eDebug("getting program info failed.");
+ else
+ {
+ eDebug("start teletext on pid %04x, page %d", program.textPid, page);
+ m_teletext_parser->start(program.textPid);*/
+ m_teletext_parser->setPage(page);
+// }
+ }
+ else
+ {
+ int pid = -page;
+ m_subtitle_parser->start(pid);
+ }
return 0;
}
{
delete m_subtitle_widget;
m_subtitle_widget = 0;
+ if (m_subtitle_parser)
+ {
+ m_subtitle_parser->stop();
+ m_dvb_subtitle_pages.clear();
+ }
+ if (m_teletext_parser)
+ {
+ m_teletext_parser->setPage(-1);
+ m_subtitle_pages.clear();
+ }
return 0;
}
{
PyObject *tuple = PyTuple_New(2);
char desc[20];
- sprintf(desc, "Page %x", *i);
+ sprintf(desc, "Page %d", *i);
PyTuple_SetItem(tuple, 0, PyString_FromString(desc));
PyTuple_SetItem(tuple, 1, PyInt_FromLong(*i));
PyList_Append(l, tuple);
+ Py_DECREF(tuple);
}
-
+
+ eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
+ eDVBServicePMTHandler::program program;
+ if (h.getProgramInfo(program))
+ eDebug("getting program info failed.");
+ else
+ {
+ for (std::vector<eDVBServicePMTHandler::subtitleStream>::iterator it(program.subtitleStreams.begin());
+ it != program.subtitleStreams.end(); ++it)
+ {
+ PyObject *tuple = PyTuple_New(2);
+ char desc[20];
+ sprintf(desc, "DVB %s", it->language_code.c_str());
+ PyTuple_SetItem(tuple, 0, PyString_FromString(desc));
+ PyTuple_SetItem(tuple, 1, PyInt_FromLong(-it->pid));
+ PyList_Append(l, tuple);
+ Py_DECREF(tuple);
+ }
+ }
+
return l;
}
if (m_subtitle_widget)
{
m_subtitle_pages.push_back(page);
-
checkSubtitleTiming();
}
}
void eDVBServicePlay::checkSubtitleTiming()
{
+// eDebug("checkSubtitleTiming");
+ if (!m_subtitle_widget)
+ return;
while (1)
{
- if (m_subtitle_pages.empty())
+ enum { TELETEXT, DVB } type;
+ eDVBTeletextSubtitlePage page;
+ eDVBSubtitlePage dvb_page;
+ pts_t show_time;
+ if (!m_subtitle_pages.empty())
+ {
+ page = m_subtitle_pages.front();
+ type = TELETEXT;
+ show_time = page.m_pts;
+ }
+ else if (!m_dvb_subtitle_pages.empty())
+ {
+ dvb_page = m_dvb_subtitle_pages.front();
+ type = DVB;
+ show_time = dvb_page.m_show_time;
+ }
+ else
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;
+
+// eDebug("%lld %lld", pos, show_time);
+ int diff = show_time - pos;
if (diff < 0)
{
eDebug("[late (%d ms)]", -diff / 90);
if (!diff)
{
- m_subtitle_widget->setPage(p);
- m_subtitle_pages.pop_front();
+ if (type == TELETEXT)
+ {
+ eDebug("display teletext subtitle page");
+ m_subtitle_widget->setPage(page);
+ m_subtitle_pages.pop_front();
+ }
+ else
+ {
+ eDebug("display dvb subtitle Page");
+ m_subtitle_widget->setPage(dvb_page);
+ m_dvb_subtitle_pages.pop_front();
+ }
} else
{
+ eDebug("start subtitle delay %d", diff / 90);
m_subtitle_sync_timer.start(diff / 90, 1);
break;
}
}
}
+void eDVBServicePlay::newDVBSubtitlePage(const eDVBSubtitlePage &p)
+{
+ if (m_subtitle_widget)
+ {
+ m_dvb_subtitle_pages.push_back(p);
+ checkSubtitleTiming();
+ }
+}
+
int eDVBServicePlay::getAC3Delay()
{
if (m_dvb_service)