diff --git a/libspark/dmx.cpp b/libspark/dmx.cpp index 3cb08c8..a3d2dfc 100644 --- a/libspark/dmx.cpp +++ b/libspark/dmx.cpp @@ -1,3 +1,52 @@ +/* + * cDemux implementation for SH4 receivers (tested on fulan spark and + * fulan spark7162 hardware + * + * derived from libtriple/dmx_td.cpp + * + * (C) 2010-2012 Stefan Seyfried + * + * This program 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 of the License, or + * (at your option) any later version. + */ + +/* + * Theory of operation (or "why is this dmx_source thing so strange and + * what is the _open() good for?") + * + * the sh4 pti driver, driving the /dev/dvb/adapter0/dmxN devices, can + * apparently only map one input to on demux device at a time, so e.g. + * DMX_SOURCE_FRONT1 -> demux0 + * DMX_SOURCE_FRONT2 -> demux0 + * DMX_SOURCE_FRONT1 -> demux1 + * does not work. The driver makes sure that a one-to-one mapping of + * DMX_SOURCE_FRONTn to demuxM is maintained, and it does by e.g changing + * the default of + * FRONT0 -> demux0 + * FRONT1 -> demux1 + * FRONT2 -> demux2 + * to + * FRONT1 -> demux0 + * FRONT0 -> demux1 + * FRONT2 -> demux2 + * if you do a DMX_SET_SOURCE(FRONT1) ioctl on demux0. + * This means, it also changes demux1's source on the SET_SOURCE ioctl on + * demux0, potentially disturbing any operation on demux1 (e.g. recording). + * + * In order to avoid this, I do not change the source->demuxdev mapping + * but instead just always use the demux device that is attached to the + * correct source. + * + * The tricky part is, that the source might actually be changed after + * Open() has been called, so Open() gets a dummy placeholder that just + * sets some variables while the real device open is put into _open(). + * _open() gets called later, whenever the device is actually used or + * configured and -- if the source has changed -- closes the old and + * opens the correct new device node. + */ + #include #include #include @@ -49,12 +98,21 @@ static const char *DMX_T[] = { "DMX_PCR" }; -/* map the device numbers. for now only demux0 is used */ -static const char *devname[] = { +/* this is the number of different cDemux() units, not the number of + * /dev/dvb/.../demuxX devices! */ +#define NUM_DEMUX 4 +/* the current source of each cDemux unit */ +static int dmx_source[NUM_DEMUX] = { 0, 0, 0, 0 }; + +/* map the device numbers. */ +#define NUM_DEMUXDEV 3 +static const char *devname[NUM_DEMUXDEV] = { "/dev/dvb/adapter0/demux0", - "/dev/dvb/adapter0/demux0", - "/dev/dvb/adapter0/demux0" + "/dev/dvb/adapter0/demux1", + "/dev/dvb/adapter0/demux2" }; +/* did we already DMX_SET_SOURCE on that demux device? */ +static bool init[NUM_DEMUXDEV] = { false, false, false }; /* uuuugly */ static int dmx_tp_count = 0; @@ -62,7 +120,7 @@ static int dmx_tp_count = 0; cDemux::cDemux(int n) { - if (n < 0 || n > 2) + if (n < 0 || n >= NUM_DEMUX) { lt_info("%s ERROR: n invalid (%d)\n", __FUNCTION__, n); num = 0; @@ -73,6 +131,7 @@ cDemux::cDemux(int n) measure = false; last_measure = 0; last_data = 0; + last_source = -1; } cDemux::~cDemux() @@ -95,73 +154,66 @@ cDemux::~cDemux() bool cDemux::Open(DMX_CHANNEL_TYPE pes_type, void * /*hVideoBuffer*/, int uBufferSize) { - int devnum = num; - int flags = O_RDWR; if (fd > -1) lt_info("%s FD ALREADY OPENED? fd = %d\n", __FUNCTION__, fd); - if (pes_type != DMX_PSI_CHANNEL) - flags |= O_NONBLOCK; -#if 0 - if (pes_type == DMX_TP_CHANNEL) - { - if (num == 0) /* streaminfo measurement, let's cheat... */ - { - lt_info("%s num=0 and DMX_TP_CHANNEL => measurement demux\n", __func__); - devnum = 2; /* demux 0 is used for live, demux 1 for recording */ - measure = true; - last_measure = 0; - last_data = 0; - flags |= O_NONBLOCK; - } - else - { - /* it looks like the drivers can only do one TS at a time */ - if (dmx_tp_count >= MAX_TS_COUNT) - { - lt_info("%s too many DMX_TP_CHANNEL requests :-(\n", __FUNCTION__); - dmx_type = DMX_INVALID; - fd = -1; - return false; - } - dmx_tp_count++; - devnum = dmx_tp_count; - } + dmx_type = pes_type; + buffersize = uBufferSize; + + /* return code is unchecked anyway... */ + return true; +} + +bool cDemux::_open(void) +{ + int flags = O_RDWR|O_CLOEXEC; + int devnum = dmx_source[num]; + if (last_source == devnum) { + lt_info("%s #%d: source (%d) did not change\n", __func__, num, last_source); + if (fd > -1) + return true; } -#endif + if (fd > -1) { + lt_info("%s #%d: FD ALREADY OPENED fd = %d lastsource %d devnum %d\n", __func__, num, fd, last_source, devnum); + close(fd); + } + + if (dmx_type != DMX_PSI_CHANNEL) + flags |= O_NONBLOCK; + fd = open(devname[devnum], flags); if (fd < 0) { lt_info("%s %s: %m\n", __FUNCTION__, devname[devnum]); return false; } - fcntl(fd, F_SETFD, FD_CLOEXEC); lt_debug("%s #%d pes_type: %s(%d), uBufferSize: %d fd: %d\n", __func__, - num, DMX_T[pes_type], pes_type, uBufferSize, fd); + num, DMX_T[dmx_type], dmx_type, buffersize, fd); - dmx_type = pes_type; -#if 0 - if (!pesfds.empty()) + /* this would actually need locking, but the worst that weill happen is, that + * we'll DMX_SET_SOURCE twice per device, so don't bother... */ + if (!init[devnum]) { - lt_info("%s ERROR! pesfds not empty!\n", __FUNCTION__); /* TODO: error handling */ - return false; + /* this should not change anything... */ + int n = DMX_SOURCE_FRONT0 + devnum; + lt_info("%s: setting %s to source %d\n", __func__, devname[devnum], n); + if (ioctl(fd, DMX_SET_SOURCE, &n) < 0) + lt_info("%s DMX_SET_SOURCE failed!\n", __func__); + else + init[devnum] = true; } -#endif - int n = DMX_SOURCE_FRONT0; - if (ioctl(fd, DMX_SET_SOURCE, &n) < 0) - lt_info("%s DMX_SET_SOURCE failed!\n", __func__); #ifdef MARTII - if (uBufferSize == 0) - uBufferSize = 0xffff; // may or may not be reasonable --martii + if (buffersize == 0) + buffersize = 0xffff; // may or may not be reasonable --martii #endif - if (uBufferSize > 0) + if (buffersize > 0) { /* probably uBufferSize == 0 means "use default size". TODO: find a reasonable default */ - if (ioctl(fd, DMX_SET_BUFFER_SIZE, uBufferSize) < 0) + if (ioctl(fd, DMX_SET_BUFFER_SIZE, buffersize) < 0) lt_info("%s DMX_SET_BUFFER_SIZE failed (%m)\n", __func__); } - buffersize = uBufferSize; + last_source = devnum; return true; } @@ -243,18 +295,37 @@ int cDemux::Read(unsigned char *buff, int len, int timeout) fprintf(stderr, "cDemux::%s #%d fd: %d type: %s len: %d timeout: %d\n", __FUNCTION__, num, fd, DMX_T[dmx_type], len, timeout); #endif + if (fd < 0) + { + lt_info("%s #%d: not open!\n", __func__, num); + return -1; + } int rc; + int to = timeout; struct pollfd ufds; ufds.fd = fd; ufds.events = POLLIN|POLLPRI|POLLERR; ufds.revents = 0; - if (timeout > 0) + /* hack: if the frontend loses and regains lock, the demuxer often will not + * return from read(), so as a "emergency exit" for e.g. NIT scan, set a (long) + * timeout here */ + if (dmx_type == DMX_PSI_CHANNEL && timeout <= 0) + to = 60 * 1000; + + if (to > 0) { retry: - rc = ::poll(&ufds, 1, timeout); + rc = ::poll(&ufds, 1, to); if (!rc) + { + if (timeout == 0) /* we took the emergency exit */ + { + dmx_err("timed out for timeout=0!, %s", "", 0); + return -1; /* this timeout is an error */ + } return 0; // timeout + } else if (rc < 0) { dmx_err("poll: %s,", strerror(errno), 0) @@ -299,6 +370,8 @@ bool cDemux::sectionFilter(unsigned short pid, const unsigned char * const filte int length = len; memset(&s_flt, 0, sizeof(s_flt)); + _open(); + if (len > DMX_FILTER_SIZE) { lt_info("%s #%d: len too long: %d, DMX_FILTER_SIZE %d\n", __func__, num, len, DMX_FILTER_SIZE); @@ -356,6 +429,7 @@ bool cDemux::sectionFilter(unsigned short pid, const unsigned char * const filte /* 0x60 - 0x6F: event_information_section - other_transport_stream, schedule */ case 0x70: /* time_date_section */ s_flt.flags &= ~DMX_CHECK_CRC; /* section has no CRC */ + s_flt.flags |= DMX_ONESHOT; //s_flt.pid = 0x0014; to = 30000; break; @@ -368,6 +442,7 @@ bool cDemux::sectionFilter(unsigned short pid, const unsigned char * const filte to = 0; break; case 0x73: /* time_offset_section */ + s_flt.flags |= DMX_ONESHOT; //s_flt.pid = 0x0014; to = 30000; break; @@ -419,6 +494,8 @@ bool cDemux::pesFilter(const unsigned short pid) lt_debug("%s #%d pid: 0x%04hx fd: %d type: %s\n", __FUNCTION__, num, pid, fd, DMX_T[dmx_type]); + _open(); + memset(&p_flt, 0, sizeof(p_flt)); p_flt.pid = pid; p_flt.output = DMX_OUT_DECODER; @@ -478,6 +555,7 @@ bool cDemux::addPid(unsigned short Pid) lt_info("%s pes_type %s not implemented yet! pid=%hx\n", __FUNCTION__, DMX_T[dmx_type], Pid); return false; } + _open(); if (fd == -1) lt_info("%s bucketfd not yet opened? pid=%hx\n", __FUNCTION__, Pid); #if 0 @@ -563,6 +641,14 @@ int cDemux::getUnit(void) bool cDemux::SetSource(int unit, int source) { - lt_info_c("%s(%d, %d): not implemented yet\n", __func__, unit, source); + if (unit >= NUM_DEMUX || unit < 0) { + lt_info_c("%s: unit (%d) out of range, NUM_DEMUX %d\n", __func__, unit, NUM_DEMUX); + return false; + } + lt_info_c("%s(%d, %d) => %d to %d\n", __func__, unit, source, dmx_source[unit], source); + if (source < 0 || source >= NUM_DEMUXDEV) + lt_info_c("%s(%d, %d) ERROR: source %d out of range!\n", __func__, unit, source, source); + else + dmx_source[unit] = source; return true; } diff --git a/libspark/dmx_lib.h b/libspark/dmx_lib.h index ffd293e..99ac526 100644 --- a/libspark/dmx_lib.h +++ b/libspark/dmx_lib.h @@ -38,9 +38,11 @@ class cDemux std::vector pesfds; struct dmx_sct_filter_params s_flt; struct dmx_pes_filter_params p_flt; + int last_source; + bool _open(void); public: - bool Open(DMX_CHANNEL_TYPE pes_type, void * x = NULL, int y = 0); + bool Open(DMX_CHANNEL_TYPE pes_type, void * unused = NULL, int bufsize = 0); void Close(void); bool Start(bool record = false); bool Stop(void); diff --git a/libspark/record.cpp b/libspark/record.cpp index 30d7180..2d269eb 100644 --- a/libspark/record.cpp +++ b/libspark/record.cpp @@ -26,16 +26,17 @@ void *execute_record_thread(void *c) } #ifdef MARTII -cRecord::cRecord(int /*num*/, int bs_dmx, int bs) +cRecord::cRecord(int num, int bs_dmx, int bs) #else -cRecord::cRecord(int /*num*/) +cRecord::cRecord(int num) #endif { - lt_info("%s\n", __func__); + lt_info("%s %d\n", __func__, num); dmx = NULL; record_thread_running = false; file_fd = -1; exit_flag = RECORD_STOPPED; + dmx_num = num; #ifdef MARTII bufsize = bs; bufsize_dmx = bs_dmx; @@ -72,7 +73,7 @@ bool cRecord::Start(int fd, unsigned short vpid, unsigned short * apids, int num int i; if (!dmx) - dmx = new cDemux(1); + dmx = new cDemux(dmx_num); #ifdef MARTII dmx->Open(DMX_TP_CHANNEL, NULL, bufsize_dmx); diff --git a/libspark/record_lib.h b/libspark/record_lib.h index 7628068..5dc548b 100644 --- a/libspark/record_lib.h +++ b/libspark/record_lib.h @@ -17,6 +17,7 @@ class cRecord { private: int file_fd; + int dmx_num; cDemux *dmx; pthread_t record_thread; bool record_thread_running;