lib/dvb/demux.cpp

   1 #include <stdio.h>
   2 #include <fcntl.h>
   3 #include <sys/ioctl.h>
   4 #include <errno.h>
   5 #include <unistd.h>
   6 #include <signal.h>
   7
   8 // #define FUZZING 1
   9
  10 #if FUZZING
  11                 /* change every 1:FUZZING_PROPABILITY byte */
  12 #define FUZZING_PROPABILITY 100
  13 #endif
  14
  15 #if HAVE_DVB_API_VERSION < 3
  16 #include <ost/dmx.h>
  17
  18 #ifndef DMX_SET_NEGFILTER_MASK
  19         #define DMX_SET_NEGFILTER_MASK   _IOW('o',48,uint8_t *)
  20 #endif
  21
  22 #ifndef DMX_GET_STC
  23         struct dmx_stc
  24         {
  25                 unsigned int num;       /* input : which STC? O..N */
  26                 unsigned int base;      /* output: divisor for stc to get 90 kHz clock */
  27                 unsigned long long stc; /* output: src in 'base'*90 kHz units */
  28         };
  29         #define DMX_GET_STC             _IOR('o', 50, struct dmx_stc)
  30 #endif
  31
  32 #else
  33 #include <linux/dvb/dmx.h>
  34
  35 #define HAVE_ADD_PID
  36
  37 #ifdef HAVE_ADD_PID
  38
  39 #if HAVE_DVB_API_VERSION > 3
  40 #ifndef DMX_ADD_PID
  41 #define DMX_ADD_PID             _IOW('o', 51, __u16)
  42 #define DMX_REMOVE_PID          _IOW('o', 52, __u16)
  43 #endif
  44 #else
  45 #define DMX_ADD_PID              _IO('o', 51)
  46 #define DMX_REMOVE_PID           _IO('o', 52)
  47
  48 typedef enum {
  49         DMX_TAP_TS = 0,
  50         DMX_TAP_PES = DMX_PES_OTHER, /* for backward binary compat. */
  51 } dmx_tap_type_t;
  52 #endif
  53
  54 #endif
  55
  56 #endif
  57
  58 #include "crc32.h"
  59
  60 #include <lib/base/eerror.h>
  61 #include <lib/base/filepush.h>
  62 #include <lib/dvb/idvb.h>
  63 #include <lib/dvb/demux.h>
  64 #include <lib/dvb/esection.h>
  65 #include <lib/dvb/decoder.h>
  66 #include <lib/dvb/pvrparse.h>
  67
  68 eDVBDemux::eDVBDemux(int adapter, int demux): adapter(adapter), demux(demux)
  69 {
  70         m_dvr_busy = 0;
  71 }
  72
  73 eDVBDemux::~eDVBDemux()
  74 {
  75 }
  76
  77 int eDVBDemux::openDemux(void)
  78 {
  79         char filename[128];
  80 #if HAVE_DVB_API_VERSION < 3
  81         snprintf(filename, 128, "/dev/dvb/card%d/demux%d", adapter, demux);
  82 #else
  83         snprintf(filename, 128, "/dev/dvb/adapter%d/demux%d", adapter, demux);
  84 #endif
  85         return ::open(filename, O_RDWR);
  86 }
  87
  88 DEFINE_REF(eDVBDemux)
  89
  90 RESULT eDVBDemux::setSourceFrontend(int fenum)
  91 {
  92 #if HAVE_DVB_API_VERSION >= 3
  93         int fd = openDemux();
  94         int n = DMX_SOURCE_FRONT0 + fenum;
  95         int res = ::ioctl(fd, DMX_SET_SOURCE, &n);
  96         if (res)
  97                 eDebug("DMX_SET_SOURCE failed! - %m");
  98         else
  99                 source = fenum;
 100         ::close(fd);
 101         return res;
 102 #endif
 103         return 0;
 104 }
 105
 106 RESULT eDVBDemux::setSourcePVR(int pvrnum)
 107 {
 108 #if HAVE_DVB_API_VERSION >= 3
 109         int fd = openDemux();
 110         int n = DMX_SOURCE_DVR0 + pvrnum;
 111         int res = ::ioctl(fd, DMX_SET_SOURCE, &n);
 112         source = -1;
 113         ::close(fd);
 114         return res;
 115 #endif
 116         return 0;
 117 }
 118
 119 RESULT eDVBDemux::createSectionReader(eMainloop *context, ePtr<iDVBSectionReader> &reader)
 120 {
 121         RESULT res;
 122         reader = new eDVBSectionReader(this, context, res);
 123         if (res)
 124                 reader = 0;
 125         return res;
 126 }
 127
 128 RESULT eDVBDemux::createPESReader(eMainloop *context, ePtr<iDVBPESReader> &reader)
 129 {
 130         RESULT res;
 131         reader = new eDVBPESReader(this, context, res);
 132         if (res)
 133                 reader = 0;
 134         return res;
 135 }
 136
 137 RESULT eDVBDemux::createTSRecorder(ePtr<iDVBTSRecorder> &recorder)
 138 {
 139         if (m_dvr_busy)
 140                 return -EBUSY;
 141         recorder = new eDVBTSRecorder(this);
 142         return 0;
 143 }
 144
 145 RESULT eDVBDemux::getMPEGDecoder(ePtr<iTSMPEGDecoder> &decoder, int primary)
 146 {
 147         decoder = new eTSMPEGDecoder(this, primary ? 0 : 1);
 148         return 0;
 149 }
 150
 151 RESULT eDVBDemux::getSTC(pts_t &pts, int num)
 152 {
 153         int fd = openDemux();
 154
 155         if (fd < 0)
 156                 return -ENODEV;
 157
 158         struct dmx_stc stc;
 159         stc.num = num;
 160         stc.base = 1;
 161
 162         if (ioctl(fd, DMX_GET_STC, &stc) < 0)
 163         {
 164                 eDebug("DMX_GET_STC failed!");
 165                 ::close(fd);
 166                 return -1;
 167         }
 168
 169         pts = stc.stc;
 170
 171         eDebug("DMX_GET_STC - %lld", pts);
 172
 173         ::close(fd);
 174         return 0;
 175 }
 176
 177 RESULT eDVBDemux::flush()
 178 {
 179         // FIXME: implement flushing the PVR queue here.
 180
 181         m_event(evtFlush);
 182         return 0;
 183 }
 184
 185 RESULT eDVBDemux::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn)
 186 {
 187         conn = new eConnection(this, m_event.connect(event));
 188         return 0;
 189 }
 190
 191 void eDVBSectionReader::data(int)
 192 {
 193         __u8 data[4096]; // max. section size
 194         int r;
 195         r = ::read(fd, data, 4096);
 196 #if FUZZING
 197         int j;
 198         for (j = 0; j < r; ++j)
 199         {
 200                 if (!(rand()%FUZZING_PROPABILITY))
 201                         data[j] ^= rand();
 202         }
 203 #endif
 204         if(r < 0)
 205         {
 206                 eWarning("ERROR reading section - %m\n");
 207                 return;
 208         }
 209         if (checkcrc)
 210         {
 211                         // this check should never happen unless the driver is crappy!
 212                 unsigned int c;
 213                 if ((c = crc32((unsigned)-1, data, r)))
 214                 {
 215                         eDebug("crc32 failed! is %x\n", c);
 216                         return;
 217                 }
 218         }
 219         if (active)
 220                 read(data);
 221         else
 222                 eDebug("data.. but not active");
 223 }
 224
 225 eDVBSectionReader::eDVBSectionReader(eDVBDemux *demux, eMainloop *context, RESULT &res): demux(demux)
 226 {
 227         char filename[128];
 228         fd = demux->openDemux();
 229
 230         if (fd >= 0)
 231         {
 232                 notifier=eSocketNotifier::create(context, fd, eSocketNotifier::Read, false);
 233                 CONNECT(notifier->activated, eDVBSectionReader::data);
 234                 res = 0;
 235         } else
 236         {
 237                 perror(filename);
 238                 res = errno;
 239         }
 240 }
 241
 242 DEFINE_REF(eDVBSectionReader)
 243
 244 eDVBSectionReader::~eDVBSectionReader()
 245 {
 246         if (fd >= 0)
 247                 ::close(fd);
 248 }
 249
 250 RESULT eDVBSectionReader::start(const eDVBSectionFilterMask &mask)
 251 {
 252         RESULT res;
 253         if (fd < 0)
 254                 return -ENODEV;
 255
 256         notifier->start();
 257 #if HAVE_DVB_API_VERSION < 3
 258         dmxSctFilterParams sct;
 259 #else
 260         dmx_sct_filter_params sct;
 261 #endif
 262         sct.pid     = mask.pid;
 263         sct.timeout = 0;
 264 #if HAVE_DVB_API_VERSION < 3
 265         sct.flags   = 0;
 266 #else
 267         sct.flags   = DMX_IMMEDIATE_START;
 268 #endif
 269 #if !FUZZING
 270         if (mask.flags & eDVBSectionFilterMask::rfCRC)
 271         {
 272                 sct.flags |= DMX_CHECK_CRC;
 273                 checkcrc = 1;
 274         } else
 275 #endif
 276                 checkcrc = 0;
 277
 278         memcpy(sct.filter.filter, mask.data, DMX_FILTER_SIZE);
 279         memcpy(sct.filter.mask, mask.mask, DMX_FILTER_SIZE);
 280 #if HAVE_DVB_API_VERSION >= 3
 281         memcpy(sct.filter.mode, mask.mode, DMX_FILTER_SIZE);
 282         if (::ioctl(fd, DMX_SET_BUFFER_SIZE, 8192*8) < 0)
 283                 eDebug("DMX_SET_BUFFER_SIZE failed(%m)");
 284 #endif
 285
 286         res = ::ioctl(fd, DMX_SET_FILTER, &sct);
 287         if (!res)
 288         {
 289 #if HAVE_DVB_API_VERSION < 3
 290                 res = ::ioctl(fd, DMX_SET_NEGFILTER_MASK, mask.mode);
 291                 if (!res)
 292                 {
 293                         res = ::ioctl(fd, DMX_START, 0);
 294                         if (!res)
 295                                 active = 1;
 296                 }
 297 #else
 298                 active = 1;
 299 #endif
 300         }
 301         return res;
 302 }
 303
 304 RESULT eDVBSectionReader::stop()
 305 {
 306         if (!active)
 307                 return -1;
 308
 309         active=0;
 310         ::ioctl(fd, DMX_STOP);
 311         notifier->stop();
 312
 313         return 0;
 314 }
 315
 316 RESULT eDVBSectionReader::connectRead(const Slot1<void,const __u8*> &r, ePtr<eConnection> &conn)
 317 {
 318         conn = new eConnection(this, read.connect(r));
 319         return 0;
 320 }
 321
 322 void eDVBPESReader::data(int)
 323 {
 324         while (1)
 325         {
 326                 __u8 buffer[16384];
 327                 int r;
 328                 r = ::read(m_fd, buffer, 16384);
 329                 if (!r)
 330                         return;
 331                 if(r < 0)
 332                 {
 333                         if (errno == EAGAIN || errno == EINTR) /* ok */
 334                                 return;
 335                         eWarning("ERROR reading PES (fd=%d) - %m", m_fd);
 336                         return;
 337                 }
 338
 339                 if (m_active)
 340                         m_read(buffer, r);
 341                 else
 342                         eWarning("PES reader not active");
 343                 if (r != 16384)
 344                         break;
 345         }
 346 }
 347
 348 eDVBPESReader::eDVBPESReader(eDVBDemux *demux, eMainloop *context, RESULT &res): m_demux(demux)
 349 {
 350         char filename[128];
 351         m_fd = m_demux->openDemux();
 352
 353         if (m_fd >= 0)
 354         {
 355                 ::ioctl(m_fd, DMX_SET_BUFFER_SIZE, 64*1024);
 356                 ::fcntl(m_fd, F_SETFL, O_NONBLOCK);
 357                 m_notifier = eSocketNotifier::create(context, m_fd, eSocketNotifier::Read, false);
 358                 CONNECT(m_notifier->activated, eDVBPESReader::data);
 359                 res = 0;
 360         } else
 361         {
 362                 perror(filename);
 363                 res = errno;
 364         }
 365 }
 366
 367 DEFINE_REF(eDVBPESReader)
 368
 369 eDVBPESReader::~eDVBPESReader()
 370 {
 371         if (m_fd >= 0)
 372                 ::close(m_fd);
 373 }
 374
 375 RESULT eDVBPESReader::start(int pid)
 376 {
 377         RESULT res;
 378         if (m_fd < 0)
 379                 return -ENODEV;
 380
 381         m_notifier->start();
 382
 383 #if HAVE_DVB_API_VERSION < 3
 384         dmxPesFilterParams flt;
 385
 386         flt.pesType = DMX_PES_OTHER;
 387 #else
 388         dmx_pes_filter_params flt;
 389
 390         flt.pes_type = DMX_PES_OTHER;
 391 #endif
 392
 393         flt.pid     = pid;
 394         flt.input   = DMX_IN_FRONTEND;
 395         flt.output  = DMX_OUT_TAP;
 396
 397         flt.flags   = DMX_IMMEDIATE_START;
 398
 399         res = ::ioctl(m_fd, DMX_SET_PES_FILTER, &flt);
 400
 401         if (res)
 402                 eWarning("PES filter: DMX_SET_PES_FILTER - %m");
 403         if (!res)
 404                 m_active = 1;
 405         return res;
 406 }
 407
 408 RESULT eDVBPESReader::stop()
 409 {
 410         if (!m_active)
 411                 return -1;
 412
 413         m_active=0;
 414         ::ioctl(m_fd, DMX_STOP);
 415         m_notifier->stop();
 416
 417         return 0;
 418 }
 419
 420 RESULT eDVBPESReader::connectRead(const Slot2<void,const __u8*,int> &r, ePtr<eConnection> &conn)
 421 {
 422         conn = new eConnection(this, m_read.connect(r));
 423         return 0;
 424 }
 425
 426 class eDVBRecordFileThread: public eFilePushThread
 427 {
 428 public:
 429         eDVBRecordFileThread();
 430         void setTimingPID(int pid, int type);
 431
 432         void startSaveMetaInformation(const std::string &filename);
 433         void stopSaveMetaInformation();
 434         int getLastPTS(pts_t &pts);
 435 protected:
 436         int filterRecordData(const unsigned char *data, int len, size_t &current_span_remaining);
 437 private:
 438         eMPEGStreamParserTS m_ts_parser;
 439         eMPEGStreamInformation m_stream_info;
 440         off_t m_current_offset;
 441         pts_t m_last_pcr; /* very approximate.. */
 442         int m_pid;
 443 };
 444
 445 eDVBRecordFileThread::eDVBRecordFileThread()
 446         :eFilePushThread(IOPRIO_CLASS_RT, 7), m_ts_parser(m_stream_info)
 447 {
 448         m_current_offset = 0;
 449 }
 450
 451 void eDVBRecordFileThread::setTimingPID(int pid, int type)
 452 {
 453         m_ts_parser.setPid(pid, type);
 454 }
 455
 456 void eDVBRecordFileThread::startSaveMetaInformation(const std::string &filename)
 457 {
 458         m_stream_info.startSave(filename.c_str());
 459 }
 460
 461 void eDVBRecordFileThread::stopSaveMetaInformation()
 462 {
 463         m_stream_info.stopSave();
 464 }
 465
 466 int eDVBRecordFileThread::getLastPTS(pts_t &pts)
 467 {
 468         return m_ts_parser.getLastPTS(pts);
 469 }
 470
 471 int eDVBRecordFileThread::filterRecordData(const unsigned char *data, int len, size_t &current_span_remaining)
 472 {
 473         m_ts_parser.parseData(m_current_offset, data, len);
 474
 475         m_current_offset += len;
 476
 477         return len;
 478 }
 479
 480 DEFINE_REF(eDVBTSRecorder);
 481
 482 eDVBTSRecorder::eDVBTSRecorder(eDVBDemux *demux): m_demux(demux)
 483 {
 484         m_running = 0;
 485         m_target_fd = -1;
 486         m_thread = new eDVBRecordFileThread();
 487   CONNECT(m_thread->m_event, eDVBTSRecorder::filepushEvent);
 488 #ifndef HAVE_ADD_PID
 489         m_demux->m_dvr_busy = 1;
 490 #endif
 491 }
 492
 493 eDVBTSRecorder::~eDVBTSRecorder()
 494 {
 495         stop();
 496         delete m_thread;
 497 #ifndef HAVE_ADD_PID
 498         m_demux->m_dvr_busy = 0;
 499 #endif
 500 }
 501
 502 RESULT eDVBTSRecorder::start()
 503 {
 504         std::map<int,int>::iterator i(m_pids.begin());
 505
 506         if (m_running)
 507                 return -1;
 508
 509         if (m_target_fd == -1)
 510                 return -2;
 511
 512         if (i == m_pids.end())
 513                 return -3;
 514
 515         char filename[128];
 516 #ifndef HAVE_ADD_PID
 517 #if HAVE_DVB_API_VERSION < 3
 518         snprintf(filename, 128, "/dev/dvb/card%d/dvr%d", m_demux->adapter, m_demux->demux);
 519 #else
 520         snprintf(filename, 128, "/dev/dvb/adapter%d/dvr%d", m_demux->adapter, m_demux->demux);
 521 #endif
 522         m_source_fd = ::open(filename, O_RDONLY);
 523
 524         if (m_source_fd < 0)
 525         {
 526                 eDebug("FAILED to open dvr (%s) in ts recoder (%m)", filename);
 527                 return -3;
 528         }
 529 #else
 530         snprintf(filename, 128, "/dev/dvb/adapter%d/demux%d", m_demux->adapter, m_demux->demux);
 531
 532         m_source_fd = ::open(filename, O_RDONLY);
 533
 534         if (m_source_fd < 0)
 535         {
 536                 eDebug("FAILED to open demux (%s) in ts recoder (%m)", filename);
 537                 return -3;
 538         }
 539
 540         ::ioctl(m_source_fd, DMX_SET_BUFFER_SIZE, 1024*1024);
 541
 542         dmx_pes_filter_params flt;
 543 #if HAVE_DVB_API_VERSION > 3
 544         flt.pes_type = DMX_PES_OTHER;
 545         flt.output  = DMX_OUT_TSDEMUX_TAP;
 546 #else
 547         flt.pes_type = (dmx_pes_type_t)DMX_TAP_TS;
 548         flt.output  = DMX_OUT_TAP;
 549 #endif
 550         flt.pid     = i->first;
 551         ++i;
 552         flt.input   = DMX_IN_FRONTEND;
 553         flt.flags   = 0;
 554         int res = ::ioctl(m_source_fd, DMX_SET_PES_FILTER, &flt);
 555         if (res)
 556         {
 557                 eDebug("DMX_SET_PES_FILTER: %m");
 558                 ::close(m_source_fd);
 559                 return -3;
 560         }
 561
 562         ::ioctl(m_source_fd, DMX_START);
 563
 564 #endif
 565
 566         if (m_target_filename != "")
 567                 m_thread->startSaveMetaInformation(m_target_filename);
 568
 569         m_thread->start(m_source_fd, m_target_fd);
 570         m_running = 1;
 571
 572         while (i != m_pids.end()) {
 573                 startPID(i->first);
 574                 ++i;
 575         }
 576
 577         return 0;
 578 }
 579
 580 RESULT eDVBTSRecorder::addPID(int pid)
 581 {
 582         if (m_pids.find(pid) != m_pids.end())
 583                 return -1;
 584
 585         m_pids.insert(std::pair<int,int>(pid, -1));
 586         if (m_running)
 587                 startPID(pid);
 588         return 0;
 589 }
 590
 591 RESULT eDVBTSRecorder::removePID(int pid)
 592 {
 593         if (m_pids.find(pid) == m_pids.end())
 594                 return -1;
 595
 596         if (m_running)
 597                 stopPID(pid);
 598
 599         m_pids.erase(pid);
 600         return 0;
 601 }
 602
 603 RESULT eDVBTSRecorder::setTimingPID(int pid, int type)
 604 {
 605         if (m_running)
 606                 return -1;
 607         m_thread->setTimingPID(pid, type);
 608         return 0;
 609 }
 610
 611 RESULT eDVBTSRecorder::setTargetFD(int fd)
 612 {
 613         m_target_fd = fd;
 614         return 0;
 615 }
 616
 617 RESULT eDVBTSRecorder::setTargetFilename(const char *filename)
 618 {
 619         m_target_filename = filename;
 620         return 0;
 621 }
 622
 623 RESULT eDVBTSRecorder::setBoundary(off_t max)
 624 {
 625         return -1; // not yet implemented
 626 }
 627
 628 RESULT eDVBTSRecorder::stop()
 629 {
 630         for (std::map<int,int>::iterator i(m_pids.begin()); i != m_pids.end(); ++i)
 631                 stopPID(i->first);
 632
 633         if (!m_running)
 634                 return -1;
 635         m_thread->stop();
 636
 637         close(m_source_fd);
 638         m_source_fd = -1;
 639
 640         m_thread->stopSaveMetaInformation();
 641
 642         return 0;
 643 }
 644
 645 RESULT eDVBTSRecorder::getCurrentPCR(pts_t &pcr)
 646 {
 647         if (!m_running)
 648                 return 0;
 649         if (!m_thread)
 650                 return 0;
 651                 /* XXX: we need a lock here */
 652
 653                         /* we don't filter PCR data, so just use the last received PTS, which is not accurate, but better than nothing */
 654         return m_thread->getLastPTS(pcr);
 655 }
 656
 657 RESULT eDVBTSRecorder::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &conn)
 658 {
 659         conn = new eConnection(this, m_event.connect(event));
 660         return 0;
 661 }
 662
 663 RESULT eDVBTSRecorder::startPID(int pid)
 664 {
 665 #ifndef HAVE_ADD_PID
 666         int fd = m_demux->openDemux();
 667         if (fd < 0)
 668         {
 669                 eDebug("FAILED to open demux in ts recoder (%m)");
 670                 return -1;
 671         }
 672
 673 #if HAVE_DVB_API_VERSION < 3
 674         dmxPesFilterParams flt;
 675
 676         flt.pesType = DMX_PES_OTHER;
 677 #else
 678         dmx_pes_filter_params flt;
 679
 680         flt.pes_type = DMX_PES_OTHER;
 681 #endif
 682
 683         flt.pid     = pid;
 684         flt.input   = DMX_IN_FRONTEND;
 685         flt.output  = DMX_OUT_TS_TAP;
 686
 687         flt.flags   = DMX_IMMEDIATE_START;
 688
 689         int res = ::ioctl(fd, DMX_SET_PES_FILTER, &flt);
 690         if (res < 0)
 691         {
 692                 eDebug("set pes filter failed!");
 693                 ::close(fd);
 694                 return -1;
 695         }
 696         m_pids[pid] = fd;
 697 #else
 698         while(true) {
 699 #if HAVE_DVB_API_VERSION > 3
 700                 __u16 p = pid;
 701                 if (::ioctl(m_source_fd, DMX_ADD_PID, &p) < 0) {
 702 #else
 703                 if (::ioctl(m_source_fd, DMX_ADD_PID, pid) < 0) {
 704 #endif
 705                         perror("DMX_ADD_PID");
 706                         if (errno == EAGAIN || errno == EINTR) {
 707                                 eDebug("retry!");
 708                                 continue;
 709                         }
 710                 } else
 711                         m_pids[pid] = 1;
 712                 break;
 713         }
 714 #endif
 715         return 0;
 716 }
 717
 718 void eDVBTSRecorder::stopPID(int pid)
 719 {
 720 #ifndef HAVE_ADD_PID
 721         if (m_pids[pid] != -1)
 722                 ::close(m_pids[pid]);
 723 #else
 724         if (m_pids[pid] != -1)
 725         {
 726                 while(true) {
 727 #if HAVE_DVB_API_VERSION > 3
 728                         __u16 p = pid;
 729                         if (::ioctl(m_source_fd, DMX_REMOVE_PID, &p) < 0) {
 730 #else
 731                         if (::ioctl(m_source_fd, DMX_REMOVE_PID, pid) < 0) {
 732 #endif
 733                                 perror("DMX_REMOVE_PID");
 734                                 if (errno == EAGAIN || errno == EINTR) {
 735                                         eDebug("retry!");
 736                                         continue;
 737                                 }
 738                         }
 739                         break;
 740                 }
 741         }
 742 #endif
 743         m_pids[pid] = -1;
 744 }
 745
 746 void eDVBTSRecorder::filepushEvent(int event)
 747 {
 748         switch (event)
 749         {
 750         case eFilePushThread::evtWriteError:
 751                 m_event(eventWriteError);
 752                 break;
 753         }
 754 }