lib/dvb/demux.cpp

   1 #include <config.h>
   2 #include <stdio.h>
   3 #include <fcntl.h>
   4 #include <sys/ioctl.h>
   5 #include <errno.h>
   6 #include <unistd.h>
   7 #include <signal.h>
   8
   9 #if HAVE_DVB_API_VERSION < 3
  10 #include <ost/dmx.h>
  11 #ifndef DMX_SET_NEGFILTER_MASK
  12         #define DMX_SET_NEGFILTER_MASK   _IOW('o',48,uint8_t *)
  13 #endif
  14 #else
  15 #include <linux/dvb/dmx.h>
  16 #endif
  17
  18 #include "crc32.h"
  19
  20 #include <lib/base/eerror.h>
  21 #include <lib/base/filepush.h>
  22 #include <lib/dvb/idvb.h>
  23 #include <lib/dvb/demux.h>
  24 #include <lib/dvb/esection.h>
  25 #include <lib/dvb/decoder.h>
  26
  27 eDVBDemux::eDVBDemux(int adapter, int demux): adapter(adapter), demux(demux)
  28 {
  29         m_dvr_busy = 0;
  30 }
  31
  32 eDVBDemux::~eDVBDemux()
  33 {
  34 }
  35
  36 int eDVBDemux::openDemux(void)
  37 {
  38         char filename[128];
  39 #if HAVE_DVB_API_VERSION < 3
  40         snprintf(filename, 128, "/dev/dvb/card%d/demux%d", adapter, demux);
  41 #else
  42         snprintf(filename, 128, "/dev/dvb/adapter%d/demux%d", adapter, demux);
  43 #endif
  44         return ::open(filename, O_RDWR);
  45 }
  46
  47 DEFINE_REF(eDVBDemux)
  48
  49 RESULT eDVBDemux::setSourceFrontend(int fenum)
  50 {
  51 #if HAVE_DVB_API_VERSION >= 3
  52         int fd = openDemux();
  53
  54         int n = DMX_SOURCE_FRONT0 + fenum;
  55         int res = ::ioctl(fd, DMX_SET_SOURCE, &n);
  56         if (res)
  57                 eDebug("DMX_SET_SOURCE failed! - %m");
  58         ::close(fd);
  59         return res;
  60 #endif
  61         return 0;
  62 }
  63
  64 RESULT eDVBDemux::setSourcePVR(int pvrnum)
  65 {
  66 #if HAVE_DVB_API_VERSION >= 3
  67         int fd = openDemux();
  68         int n = DMX_SOURCE_DVR0 + pvrnum;
  69         int res = ::ioctl(fd, DMX_SET_SOURCE, &n);
  70         ::close(fd);
  71         return res;
  72 #endif
  73         return 0;
  74 }
  75
  76 RESULT eDVBDemux::createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)
  77 {
  78         RESULT res;
  79         reader = new eDVBSectionReader(this, context, res);
  80         if (res)
  81                 reader = 0;
  82         return res;
  83 }
  84
  85 RESULT eDVBDemux::createTSRecorder(ePtr<iDVBTSRecorder> &recorder)
  86 {
  87         if (m_dvr_busy)
  88                 return -EBUSY;
  89         recorder = new eDVBTSRecorder(this);
  90         return 0;
  91 }
  92
  93 RESULT eDVBDemux::getMPEGDecoder(ePtr<iTSMPEGDecoder> &decoder)
  94 {
  95         decoder = new eTSMPEGDecoder(this, 0);
  96         return 0;
  97 }
  98
  99 RESULT eDVBDemux::getSTC(pts_t &pts)
 100 {
 101         int fd = openDemux();
 102
 103         if (fd < 0)
 104                 return -ENODEV;
 105
 106         struct dmx_stc stc;
 107         stc.num = 0;
 108         stc.base = 1;
 109
 110         if (ioctl(fd, DMX_GET_STC, &stc) < 0)
 111         {
 112                 ::close(fd);
 113                 return -1;
 114         }
 115
 116         pts = stc.stc;
 117
 118         ::close(fd);
 119         return 0;
 120 }
 121
 122 RESULT eDVBDemux::flush()
 123 {
 124         // FIXME: implement flushing the PVR queue here.
 125
 126         m_event(evtFlush);
 127         return 0;
 128 }
 129
 130 RESULT eDVBDemux::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn)
 131 {
 132         conn = new eConnection(this, m_event.connect(event));
 133         return 0;
 134 }
 135
 136 void eDVBSectionReader::data(int)
 137 {
 138         __u8 data[4096]; // max. section size
 139         int r;
 140         r = ::read(fd, data, 4096);
 141         if(r < 0)
 142         {
 143                 eWarning("ERROR reading section - %m\n");
 144                 return;
 145         }
 146         if (checkcrc)
 147         {
 148                         // this check should never happen unless the driver is crappy!
 149                 unsigned int c;
 150                 if ((c = crc32((unsigned)-1, data, r)))
 151                 {
 152                         eDebug("crc32 failed! is %x\n", c);
 153                         return;
 154                 }
 155         }
 156         if (active)
 157                 read(data);
 158         else
 159                 eDebug("data.. but not active");
 160 }
 161
 162 eDVBSectionReader::eDVBSectionReader(eDVBDemux *demux, eMainloop *context, RESULT &res): demux(demux)
 163 {
 164         char filename[128];
 165         fd = demux->openDemux();
 166
 167         if (fd >= 0)
 168         {
 169                 notifier=new eSocketNotifier(context, fd, eSocketNotifier::Read, false);
 170                 CONNECT(notifier->activated, eDVBSectionReader::data);
 171                 res = 0;
 172         } else
 173         {
 174                 perror(filename);
 175                 res = errno;
 176         }
 177 }
 178
 179 DEFINE_REF(eDVBSectionReader)
 180
 181 eDVBSectionReader::~eDVBSectionReader()
 182 {
 183         if (notifier)
 184                 delete notifier;
 185         if (fd >= 0)
 186                 ::close(fd);
 187 }
 188
 189 RESULT eDVBSectionReader::start(const eDVBSectionFilterMask &mask)
 190 {
 191         RESULT res;
 192         if (fd < 0)
 193                 return -ENODEV;
 194
 195         notifier->start();
 196 #if HAVE_DVB_API_VERSION < 3
 197         dmxSctFilterParams sct;
 198 #else
 199         dmx_sct_filter_params sct;
 200 #endif
 201         sct.pid     = mask.pid;
 202         sct.timeout = 0;
 203 #if HAVE_DVB_API_VERSION < 3
 204         sct.flags   = 0;
 205 #else
 206         sct.flags   = DMX_IMMEDIATE_START;
 207 #endif
 208         if (mask.flags & eDVBSectionFilterMask::rfCRC)
 209         {
 210                 sct.flags |= DMX_CHECK_CRC;
 211                 checkcrc = 1;
 212         } else
 213                 checkcrc = 0;
 214
 215         memcpy(sct.filter.filter, mask.data, DMX_FILTER_SIZE);
 216         memcpy(sct.filter.mask, mask.mask, DMX_FILTER_SIZE);
 217 #if HAVE_DVB_API_VERSION >= 3
 218         memcpy(sct.filter.mode, mask.mode, DMX_FILTER_SIZE);
 219         if (::ioctl(fd, DMX_SET_BUFFER_SIZE, 8192*8) < 0)
 220                 eDebug("DMX_SET_BUFFER_SIZE failed(%m)");
 221 #endif
 222
 223         res = ::ioctl(fd, DMX_SET_FILTER, &sct);
 224         if (!res)
 225         {
 226 #if HAVE_DVB_API_VERSION < 3
 227                 res = ::ioctl(fd, DMX_SET_NEGFILTER_MASK, mask.mode);
 228                 if (!res)
 229                 {
 230                         res = ::ioctl(fd, DMX_START, 0);
 231                         if (!res)
 232                                 active = 1;
 233                 }
 234 #else
 235                 active = 1;
 236 #endif
 237         }
 238         return res;
 239 }
 240
 241 RESULT eDVBSectionReader::stop()
 242 {
 243         if (!active)
 244                 return -1;
 245
 246         active=0;
 247         ::ioctl(fd, DMX_STOP);
 248         notifier->stop();
 249
 250         return 0;
 251 }
 252
 253 RESULT eDVBSectionReader::connectRead(const Slot1<void,const __u8*> &r, ePtr<eConnection> &conn)
 254 {
 255         conn = new eConnection(this, read.connect(r));
 256         return 0;
 257 }
 258
 259 DEFINE_REF(eDVBTSRecorder);
 260
 261 eDVBTSRecorder::eDVBTSRecorder(eDVBDemux *demux): m_demux(demux)
 262 {
 263         m_running = 0;
 264         m_format = 0;
 265         m_target_fd = -1;
 266         m_thread = new eFilePushThread();
 267         m_demux->m_dvr_busy = 1;
 268 }
 269
 270 eDVBTSRecorder::~eDVBTSRecorder()
 271 {
 272         stop();
 273         delete m_thread;
 274         m_demux->m_dvr_busy = 0;
 275 }
 276
 277 RESULT eDVBTSRecorder::start()
 278 {
 279         if (m_running)
 280                 return -1;
 281
 282         if (m_target_fd == -1)
 283                 return -2;
 284
 285         char filename[128];
 286 #if HAVE_DVB_API_VERSION < 3
 287         snprintf(filename, 128, "/dev/dvb/card%d/dvr%d", m_demux->adapter, m_demux->demux);
 288 #else
 289         snprintf(filename, 128, "/dev/dvb/adapter%d/dvr%d", m_demux->adapter, m_demux->demux);
 290 #endif
 291         m_source_fd = ::open(filename, O_RDONLY);
 292
 293         if (m_source_fd < 0)
 294         {
 295                 eDebug("FAILED to open dvr (%s) in ts recoder (%m)", filename);
 296                 return -3;
 297         }
 298
 299         m_thread->start(m_source_fd, m_target_fd);
 300         m_running = 1;
 301
 302         for (std::map<int,int>::iterator i(m_pids.begin()); i != m_pids.end(); ++i)
 303                 startPID(i->first);
 304
 305         return 0;
 306 }
 307
 308 RESULT eDVBTSRecorder::addPID(int pid)
 309 {
 310         if (m_pids.find(pid) != m_pids.end())
 311                 return -1;
 312
 313         m_pids.insert(std::pair<int,int>(pid, -1));
 314         if (m_running)
 315                 startPID(pid);
 316         return 0;
 317 }
 318
 319 RESULT eDVBTSRecorder::removePID(int pid)
 320 {
 321         if (m_pids.find(pid) == m_pids.end())
 322                 return -1;
 323
 324         if (m_running)
 325                 stopPID(pid);
 326
 327         m_pids.erase(pid);
 328         return 0;
 329 }
 330
 331 RESULT eDVBTSRecorder::setFormat(int format)
 332 {
 333         if (m_running)
 334                 return -1;
 335         m_format = format;
 336         return 0;
 337 }
 338
 339 RESULT eDVBTSRecorder::setTargetFD(int fd)
 340 {
 341         m_target_fd = fd;
 342         return 0;
 343 }
 344
 345 RESULT eDVBTSRecorder::setBoundary(off_t max)
 346 {
 347         return -1; // not yet implemented
 348 }
 349
 350 RESULT eDVBTSRecorder::stop()
 351 {
 352         for (std::map<int,int>::iterator i(m_pids.begin()); i != m_pids.end(); ++i)
 353                 stopPID(i->first);
 354
 355         if (!m_running)
 356                 return -1;
 357         m_thread->stop();
 358
 359         close(m_source_fd);
 360
 361         return 0;
 362 }
 363
 364 RESULT eDVBTSRecorder::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn)
 365 {
 366         conn = new eConnection(this, m_event.connect(event));
 367         return 0;
 368 }
 369
 370 RESULT eDVBTSRecorder::startPID(int pid)
 371 {
 372         int fd = m_demux->openDemux();
 373         if (fd < 0)
 374         {
 375                 eDebug("FAILED to open demux in ts recoder (%m)");
 376                 return -1;
 377         }
 378
 379 #if HAVE_DVB_API_VERSION < 3
 380         dmxPesFilterParams flt;
 381
 382         flt.pesType = DMX_PES_OTHER;
 383 #else
 384         dmx_pes_filter_params flt;
 385
 386         flt.pes_type = DMX_PES_OTHER;
 387 #endif
 388
 389         flt.pid     = pid;
 390         flt.input   = DMX_IN_FRONTEND;
 391         flt.output  = DMX_OUT_TS_TAP;
 392
 393         flt.flags   = DMX_IMMEDIATE_START;
 394
 395         int res = ::ioctl(fd, DMX_SET_PES_FILTER, &flt);
 396         if (res < 0)
 397         {
 398                 eDebug("set pes filter failed!");
 399                 ::close(fd);
 400                 return -1;
 401         }
 402         m_pids[pid] = fd;
 403
 404         return 0;
 405 }
 406
 407 void eDVBTSRecorder::stopPID(int pid)
 408 {
 409         ::close(m_pids[pid]);
 410         m_pids[pid] = -1;
 411 }