+/*******************************************************************************
+ VLC Player Plugin by A. Lätsch 2007
+ This is free software; you can redistribute it and/or modify it under
+ the terms of the GNU General Public License as published by the Free
+ Software Foundation; either version 2, or (at your option) any later
+ version.
+********************************************************************************/
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netdb.h>
#include <signal.h>
+#include <time.h>
#include "servicets.h"
#include <lib/base/eerror.h>
#include <lib/base/object.h>
#include <lib/base/init.h>
#include <lib/dvb/decoder.h>
+#include <lib/dvb/pmt.h>
+
#define MAX(a,b) ((a) > (b) ? (a) : (b))
-// eServiceFactoryTS
+/********************************************************************/
+/* eServiceFactoryTS */
+/********************************************************************/
eServiceFactoryTS::eServiceFactoryTS()
{
ePtr<eServiceCenter> sc;
-
+
eServiceCenter::getPrivInstance(sc);
if (sc)
{
std::list<std::string> extensions;
sc->addServiceFactory(eServiceFactoryTS::id, this, extensions);
}
-
- m_service_info = new eStaticServiceTSInfo();
}
eServiceFactoryTS::~eServiceFactoryTS()
{
ePtr<eServiceCenter> sc;
-
+
eServiceCenter::getPrivInstance(sc);
if (sc)
sc->removeServiceFactory(eServiceFactoryTS::id);
DEFINE_REF(eServiceFactoryTS)
- // iServiceHandler
+// iServiceHandler
RESULT eServiceFactoryTS::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
{
- // check resources...
ptr = new eServiceTS(ref);
return 0;
}
RESULT eServiceFactoryTS::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
{
- ptr = m_service_info;
- return 0;
+ ptr = 0;
+ return -1;
}
RESULT eServiceFactoryTS::offlineOperations(const eServiceReference &, ePtr<iServiceOfflineOperations> &ptr)
}
-// eStaticServiceTSInfo
-DEFINE_REF(eStaticServiceTSInfo)
+/********************************************************************/
+/* TSAudioInfo */
+/********************************************************************/
+DEFINE_REF(TSAudioInfo);
-eStaticServiceTSInfo::eStaticServiceTSInfo()
-{
+void TSAudioInfo::addAudio(int pid, std::string lang, std::string desc, int type) {
+ StreamInfo as;
+ as.description = desc;
+ as.language = lang;
+ as.pid = pid;
+ as.type = type;
+ audioStreams.push_back(as);
}
-RESULT eStaticServiceTSInfo::getName(const eServiceReference &ref, std::string &name)
-{
- size_t last = ref.path.rfind('/');
- if (last != std::string::npos)
- name = ref.path.substr(last+1);
- else
- name = ref.path;
- return 0;
-}
-
-int eStaticServiceTSInfo::getLength(const eServiceReference &ref)
-{
- return -1;
-}
-// eServiceTS
+/********************************************************************/
+/* eServiceTS */
+/********************************************************************/
eServiceTS::eServiceTS(const eServiceReference &url): m_pump(eApp, 1)
{
m_vpid = url.getData(0) == 0 ? 0x44 : url.getData(0);
m_apid = url.getData(1) == 0 ? 0x45 : url.getData(1);
m_state = stIdle;
+ m_audioInfo = 0;
+ m_destfd = -1;
}
eServiceTS::~eServiceTS()
{
eDebug("ServiceTS destruct!");
- if (m_state == stRunning)
- stop();
+ stop();
}
-DEFINE_REF(eServiceTS);
+DEFINE_REF(eServiceTS);
size_t crop(char *buf)
{
return len;
}
-static int getline(char** pbuffer, size_t* pbufsize, int fd)
+static int getline(char** pbuffer, size_t* pbufsize, int fd)
{
size_t i = 0;
int rc;
{
ePtr<eDVBResourceManager> rmgr;
eDVBResourceManager::getInstance(rmgr);
- if (rmgr->allocateDemux(NULL, m_decodedemux, iDVBChannel::capDecode) != 0) {
+ eDVBChannel dvbChannel(rmgr, 0);
+ if (m_destfd == -1)
+ {
+ m_destfd = ::open("/dev/misc/pvr", O_WRONLY);
+ if (m_destfd < 0)
+ {
+ eDebug("Cannot open /dev/misc/pvr");
+ return -1;
+ }
+ }
+ if (dvbChannel.getDemux(m_decodedemux, iDVBChannel::capDecode) != 0) {
eDebug("Cannot allocate decode-demux");
- return 1;
+ return -1;
}
- if (m_decodedemux->get().getMPEGDecoder(m_decoder, 1) != 0) {
+ if (m_decodedemux->getMPEGDecoder(m_decoder, 1) != 0) {
eDebug("Cannot allocate MPEGDecoder");
- return 1;
+ return -1;
}
- m_decodedemux->get().setSourcePVR(0);
m_decoder->setVideoPID(m_vpid, eDVBVideo::MPEG2);
m_decoder->setAudioPID(m_apid, eDVBAudio::aMPEG);
m_streamthread = new eStreamThread();
CONNECT(m_streamthread->m_event, eServiceTS::recv_event);
- m_decoder->freeze(0);
- m_decoder->preroll();
+ m_decoder->pause();
if (unpause() != 0) return -1;
m_state = stRunning;
m_event(this, evStart);
RESULT eServiceTS::stop()
{
+ if (m_destfd >= 0)
+ {
+ ::close(m_destfd);
+ m_destfd = -1;
+ }
if (m_state != stRunning)
return -1;
printf("TS: %s stop\n", m_filename.c_str());
m_streamthread->stop();
- m_decodedemux->get().flush();
+ m_decodedemux->flush();
m_state = stStopped;
+ m_audioInfo = 0;
return 0;
}
eDebug("eServiceTS::recv_event: %d", evt);
switch (evt) {
case eStreamThread::evtEOS:
- m_decodedemux->get().flush();
+ m_decodedemux->flush();
m_state = stStopped;
m_event((iPlayableService*)this, evEOF);
break;
case eStreamThread::evtReadError:
case eStreamThread::evtWriteError:
- m_decoder->freeze(0);
+ m_decoder->pause();
m_state = stStopped;
m_event((iPlayableService*)this, evEOF);
+ break;
+ case eStreamThread::evtSOS:
+ m_event((iPlayableService*)this, evSOF);
+ break;
+ case eStreamThread::evtStreamInfo:
+ bool wasnull = !m_audioInfo;
+ m_streamthread->getAudioInfo(m_audioInfo);
+ if (m_audioInfo)
+ eDebug("[servicets] %d audiostreams found", m_audioInfo->audioStreams.size());
+ if (m_audioInfo && wasnull) {
+ int sel = getCurrentTrack();
+ if (sel < 0)
+ selectTrack(0);
+ else if (m_audioInfo->audioStreams[sel].type != eDVBAudio::aMPEG)
+ selectTrack(sel);
+ }
+ break;
}
}
-RESULT eServiceTS::setTarget(int target)
-{
- return -1;
-}
-
RESULT eServiceTS::pause(ePtr<iPauseableService> &ptr)
{
- ptr=this;
+ ptr = this;
return 0;
}
-RESULT eServiceTS::setSlowMotion(int ratio)
-{
- return -1;
-}
-
-RESULT eServiceTS::setFastForward(int ratio)
-{
- return -1;
-}
-
- // iPausableService
+// iPausableService
RESULT eServiceTS::pause()
{
m_streamthread->stop();
- m_decoder->freeze(0);
+ m_decoder->pause();
return 0;
}
eDebug("Cannot open source stream: %s", m_filename.c_str());
return 1;
}
-
- int destfd = ::open("/dev/misc/pvr", O_WRONLY);
- if (destfd < 0) {
- eDebug("Cannot open source stream: %s", m_filename.c_str());
- ::close(srcfd);
- return 1;
- }
- m_decodedemux->get().flush();
- m_streamthread->start(srcfd, destfd);
- // let the video buffer fill up a bit
- usleep(200*1000);
- m_decoder->unfreeze();
+ m_decodedemux->flush();
+ m_streamthread->start(srcfd, m_destfd);
+ m_decoder->play();
return 0;
}
- /* iSeekableService */
+// iSeekableService
RESULT eServiceTS::seek(ePtr<iSeekableService> &ptr)
{
ptr = this;
return -1;
}
-
RESULT eServiceTS::isCurrentlySeekable()
{
return 1;
return "";
}
+int eServiceTS::getNumberOfTracks() {
+ if (m_audioInfo)
+ return (int)m_audioInfo->audioStreams.size();
+ else
+ return 0;
+}
+
+RESULT eServiceTS::selectTrack(unsigned int i) {
+ if (m_audioInfo) {
+ m_apid = m_audioInfo->audioStreams[i].pid;
+ eDebug("[servicets] audio track %d PID 0x%02x type %d\n", i, m_apid, m_audioInfo->audioStreams[i].type);
+ m_decoder->setAudioPID(m_apid, m_audioInfo->audioStreams[i].type);
+ if (m_state == stRunning)
+ m_decoder->set();
+ return 0;
+ } else {
+ return -1;
+ }
+}
+
+RESULT eServiceTS::getTrackInfo(struct iAudioTrackInfo &info, unsigned int n) {
+ if (m_audioInfo) {
+ info.m_pid = m_audioInfo->audioStreams[n].pid;
+ info.m_description = m_audioInfo->audioStreams[n].description;
+ info.m_language = m_audioInfo->audioStreams[n].language;
+ return 0;
+ } else {
+ return -1;
+ }
+}
+
+int eServiceTS::getCurrentTrack() {
+ if (m_audioInfo) {
+ for (size_t i = 0; i < m_audioInfo->audioStreams.size(); i++) {
+ if (m_apid == m_audioInfo->audioStreams[i].pid) {
+ return i;
+ }
+ }
+ }
+ return -1;
+}
+
+/********************************************************************/
+/* eStreamThread */
+/********************************************************************/
+
DEFINE_REF(eStreamThread)
eStreamThread::eStreamThread(): m_messagepump(eApp, 0) {
m_srcfd = srcfd;
m_destfd = destfd;
m_stop = false;
+ m_audioInfo = 0;
run(IOPRIO_CLASS_RT);
}
+
void eStreamThread::stop() {
m_stop = true;
kill();
m_event(evt);
}
+RESULT eStreamThread::getAudioInfo(ePtr<TSAudioInfo> &ptr)
+{
+ ptr = m_audioInfo;
+ return 0;
+}
+
+#define REGISTRATION_DESCRIPTOR 5
+#define LANGUAGE_DESCRIPTOR 10
+
+std::string eStreamThread::getDescriptor(unsigned char buf[], int buflen, int type)
+{
+ int desc_len;
+ while (buflen > 1) {
+ desc_len = buf[1];
+ if (buf[0] == type) {
+ char str[21];
+ if (desc_len > 20) desc_len = 20;
+ strncpy(str, (char*)buf+2, desc_len);
+ str[desc_len] = '\0';
+ return std::string(str);
+ } else {
+ buflen -= desc_len+2;
+ buf += desc_len+2;
+ }
+ }
+ return "";
+}
+
+bool eStreamThread::scanAudioInfo(unsigned char buf[], int len)
+{
+ if (len < 1880)
+ return false;
+
+ int adaptfield, pmtpid, offset;
+ unsigned char pmt[1188];
+ int pmtsize = 0;
+
+ for (int a=0; a < len - 188*4; a++) {
+ if ( buf[a] != 0x47 || buf[a + 188] != 0x47 || buf[a + 376] != 0x47 )
+ continue; // TS Header
+
+ if ((0x40 & buf[a + 1]) == 0) // start
+ continue;
+
+ if ((0xC0 & buf[a + 3]) != 0) // scrambling
+ continue;
+
+ adaptfield = (0x30 & buf[a + 3]) >> 4;
+
+ if ((adaptfield & 1) == 0) // adapt - no payload
+ continue;
+
+ offset = adaptfield == 3 ? 1 + (0xFF & buf[a + 4]) : 0; //adaptlength
+
+ if (buf[a + offset + 4] != 0 || buf[a + offset + 5] != 2 || (0xF0 & buf[a + offset + 6]) != 0xB0)
+ {
+ a += 187;
+ continue;
+ }
+
+ pmtpid = (0x1F & buf[a + 1])<<8 | (0xFF & buf[a + 2]);
+ memcpy(pmt + pmtsize, buf + a + 4 + offset, 184 - offset);
+ pmtsize += 184 - offset;
+
+ if (pmtsize >= 1000)
+ break;
+ }
+
+ if (pmtsize == 0) return false;
+
+ int pmtlen = (0x0F & pmt[2]) << 8 | (0xFF & pmt[3]);
+ std::string lang;
+ std::string pd_type;
+ ePtr<TSAudioInfo> ainfo = new TSAudioInfo();
+
+ for (int b=8; b < pmtlen-4 && b < pmtsize-6; b++)
+ {
+ if ( (0xe0 & pmt[b+1]) != 0xe0 )
+ continue;
+
+ int pid = (0x1F & pmt[b+1])<<8 | (0xFF & pmt[b+2]);
+
+ switch(pmt[b])
+ {
+ case 1:
+ case 2: // MPEG Video
+ //addVideo(pid, "MPEG2");
+ break;
+
+ case 0x1B: // H.264 Video
+ //addVideo(pid, "H.264");
+ break;
+
+ case 3:
+ case 4: // MPEG Audio
+ lang = getDescriptor(pmt+b+5, pmt[b+4], LANGUAGE_DESCRIPTOR);
+ ainfo->addAudio(pid, lang, "MPEG", eDVBAudio::aMPEG);
+ break;
+
+ case 0x80:
+ case 0x81: //private data of AC3 in ATSC
+ case 0x82:
+ case 0x83:
+ case 6:
+ lang = getDescriptor(pmt+b+5, pmt[b+4], LANGUAGE_DESCRIPTOR);
+ pd_type = getDescriptor(pmt+b+5, pmt[b+4], REGISTRATION_DESCRIPTOR);
+ if (pd_type == "AC-3")
+ ainfo->addAudio(pid, lang, pd_type, eDVBAudio::aAC3);
+ break;
+ }
+ b += 4 + pmt[b+4];
+ }
+ if (ainfo->audioStreams.size() > 0) {
+ m_audioInfo = ainfo;
+ return true;
+ } else {
+ return false;
+ }
+}
+
void eStreamThread::thread() {
- const int bufsize = 60000;
+ const int bufsize = 40000;
unsigned char buf[bufsize];
bool eof = false;
fd_set rfds;
fd_set wfds;
struct timeval timeout;
int rc,r,w,maxfd;
-
+ time_t next_scantime = 0;
+ bool sosSend = false;
+
r = w = 0;
hasStarted();
eDebug("eStreamThread started");
} else if (rc == 0) {
eof = true;
} else {
+ if (!sosSend) {
+ sosSend = true;
+ m_messagepump.send(evtSOS);
+ }
r += rc;
if (r == bufsize) eDebug("eStreamThread::thread: buffer full");
}
}
- if (FD_ISSET(m_destfd, &wfds) && (w < r)) {
+ if (FD_ISSET(m_destfd, &wfds) && (w < r) && ((r > bufsize/4) || eof)) {
rc = ::write(m_destfd, buf+w, r-w);
if (rc < 0) {
eDebug("eStreamThread::thread: error in write (%d)", errno);
}
w += rc;
//eDebug("eStreamThread::thread: buffer r=%d w=%d",r,w);
- if (w == r) w = r = 0;
+ if (w == r) {
+ if (time(0) >= next_scantime) {
+ if (scanAudioInfo(buf, r)) {
+ m_messagepump.send(evtStreamInfo);
+ next_scantime = time(0) + 1;
+ }
+ }
+ w = r = 0;
+ }
}
if (eof && (r==w)) {
- ::close(m_destfd);
- m_destfd = -1;
::close(m_srcfd);
m_srcfd = -1;
m_messagepump.send(evtEOS);
void eStreamThread::thread_finished() {
if (m_srcfd >= 0) ::close(m_srcfd);
- if (m_destfd >= 0) ::close(m_destfd);
eDebug("eStreamThread closed");
}
projects / vuplus_dvbapp-plugin / blobdiff