code.vuplus.com Git - vuplus_dvbapp/blob - lib/service/servicedvb.cpp

   1 #include <lib/base/eerror.h>
   2 #include <lib/base/object.h>
   3 #include <string>
   4 #include <lib/service/servicedvb.h>
   5 #include <lib/service/service.h>
   6 #include <lib/base/init_num.h>
   7 #include <lib/base/init.h>
   8 #include <lib/base/nconfig.h> // access to python config
   9 #include <lib/dvb/dvb.h>
  10 #include <lib/dvb/db.h>
  11 #include <lib/dvb/decoder.h>
  12
  13 #include <lib/components/file_eraser.h>
  14 #include <lib/service/servicedvbrecord.h>
  15 #include <lib/service/event.h>
  16 #include <lib/dvb/metaparser.h>
  17 #include <lib/dvb/tstools.h>
  18 #include <lib/python/python.h>
  19
  20                 /* for subtitles */
  21 #include <lib/gui/esubtitle.h>
  22
  23 #include <sys/vfs.h>
  24
  25 #include <byteswap.h>
  26 #include <netinet/in.h>
  27
  28 #define INTERNAL_TELETEXT
  29
  30 #ifndef BYTE_ORDER
  31 #error no byte order defined!
  32 #endif
  33
  34 #define TSPATH "/media/hdd"
  35
  36 class eStaticServiceDVBInformation: public iStaticServiceInformation
  37 {
  38         DECLARE_REF(eStaticServiceDVBInformation);
  39 public:
  40         RESULT getName(const eServiceReference &ref, std::string &name);
  41         int getLength(const eServiceReference &ref);
  42 };
  43
  44 DEFINE_REF(eStaticServiceDVBInformation);
  45
  46 RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
  47 {
  48         eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
  49         if ( !ref.name.empty() )
  50         {
  51                 if (service.getParentTransportStreamID().get()) // linkage subservice
  52                 {
  53                         ePtr<iServiceHandler> service_center;
  54                         if (!eServiceCenter::getInstance(service_center))
  55                         {
  56                                 eServiceReferenceDVB parent = service;
  57                                 parent.setTransportStreamID( service.getParentTransportStreamID() );
  58                                 parent.setServiceID( service.getParentServiceID() );
  59                                 parent.setParentTransportStreamID(eTransportStreamID(0));
  60                                 parent.setParentServiceID(eServiceID(0));
  61                                 parent.name="";
  62                                 ePtr<iStaticServiceInformation> service_info;
  63                                 if (!service_center->info(parent, service_info))
  64                                 {
  65                                         if (!service_info->getName(parent, name))
  66                                         {
  67                                                 // just show short name
  68                                                 unsigned int pos = name.find("\xc2\x86");
  69                                                 if ( pos != std::string::npos )
  70                                                         name.erase(0, pos+2);
  71                                                 pos = name.find("\xc2\x87");
  72                                                 if ( pos != std::string::npos )
  73                                                         name.erase(pos);
  74                                                 name+=" - ";
  75                                         }
  76                                 }
  77                         }
  78                 }
  79                 else
  80                         name="";
  81                 name += ref.name;
  82                 return 0;
  83         }
  84         else
  85                 return -1;
  86 }
  87
  88 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
  89 {
  90         return -1;
  91 }
  92
  93 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
  94 {
  95         DECLARE_REF(eStaticServiceDVBBouquetInformation);
  96 public:
  97         RESULT getName(const eServiceReference &ref, std::string &name);
  98         int getLength(const eServiceReference &ref);
  99 };
 100
 101 DEFINE_REF(eStaticServiceDVBBouquetInformation);
 102
 103 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
 104 {
 105         ePtr<iDVBChannelList> db;
 106         ePtr<eDVBResourceManager> res;
 107
 108         int err;
 109         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 110         {
 111                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
 112                 return err;
 113         }
 114         if ((err = res->getChannelList(db)) != 0)
 115         {
 116                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
 117                 return err;
 118         }
 119
 120         eBouquet *bouquet=0;
 121         if ((err = db->getBouquet(ref, bouquet)) != 0)
 122         {
 123                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
 124                 return -1;
 125         }
 126
 127         if ( bouquet && bouquet->m_bouquet_name.length() )
 128         {
 129                 name = bouquet->m_bouquet_name;
 130                 return 0;
 131         }
 132         else
 133                 return -1;
 134 }
 135
 136 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
 137 {
 138         return -1;
 139 }
 140
 141 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
 142 {
 143         DECLARE_REF(eStaticServiceDVBPVRInformation);
 144         eServiceReference m_ref;
 145         eDVBMetaParser m_parser;
 146 public:
 147         eStaticServiceDVBPVRInformation(const eServiceReference &ref);
 148         RESULT getName(const eServiceReference &ref, std::string &name);
 149         int getLength(const eServiceReference &ref);
 150         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time);
 151
 152         int getInfo(const eServiceReference &ref, int w);
 153         std::string getInfoString(const eServiceReference &ref,int w);
 154 };
 155
 156 DEFINE_REF(eStaticServiceDVBPVRInformation);
 157
 158 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
 159 {
 160         m_ref = ref;
 161         m_parser.parseFile(ref.path);
 162 }
 163
 164 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
 165 {
 166         ASSERT(ref == m_ref);
 167         name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
 168         return 0;
 169 }
 170
 171 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
 172 {
 173         ASSERT(ref == m_ref);
 174
 175         eDVBTSTools tstools;
 176
 177         if (tstools.openFile(ref.path.c_str()))
 178                 return 0;
 179
 180         pts_t len;
 181         if (tstools.calcLen(len))
 182                 return 0;
 183
 184         return len / 90000;
 185 }
 186
 187 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
 188 {
 189         switch (w)
 190         {
 191         case iServiceInformation::sDescription:
 192                 return iServiceInformation::resIsString;
 193         case iServiceInformation::sServiceref:
 194                 return iServiceInformation::resIsString;
 195         case iServiceInformation::sTimeCreate:
 196                 if (m_parser.m_time_create)
 197                         return m_parser.m_time_create;
 198                 else
 199                         return iServiceInformation::resNA;
 200         default:
 201                 return iServiceInformation::resNA;
 202         }
 203 }
 204
 205 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
 206 {
 207         switch (w)
 208         {
 209         case iServiceInformation::sDescription:
 210                 return m_parser.m_description;
 211         case iServiceInformation::sServiceref:
 212                 return m_parser.m_ref.toString();
 213         default:
 214                 return "";
 215         }
 216 }
 217
 218 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
 219 {
 220         if (!ref.path.empty())
 221         {
 222                 ePtr<eServiceEvent> event = new eServiceEvent;
 223                 std::string filename = ref.path;
 224                 filename.erase(filename.length()-2, 2);
 225                 filename+="eit";
 226                 if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get()))
 227                 {
 228                         evt = event;
 229                         return 0;
 230                 }
 231         }
 232         evt = 0;
 233         return -1;
 234 }
 235
 236 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
 237 {
 238         DECLARE_REF(eDVBPVRServiceOfflineOperations);
 239         eServiceReferenceDVB m_ref;
 240 public:
 241         eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
 242
 243         RESULT deleteFromDisk(int simulate);
 244         RESULT getListOfFilenames(std::list<std::string> &);
 245 };
 246
 247 DEFINE_REF(eDVBPVRServiceOfflineOperations);
 248
 249 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
 250 {
 251 }
 252
 253 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
 254 {
 255         if (simulate)
 256                 return 0;
 257         else
 258         {
 259                 std::list<std::string> res;
 260                 if (getListOfFilenames(res))
 261                         return -1;
 262
 263                 eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance();
 264                 if (!eraser)
 265                         eDebug("FATAL !! can't get background file eraser");
 266
 267                 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
 268                 {
 269                         eDebug("Removing %s...", i->c_str());
 270                         if (eraser)
 271                                 eraser->erase(i->c_str());
 272                         else
 273                                 ::unlink(i->c_str());
 274                 }
 275
 276                 return 0;
 277         }
 278 }
 279
 280 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
 281 {
 282         res.clear();
 283         res.push_back(m_ref.path);
 284
 285 // handling for old splitted recordings (enigma 1)
 286         char buf[255];
 287         int slice=1;
 288         while(true)
 289         {
 290                 snprintf(buf, 255, "%s.%03d", m_ref.path.c_str(), slice++);
 291                 struct stat s;
 292                 if (stat(buf, &s) < 0)
 293                         break;
 294                 res.push_back(buf);
 295         }
 296
 297         res.push_back(m_ref.path + ".meta");
 298         res.push_back(m_ref.path + ".ap");
 299         res.push_back(m_ref.path + ".cuts");
 300         std::string tmp = m_ref.path;
 301         tmp.erase(m_ref.path.length()-3);
 302         res.push_back(tmp + ".eit");
 303         return 0;
 304 }
 305
 306 DEFINE_REF(eServiceFactoryDVB)
 307
 308 eServiceFactoryDVB::eServiceFactoryDVB()
 309 {
 310         ePtr<eServiceCenter> sc;
 311
 312         eServiceCenter::getPrivInstance(sc);
 313         if (sc)
 314                 sc->addServiceFactory(eServiceFactoryDVB::id, this);
 315
 316         m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
 317         m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
 318 }
 319
 320 eServiceFactoryDVB::~eServiceFactoryDVB()
 321 {
 322         ePtr<eServiceCenter> sc;
 323
 324         eServiceCenter::getPrivInstance(sc);
 325         if (sc)
 326                 sc->removeServiceFactory(eServiceFactoryDVB::id);
 327 }
 328
 329 DEFINE_REF(eDVBServiceList);
 330
 331 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
 332 {
 333 }
 334
 335 eDVBServiceList::~eDVBServiceList()
 336 {
 337 }
 338
 339 RESULT eDVBServiceList::startQuery()
 340 {
 341         ePtr<iDVBChannelList> db;
 342         ePtr<eDVBResourceManager> res;
 343
 344         int err;
 345         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 346         {
 347                 eDebug("no resource manager");
 348                 return err;
 349         }
 350         if ((err = res->getChannelList(db)) != 0)
 351         {
 352                 eDebug("no channel list");
 353                 return err;
 354         }
 355
 356         ePtr<eDVBChannelQuery> q;
 357
 358         if (!m_parent.path.empty())
 359         {
 360                 eDVBChannelQuery::compile(q, m_parent.path);
 361                 if (!q)
 362                 {
 363                         eDebug("compile query failed");
 364                         return err;
 365                 }
 366         }
 367
 368         if ((err = db->startQuery(m_query, q, m_parent)) != 0)
 369         {
 370                 eDebug("startQuery failed");
 371                 return err;
 372         }
 373
 374         return 0;
 375 }
 376
 377 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list, bool sorted)
 378 {
 379         eServiceReferenceDVB ref;
 380
 381         if (!m_query)
 382                 return -1;
 383
 384         while (!m_query->getNextResult(ref))
 385                 list.push_back(ref);
 386
 387         if (sorted)
 388                 list.sort(iListableServiceCompare(this));
 389
 390         return 0;
 391 }
 392
 393 //   The first argument of this function is a format string to specify the order and
 394 //   the content of the returned list
 395 //   useable format options are
 396 //   R = Service Reference (as swig object .. this is very slow)
 397 //   S = Service Reference (as python string object .. same as ref.toString())
 398 //   N = Service Name (as python string object)
 399 //   when exactly one return value per service is selected in the format string,
 400 //   then each value is directly a list entry
 401 //   when more than one value is returned per service, then the list is a list of
 402 //   python tuples
 403 //   unknown format string chars are returned as python None values !
 404 PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
 405 {
 406         PyObject *ret=0;
 407         std::list<eServiceReference> tmplist;
 408         int retcount=1;
 409
 410         if (!format || !(retcount=strlen(format)))
 411                 format = "R"; // just return service reference swig object ...
 412
 413         if (!getContent(tmplist, sorted))
 414         {
 415                 int services=tmplist.size();
 416                 ePtr<iStaticServiceInformation> sptr;
 417                 eServiceCenterPtr service_center;
 418
 419                 if (strchr(format, 'N'))
 420                         eServiceCenter::getPrivInstance(service_center);
 421
 422                 ret = PyList_New(services);
 423                 std::list<eServiceReference>::iterator it(tmplist.begin());
 424
 425                 for (int cnt=0; cnt < services; ++cnt)
 426                 {
 427                         eServiceReference &ref=*it++;
 428                         PyObject *tuple = retcount > 1 ? PyTuple_New(retcount) : 0;
 429                         for (int i=0; i < retcount; ++i)
 430                         {
 431                                 PyObject *tmp=0;
 432                                 switch(format[i])
 433                                 {
 434                                 case 'R':  // service reference (swig)object
 435                                         tmp = New_eServiceReference(ref);
 436                                         break;
 437                                 case 'S':  // service reference string
 438                                         tmp = PyString_FromString(ref.toString().c_str());
 439                                         break;
 440                                 case 'N':  // service name
 441                                         if (service_center)
 442                                         {
 443                                                 service_center->info(ref, sptr);
 444                                                 if (sptr)
 445                                                 {
 446                                                         std::string name;
 447                                                         sptr->getName(ref, name);
 448                                                         if (name.length())
 449                                                                 tmp = PyString_FromString(name.c_str());
 450                                                 }
 451                                         }
 452                                         if (!tmp)
 453                                                 tmp = PyString_FromString("<n/a>");
 454                                         break;
 455                                 default:
 456                                         if (tuple)
 457                                         {
 458                                                 tmp = Py_None;
 459                                                 Py_INCREF(Py_None);
 460                                         }
 461                                         break;
 462                                 }
 463                                 if (tmp)
 464                                 {
 465                                         if (tuple)
 466                                                 PyTuple_SET_ITEM(tuple, i, tmp);
 467                                         else
 468                                                 PyList_SET_ITEM(ret, cnt, tmp);
 469                                 }
 470                         }
 471                         if (tuple)
 472                                 PyList_SET_ITEM(ret, cnt, tuple);
 473                 }
 474         }
 475         return ret ? ret : PyList_New(0);
 476 }
 477
 478 RESULT eDVBServiceList::getNext(eServiceReference &ref)
 479 {
 480         if (!m_query)
 481                 return -1;
 482
 483         return m_query->getNextResult((eServiceReferenceDVB&)ref);
 484 }
 485
 486 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
 487 {
 488         return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
 489 }
 490
 491 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
 492 {
 493         if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
 494         {
 495                 ePtr<iDVBChannelList> db;
 496                 ePtr<eDVBResourceManager> resm;
 497
 498                 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
 499                         return -1;
 500
 501                 if (db->getBouquet(m_parent, m_bouquet) != 0)
 502                         return -1;
 503
 504                 res = this;
 505
 506                 return 0;
 507         }
 508         res = 0;
 509         return -1;
 510 }
 511
 512 RESULT eDVBServiceList::addService(eServiceReference &ref, eServiceReference before)
 513 {
 514         if (!m_bouquet)
 515                 return -1;
 516         return m_bouquet->addService(ref, before);
 517 }
 518
 519 RESULT eDVBServiceList::removeService(eServiceReference &ref)
 520 {
 521         if (!m_bouquet)
 522                 return -1;
 523         return m_bouquet->removeService(ref);
 524 }
 525
 526 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
 527 {
 528         if (!m_bouquet)
 529                 return -1;
 530         return m_bouquet->moveService(ref, pos);
 531 }
 532
 533 RESULT eDVBServiceList::flushChanges()
 534 {
 535         if (!m_bouquet)
 536                 return -1;
 537         return m_bouquet->flushChanges();
 538 }
 539
 540 RESULT eDVBServiceList::setListName(const std::string &name)
 541 {
 542         if (!m_bouquet)
 543                 return -1;
 544         return m_bouquet->setListName(name);
 545 }
 546
 547 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
 548 {
 549         ePtr<eDVBService> service;
 550         int r = lookupService(service, ref);
 551         if (r)
 552                 service = 0;
 553                 // check resources...
 554         ptr = new eDVBServicePlay(ref, service);
 555         return 0;
 556 }
 557
 558 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
 559 {
 560         if (ref.path.empty())
 561         {
 562                 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
 563                 return 0;
 564         } else
 565         {
 566                 ptr = 0;
 567                 return -1;
 568         }
 569 }
 570
 571 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
 572 {
 573         ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
 574         if (list->startQuery())
 575         {
 576                 ptr = 0;
 577                 return -1;
 578         }
 579
 580         ptr = list;
 581         return 0;
 582 }
 583
 584 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
 585 {
 586         /* is a listable service? */
 587         if ((ref.flags & eServiceReference::flagDirectory) == eServiceReference::flagDirectory) // bouquet
 588         {
 589                 if ( !ref.name.empty() )  // satellites or providers list
 590                         ptr = m_StaticServiceDVBInfo;
 591                 else // a dvb bouquet
 592                         ptr = m_StaticServiceDVBBouquetInfo;
 593         }
 594         else if (!ref.path.empty()) /* do we have a PVR service? */
 595                 ptr = new eStaticServiceDVBPVRInformation(ref);
 596         else // normal dvb service
 597         {
 598                 ePtr<eDVBService> service;
 599                 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
 600                         ptr = m_StaticServiceDVBInfo;
 601                 else
 602                         /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
 603                         ptr = service;
 604         }
 605         return 0;
 606 }
 607
 608 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
 609 {
 610         if (ref.path.empty())
 611         {
 612                 ptr = 0;
 613                 return -1;
 614         } else
 615         {
 616                 ptr = new eDVBPVRServiceOfflineOperations(ref);
 617                 return 0;
 618         }
 619 }
 620
 621 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
 622 {
 623                         // TODO: handle the listing itself
 624         // if (ref.... == -1) .. return "... bouquets ...";
 625         // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
 626                         // TODO: cache
 627         ePtr<iDVBChannelList> db;
 628         ePtr<eDVBResourceManager> res;
 629
 630         int err;
 631         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 632         {
 633                 eDebug("no resource manager");
 634                 return err;
 635         }
 636         if ((err = res->getChannelList(db)) != 0)
 637         {
 638                 eDebug("no channel list");
 639                 return err;
 640         }
 641
 642                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
 643         if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
 644         {
 645                 eDebug("getService failed!");
 646                 return err;
 647         }
 648
 649         return 0;
 650 }
 651
 652 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
 653         m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
 654 {
 655         m_is_primary = 1;
 656         m_is_pvr = !m_reference.path.empty();
 657
 658         m_timeshift_enabled = m_timeshift_active = 0;
 659         m_skipmode = 0;
 660
 661         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
 662         CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
 663         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 664
 665         m_cuesheet_changed = 0;
 666         m_cutlist_enabled = 1;
 667
 668         m_subtitle_widget = 0;
 669
 670         CONNECT(m_subtitle_sync_timer.timeout, eDVBServicePlay::checkSubtitleTiming);
 671 }
 672
 673 eDVBServicePlay::~eDVBServicePlay()
 674 {
 675         delete m_subtitle_widget;
 676 }
 677
 678 void eDVBServicePlay::gotNewEvent()
 679 {
 680 #if 0
 681                 // debug only
 682         ePtr<eServiceEvent> m_event_now, m_event_next;
 683         getEvent(m_event_now, 0);
 684         getEvent(m_event_next, 1);
 685
 686         if (m_event_now)
 687                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
 688         if (m_event_next)
 689                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
 690 #endif
 691         m_event((iPlayableService*)this, evUpdatedEventInfo);
 692 }
 693
 694 void eDVBServicePlay::serviceEvent(int event)
 695 {
 696         switch (event)
 697         {
 698         case eDVBServicePMTHandler::eventTuned:
 699         {
 700                 ePtr<iDVBDemux> m_demux;
 701                 if (!m_service_handler.getDataDemux(m_demux))
 702                 {
 703                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
 704                         int sid = ref.getParentServiceID().get();
 705                         if (!sid)
 706                                 sid = ref.getServiceID().get();
 707                         if ( ref.getParentTransportStreamID().get() &&
 708                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
 709                                 m_event_handler.startOther(m_demux, sid);
 710                         else
 711                                 m_event_handler.start(m_demux, sid);
 712                 }
 713                 break;
 714         }
 715         case eDVBServicePMTHandler::eventTuneFailed:
 716         {
 717                 eDebug("DVB service failed to tune");
 718                 m_event((iPlayableService*)this, evTuneFailed);
 719                 break;
 720         }
 721         case eDVBServicePMTHandler::eventNewProgramInfo:
 722         {
 723                 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
 724                 if (m_timeshift_enabled)
 725                         updateTimeshiftPids();
 726                 if (!m_timeshift_active)
 727                         updateDecoder();
 728                 if (m_first_program_info && m_is_pvr)
 729                 {
 730                         m_first_program_info = 0;
 731                         seekTo(0);
 732                 }
 733                 m_event((iPlayableService*)this, evUpdatedInfo);
 734                 break;
 735         }
 736         case eDVBServicePMTHandler::eventEOF:
 737                 m_event((iPlayableService*)this, evEOF);
 738                 break;
 739         case eDVBServicePMTHandler::eventSOF:
 740                 m_event((iPlayableService*)this, evSOF);
 741                 break;
 742         }
 743 }
 744
 745 void eDVBServicePlay::serviceEventTimeshift(int event)
 746 {
 747         switch (event)
 748         {
 749         case eDVBServicePMTHandler::eventNewProgramInfo:
 750                 if (m_timeshift_active)
 751                         updateDecoder();
 752                 break;
 753         case eDVBServicePMTHandler::eventSOF:
 754                 m_event((iPlayableService*)this, evSOF);
 755                 break;
 756         case eDVBServicePMTHandler::eventEOF:
 757                 switchToLive();
 758                 break;
 759         }
 760 }
 761
 762 RESULT eDVBServicePlay::start()
 763 {
 764         int r;
 765                 /* in pvr mode, we only want to use one demux. in tv mode, we're using
 766                    two (one for decoding, one for data source), as we must be prepared
 767                    to start recording from the data demux. */
 768         if (m_is_pvr)
 769                 m_cue = new eCueSheet();
 770
 771         m_first_program_info = 1;
 772         eServiceReferenceDVB &service = (eServiceReferenceDVB&)m_reference;
 773         r = m_service_handler.tune(service, m_is_pvr, m_cue);
 774
 775                 /* inject EIT if there is a stored one */
 776         if (m_is_pvr)
 777         {
 778                 std::string filename = service.path;
 779                 filename.erase(filename.length()-2, 2);
 780                 filename+="eit";
 781                 ePtr<eServiceEvent> event = new eServiceEvent;
 782                 if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()))
 783                 {
 784                         ePtr<eServiceEvent> empty;
 785                         m_event_handler.inject(event, 0);
 786                         m_event_handler.inject(empty, 1);
 787                 }
 788         }
 789
 790         if (m_is_pvr)
 791                 loadCuesheet();
 792
 793         m_event(this, evStart);
 794         m_event((iPlayableService*)this, evSeekableStatusChanged);
 795         return 0;
 796 }
 797
 798 RESULT eDVBServicePlay::stop()
 799 {
 800                 /* add bookmark for last play position */
 801         if (m_is_pvr)
 802         {
 803                 pts_t play_position;
 804                 if (!getPlayPosition(play_position))
 805                 {
 806                                 /* remove last position */
 807                         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end();)
 808                         {
 809                                 if (i->what == 3) /* current play position */
 810                                 {
 811                                         m_cue_entries.erase(i);
 812                                         i = m_cue_entries.begin();
 813                                         continue;
 814                                 } else
 815                                         ++i;
 816                         }
 817
 818                         m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
 819                         m_cuesheet_changed = 1;
 820                 }
 821         }
 822
 823         stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */
 824
 825         m_service_handler_timeshift.free();
 826         m_service_handler.free();
 827
 828         if (m_is_pvr && m_cuesheet_changed)
 829                 saveCuesheet();
 830
 831         return 0;
 832 }
 833
 834 RESULT eDVBServicePlay::setTarget(int target)
 835 {
 836         m_is_primary = !target;
 837         return 0;
 838 }
 839
 840 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
 841 {
 842         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
 843         return 0;
 844 }
 845
 846 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
 847 {
 848                 /* note: we check for timeshift to be enabled,
 849                    not neccessary active. if you pause when timeshift
 850                    is not active, you should activate it when unpausing */
 851         if ((!m_is_pvr) && (!m_timeshift_enabled))
 852         {
 853                 ptr = 0;
 854                 return -1;
 855         }
 856
 857         ptr = this;
 858         return 0;
 859 }
 860
 861 RESULT eDVBServicePlay::setSlowMotion(int ratio)
 862 {
 863         if (m_decoder)
 864                 return m_decoder->setSlowMotion(ratio);
 865         else
 866                 return -1;
 867 }
 868
 869 RESULT eDVBServicePlay::setFastForward(int ratio)
 870 {
 871         int skipmode, ffratio;
 872
 873         if (ratio > 8)
 874         {
 875                 skipmode = ratio;
 876                 ffratio = 1;
 877         } else if (ratio > 0)
 878         {
 879                 skipmode = 0;
 880                 ffratio = ratio;
 881         } else if (!ratio)
 882         {
 883                 skipmode = 0;
 884                 ffratio = 0;
 885         } else // if (ratio < 0)
 886         {
 887                 skipmode = ratio;
 888                 ffratio = 1;
 889         }
 890
 891         if (m_skipmode != skipmode)
 892         {
 893                 eDebug("setting cue skipmode to %d", skipmode);
 894                 if (m_cue)
 895                         m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
 896         }
 897
 898         m_skipmode = skipmode;
 899
 900         if (!m_decoder)
 901                 return -1;
 902
 903         return m_decoder->setFastForward(ffratio);
 904 }
 905
 906 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
 907 {
 908         if (m_is_pvr || m_timeshift_enabled)
 909         {
 910                 ptr = this;
 911                 return 0;
 912         }
 913
 914         ptr = 0;
 915         return -1;
 916 }
 917
 918         /* TODO: when timeshift is enabled but not active, this doesn't work. */
 919 RESULT eDVBServicePlay::getLength(pts_t &len)
 920 {
 921         ePtr<iDVBPVRChannel> pvr_channel;
 922
 923         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 924                 return -1;
 925
 926         return pvr_channel->getLength(len);
 927 }
 928
 929 RESULT eDVBServicePlay::pause()
 930 {
 931         if (!m_is_paused && m_decoder)
 932         {
 933                 m_is_paused = 1;
 934                 return m_decoder->freeze(0);
 935         } else
 936                 return -1;
 937 }
 938
 939 RESULT eDVBServicePlay::unpause()
 940 {
 941         if (m_is_paused && m_decoder)
 942         {
 943                 m_is_paused = 0;
 944                 return m_decoder->unfreeze();
 945         } else
 946                 return -1;
 947 }
 948
 949 RESULT eDVBServicePlay::seekTo(pts_t to)
 950 {
 951         eDebug("eDVBServicePlay::seekTo: jump %lld", to);
 952
 953         if (!m_decode_demux)
 954                 return -1;
 955
 956         ePtr<iDVBPVRChannel> pvr_channel;
 957
 958         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 959                 return -1;
 960
 961         if (!m_cue)
 962                 return -1;
 963
 964         m_cue->seekTo(0, to);
 965         return 0;
 966 }
 967
 968 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
 969 {
 970         eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
 971
 972         if (!m_decode_demux)
 973                 return -1;
 974
 975         ePtr<iDVBPVRChannel> pvr_channel;
 976
 977         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 978                 return -1;
 979
 980         int mode = 1;
 981
 982                         /* HACK until we have skip-AP api */
 983         if ((to > 0) && (to < 100))
 984                 mode = 2;
 985
 986         to *= direction;
 987
 988         if (!m_cue)
 989                 return 0;
 990
 991         m_cue->seekTo(mode, to);
 992         return 0;
 993 }
 994
 995 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
 996 {
 997         ePtr<iDVBPVRChannel> pvr_channel;
 998
 999         if (!m_decode_demux)
1000                 return -1;
1001
1002         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1003                 return -1;
1004
1005         int r = 0;
1006
1007                 /* if there is a decoder, use audio or video PTS */
1008         if (m_decoder)
1009         {
1010                 r = m_decoder->getPTS(0, pos);
1011                 if (r)
1012                         return r;
1013         }
1014
1015                 /* fixup */
1016         return pvr_channel->getCurrentPosition(m_decode_demux, pos, m_decoder ? 1 : 0);
1017 }
1018
1019 RESULT eDVBServicePlay::setTrickmode(int trick)
1020 {
1021         if (m_decoder)
1022                 m_decoder->setTrickmode(trick);
1023         return 0;
1024 }
1025
1026 RESULT eDVBServicePlay::isCurrentlySeekable()
1027 {
1028         return m_is_pvr || m_timeshift_active;
1029 }
1030
1031 RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
1032 {
1033         ptr = this;
1034         return 0;
1035 }
1036
1037 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
1038 {
1039         ptr = this;
1040         return 0;
1041 }
1042
1043 RESULT eDVBServicePlay::audioChannel(ePtr<iAudioChannelSelection> &ptr)
1044 {
1045         ptr = this;
1046         return 0;
1047 }
1048
1049 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
1050 {
1051         ptr = this;
1052         return 0;
1053 }
1054
1055 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
1056 {
1057         ptr = this;
1058         return 0;
1059 }
1060
1061 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
1062 {
1063         ptr = 0;
1064         if (m_have_video_pid &&  // HACK !!! FIXMEE !! temporary no timeshift on radio services !!
1065                 (m_timeshift_enabled || !m_is_pvr))
1066         {
1067                 if (!m_timeshift_enabled)
1068                 {
1069                                 /* we need enough diskspace */
1070                         struct statfs fs;
1071                         if (statfs(TSPATH "/.", &fs) < 0)
1072                         {
1073                                 eDebug("statfs failed!");
1074                                 return -2;
1075                         }
1076
1077                         if (((off_t)fs.f_bavail) * ((off_t)fs.f_bsize) < 1024*1024*1024LL)
1078                         {
1079                                 eDebug("not enough diskspace for timeshift! (less than 1GB)");
1080                                 return -3;
1081                         }
1082                 }
1083                 ptr = this;
1084                 return 0;
1085         }
1086         return -1;
1087 }
1088
1089 RESULT eDVBServicePlay::cueSheet(ePtr<iCueSheet> &ptr)
1090 {
1091         if (m_is_pvr)
1092         {
1093                 ptr = this;
1094                 return 0;
1095         }
1096         ptr = 0;
1097         return -1;
1098 }
1099
1100 RESULT eDVBServicePlay::subtitle(ePtr<iSubtitleOutput> &ptr)
1101 {
1102         ptr = this;
1103         return 0;
1104 }
1105
1106 RESULT eDVBServicePlay::audioDelay(ePtr<iAudioDelay> &ptr)
1107 {
1108         ptr = this;
1109         return 0;
1110 }
1111
1112 RESULT eDVBServicePlay::radioText(ePtr<iRadioText> &ptr)
1113 {
1114         ptr = this;
1115         return 0;
1116 }
1117
1118 RESULT eDVBServicePlay::getName(std::string &name)
1119 {
1120         if (m_is_pvr)
1121         {
1122                 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
1123                 return i->getName(m_reference, name);
1124         }
1125         if (m_dvb_service)
1126         {
1127                 m_dvb_service->getName(m_reference, name);
1128                 if (name.empty())
1129                         name = "(...)";
1130         }
1131         else if (!m_reference.name.empty())
1132                 eStaticServiceDVBInformation().getName(m_reference, name);
1133         else
1134                 name = "DVB service";
1135         return 0;
1136 }
1137
1138 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
1139 {
1140         return m_event_handler.getEvent(evt, nownext);
1141 }
1142
1143 int eDVBServicePlay::getInfo(int w)
1144 {
1145         eDVBServicePMTHandler::program program;
1146
1147         if (w == sCAIDs)
1148                 return resIsPyObject;
1149
1150         if (m_service_handler.getProgramInfo(program))
1151                 return -1;
1152
1153         switch (w)
1154         {
1155         case sAspect:
1156                 if (!program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
1157                 {
1158                         ePtr<eServiceEvent> evt;
1159                         if (!m_event_handler.getEvent(evt, 0))
1160                         {
1161                                 ePtr<eComponentData> data;
1162                                 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
1163                                 {
1164                                         if ( data->getStreamContent() == 1 )
1165                                         {
1166                                                 switch(data->getComponentType())
1167                                                 {
1168                                                         // SD
1169                                                         case 1: // 4:3 SD PAL
1170                                                         case 2:
1171                                                         case 3: // 16:9 SD PAL
1172                                                         case 4: // > 16:9 PAL
1173                                                         case 5: // 4:3 SD NTSC
1174                                                         case 6:
1175                                                         case 7: // 16:9 SD NTSC
1176                                                         case 8: // > 16:9 NTSC
1177
1178                                                         // HD
1179                                                         case 9: // 4:3 HD PAL
1180                                                         case 0xA:
1181                                                         case 0xB: // 16:9 HD PAL
1182                                                         case 0xC: // > 16:9 HD PAL
1183                                                         case 0xD: // 4:3 HD NTSC
1184                                                         case 0xE:
1185                                                         case 0xF: // 16:9 HD NTSC
1186                                                         case 0x10: // > 16:9 HD PAL
1187                                                                 return data->getComponentType();
1188                                                 }
1189                                         }
1190                                 }
1191                         }
1192                 }
1193                 return -1;
1194         case sIsCrypted: return program.isCrypted();
1195         case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
1196         case sVideoType: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
1197         case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[m_current_audio_stream].pid;
1198         case sPCRPID: return program.pcrPid;
1199         case sPMTPID: return program.pmtPid;
1200         case sTXTPID: return program.textPid;
1201         case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
1202         case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
1203         case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
1204         case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
1205         case sProvider: if (!m_dvb_service) return -1; return -2;
1206         default:
1207                 return -1;
1208         }
1209 }
1210
1211 std::string eDVBServicePlay::getInfoString(int w)
1212 {
1213         switch (w)
1214         {
1215         case sProvider:
1216                 if (!m_dvb_service) return "";
1217                 return m_dvb_service->m_provider_name;
1218         default:
1219                 break;
1220         }
1221         return iServiceInformation::getInfoString(w);
1222 }
1223
1224 PyObject *eDVBServicePlay::getInfoObject(int w)
1225 {
1226         switch (w)
1227         {
1228         case sCAIDs:
1229                 return m_service_handler.getCaIds();
1230         default:
1231                 break;
1232         }
1233         return iServiceInformation::getInfoObject(w);
1234 }
1235
1236 int eDVBServicePlay::getNumberOfTracks()
1237 {
1238         eDVBServicePMTHandler::program program;
1239         if (m_service_handler.getProgramInfo(program))
1240                 return 0;
1241         return program.audioStreams.size();
1242 }
1243
1244 RESULT eDVBServicePlay::selectTrack(unsigned int i)
1245 {
1246         int ret = selectAudioStream(i);
1247
1248         if (m_decoder->start())
1249                 return -5;
1250
1251         return ret;
1252 }
1253
1254 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
1255 {
1256         eDVBServicePMTHandler::program program;
1257
1258         if (m_service_handler.getProgramInfo(program))
1259                 return -1;
1260
1261         if (i >= program.audioStreams.size())
1262                 return -2;
1263
1264         if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
1265                 info.m_description = "MPEG";
1266         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
1267                 info.m_description = "AC3";
1268         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
1269                 info.m_description = "AAC";
1270         else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
1271                 info.m_description = "DTS";
1272         else
1273                 info.m_description = "???";
1274
1275         if (program.audioStreams[i].component_tag != -1)
1276         {
1277                 ePtr<eServiceEvent> evt;
1278                 if (!m_event_handler.getEvent(evt, 0))
1279                 {
1280                         ePtr<eComponentData> data;
1281                         if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
1282                                 info.m_language = data->getText();
1283                 }
1284         }
1285
1286         if (info.m_language.empty())
1287                 info.m_language = program.audioStreams[i].language_code;
1288
1289         return 0;
1290 }
1291
1292 int eDVBServicePlay::selectAudioStream(int i)
1293 {
1294         eDVBServicePMTHandler::program program;
1295
1296         if (m_service_handler.getProgramInfo(program))
1297                 return -1;
1298
1299         if ((unsigned int)i >= program.audioStreams.size())
1300                 return -2;
1301
1302         if (!m_decoder)
1303                 return -3;
1304
1305         if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type))
1306                 return -4;
1307
1308         if (m_radiotext_parser)
1309                 m_radiotext_parser->start(program.audioStreams[i].pid);
1310
1311         if (m_dvb_service && !m_is_pvr)
1312         {
1313                 if (program.audioStreams[i].type == eDVBAudio::aMPEG)
1314                 {
1315                         m_dvb_service->setCacheEntry(eDVBService::cAPID, program.audioStreams[i].pid);
1316                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1317                 }
1318                 else
1319                 {
1320                         m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1321                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, program.audioStreams[i].pid);
1322                 }
1323         }
1324
1325         m_current_audio_stream = i;
1326
1327         return 0;
1328 }
1329
1330 int eDVBServicePlay::getCurrentChannel()
1331 {
1332         return m_decoder ? m_decoder->getAudioChannel() : STEREO;
1333 }
1334
1335 RESULT eDVBServicePlay::selectChannel(int i)
1336 {
1337         if (i < LEFT || i > RIGHT || i == STEREO)
1338                 i = -1;  // Stereo
1339         if (m_dvb_service)
1340                 m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i);
1341         if (m_decoder)
1342                 m_decoder->setAudioChannel(i);
1343         return 0;
1344 }
1345
1346 std::string eDVBServicePlay::getRadioText(int x)
1347 {
1348         if (m_radiotext_parser)
1349                 switch(x)
1350                 {
1351                         case 0:
1352                                 return m_radiotext_parser->getCurrentText();
1353                 }
1354         return "";
1355 }
1356
1357 void eDVBServicePlay::radioTextUpdated()
1358 {
1359         m_event((iPlayableService*)this, evUpdatedRadioText);
1360 }
1361
1362 int eDVBServiceBase::getFrontendInfo(int w)
1363 {
1364         eUsePtr<iDVBChannel> channel;
1365         if(m_service_handler.getChannel(channel))
1366                 return 0;
1367         ePtr<iDVBFrontend> fe;
1368         if(channel->getFrontend(fe))
1369                 return 0;
1370         return fe->readFrontendData(w);
1371 }
1372
1373 PyObject *eDVBServiceBase::getFrontendData(bool original)
1374 {
1375         PyObject *ret=0;
1376
1377         eUsePtr<iDVBChannel> channel;
1378         if(!m_service_handler.getChannel(channel))
1379         {
1380                 ePtr<iDVBFrontend> fe;
1381                 if(!channel->getFrontend(fe))
1382                 {
1383                         ret = fe->readTransponderData(original);
1384                         if (ret)
1385                         {
1386                                 ePtr<iDVBFrontendParameters> feparm;
1387                                 channel->getCurrentFrontendParameters(feparm);
1388                                 if (feparm)
1389                                 {
1390                                         eDVBFrontendParametersSatellite osat;
1391                                         if (!feparm->getDVBS(osat))
1392                                         {
1393                                                 void PutToDict(PyObject *, const char*, long);
1394                                                 void PutToDict(PyObject *, const char*, const char*);
1395                                                 PutToDict(ret, "orbital_position", osat.orbital_position);
1396                                                 const char *tmp = "UNKNOWN";
1397                                                 switch(osat.polarisation)
1398                                                 {
1399                                                         case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break;
1400                                                         case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break;
1401                                                         case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR_LEFT"; break;
1402                                                         case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR_RIGHT"; break;
1403                                                         default:break;
1404                                                 }
1405                                                 PutToDict(ret, "polarization", tmp);
1406                                         }
1407                                 }
1408                         }
1409                 }
1410         }
1411         if (!ret)
1412         {
1413                 ret = Py_None;
1414                 Py_INCREF(ret);
1415         }
1416         return ret;
1417 }
1418
1419 int eDVBServicePlay::getNumberOfSubservices()
1420 {
1421         ePtr<eServiceEvent> evt;
1422         if (!m_event_handler.getEvent(evt, 0))
1423                 return evt->getNumOfLinkageServices();
1424         return 0;
1425 }
1426
1427 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
1428 {
1429         ePtr<eServiceEvent> evt;
1430         if (!m_event_handler.getEvent(evt, 0))
1431         {
1432                 if (!evt->getLinkageService(sub, m_reference, n))
1433                         return 0;
1434         }
1435         sub.type=eServiceReference::idInvalid;
1436         return -1;
1437 }
1438
1439 RESULT eDVBServicePlay::startTimeshift()
1440 {
1441         ePtr<iDVBDemux> demux;
1442
1443         eDebug("Start timeshift!");
1444
1445         if (m_timeshift_enabled)
1446                 return -1;
1447
1448                 /* start recording with the data demux. */
1449         if (m_service_handler.getDataDemux(demux))
1450                 return -2;
1451
1452         demux->createTSRecorder(m_record);
1453         if (!m_record)
1454                 return -3;
1455
1456         char templ[]=TSPATH "/timeshift.XXXXXX";
1457         m_timeshift_fd = mkstemp(templ);
1458         m_timeshift_file = templ;
1459
1460         eDebug("recording to %s", templ);
1461
1462         if (m_timeshift_fd < 0)
1463         {
1464                 m_record = 0;
1465                 return -4;
1466         }
1467
1468         m_record->setTargetFD(m_timeshift_fd);
1469
1470         m_timeshift_enabled = 1;
1471
1472         updateTimeshiftPids();
1473         m_record->start();
1474
1475         return 0;
1476 }
1477
1478 RESULT eDVBServicePlay::stopTimeshift()
1479 {
1480         if (!m_timeshift_enabled)
1481                 return -1;
1482
1483         switchToLive();
1484
1485         m_timeshift_enabled = 0;
1486
1487         m_record->stop();
1488         m_record = 0;
1489
1490         close(m_timeshift_fd);
1491         eDebug("remove timeshift file");
1492         remove(m_timeshift_file.c_str());
1493
1494         return 0;
1495 }
1496
1497 int eDVBServicePlay::isTimeshiftActive()
1498 {
1499         return m_timeshift_enabled && m_timeshift_active;
1500 }
1501
1502 RESULT eDVBServicePlay::activateTimeshift()
1503 {
1504         if (!m_timeshift_enabled)
1505                 return -1;
1506
1507         if (!m_timeshift_active)
1508         {
1509                 switchToTimeshift();
1510                 return 0;
1511         }
1512
1513         return -2;
1514 }
1515
1516 PyObject *eDVBServicePlay::getCutList()
1517 {
1518         PyObject *list = PyList_New(0);
1519
1520         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
1521         {
1522                 PyObject *tuple = PyTuple_New(2);
1523                 PyTuple_SetItem(tuple, 0, PyLong_FromLongLong(i->where));
1524                 PyTuple_SetItem(tuple, 1, PyInt_FromLong(i->what));
1525                 PyList_Append(list, tuple);
1526                 Py_DECREF(tuple);
1527         }
1528
1529         return list;
1530 }
1531
1532 void eDVBServicePlay::setCutList(PyObject *list)
1533 {
1534         if (!PyList_Check(list))
1535                 return;
1536         int size = PyList_Size(list);
1537         int i;
1538
1539         m_cue_entries.clear();
1540
1541         for (i=0; i<size; ++i)
1542         {
1543                 PyObject *tuple = PyList_GetItem(list, i);
1544                 if (!PyTuple_Check(tuple))
1545                 {
1546                         eDebug("non-tuple in cutlist");
1547                         continue;
1548                 }
1549                 if (PyTuple_Size(tuple) != 2)
1550                 {
1551                         eDebug("cutlist entries need to be a 2-tuple");
1552                         continue;
1553                 }
1554                 PyObject *ppts = PyTuple_GetItem(tuple, 0), *ptype = PyTuple_GetItem(tuple, 1);
1555                 if (!(PyLong_Check(ppts) && PyInt_Check(ptype)))
1556                 {
1557                         eDebug("cutlist entries need to be (pts, type)-tuples (%d %d)", PyLong_Check(ppts), PyInt_Check(ptype));
1558                         continue;
1559                 }
1560                 pts_t pts = PyLong_AsLongLong(ppts);
1561                 int type = PyInt_AsLong(ptype);
1562                 m_cue_entries.insert(cueEntry(pts, type));
1563                 eDebug("adding %08llx, %d", pts, type);
1564         }
1565         m_cuesheet_changed = 1;
1566
1567         cutlistToCuesheet();
1568         m_event((iPlayableService*)this, evCuesheetChanged);
1569 }
1570
1571 void eDVBServicePlay::setCutListEnable(int enable)
1572 {
1573         m_cutlist_enabled = enable;
1574         cutlistToCuesheet();
1575 }
1576
1577 void eDVBServicePlay::updateTimeshiftPids()
1578 {
1579         if (!m_record)
1580                 return;
1581
1582         eDVBServicePMTHandler::program program;
1583         if (m_service_handler.getProgramInfo(program))
1584                 return;
1585         else
1586         {
1587                 std::set<int> pids_to_record;
1588                 pids_to_record.insert(0); // PAT
1589                 if (program.pmtPid != -1)
1590                         pids_to_record.insert(program.pmtPid); // PMT
1591
1592                 if (program.textPid != -1)
1593                         pids_to_record.insert(program.textPid); // Videotext
1594
1595                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1596                         i(program.videoStreams.begin());
1597                         i != program.videoStreams.end(); ++i)
1598                         pids_to_record.insert(i->pid);
1599
1600                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1601                         i(program.audioStreams.begin());
1602                         i != program.audioStreams.end(); ++i)
1603                                 pids_to_record.insert(i->pid);
1604
1605                 std::set<int> new_pids, obsolete_pids;
1606
1607                 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
1608                                 m_pids_active.begin(), m_pids_active.end(),
1609                                 std::inserter(new_pids, new_pids.begin()));
1610
1611                 std::set_difference(
1612                                 m_pids_active.begin(), m_pids_active.end(),
1613                                 pids_to_record.begin(), pids_to_record.end(),
1614                                 std::inserter(new_pids, new_pids.begin())
1615                                 );
1616
1617                 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
1618                         m_record->addPID(*i);
1619
1620                 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
1621                         m_record->removePID(*i);
1622         }
1623 }
1624
1625 void eDVBServicePlay::switchToLive()
1626 {
1627         if (!m_timeshift_active)
1628                 return;
1629
1630         m_cue = 0;
1631         m_decoder = 0;
1632         m_decode_demux = 0;
1633         m_teletext_parser = 0;
1634         m_radiotext_parser = 0;
1635         m_new_subtitle_page_connection = 0;
1636         m_radiotext_updated_connection = 0;
1637
1638                 /* free the timeshift service handler, we need the resources */
1639         m_service_handler_timeshift.free();
1640         m_timeshift_active = 0;
1641
1642         m_event((iPlayableService*)this, evSeekableStatusChanged);
1643
1644         updateDecoder();
1645 }
1646
1647 void eDVBServicePlay::switchToTimeshift()
1648 {
1649         if (m_timeshift_active)
1650                 return;
1651
1652         m_decode_demux = 0;
1653         m_decoder = 0;
1654         m_teletext_parser = 0;
1655         m_radiotext_parser = 0;
1656         m_new_subtitle_page_connection = 0;
1657         m_radiotext_updated_connection = 0;
1658
1659         m_timeshift_active = 1;
1660
1661         m_event((iPlayableService*)this, evSeekableStatusChanged);
1662
1663         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1664         r.path = m_timeshift_file;
1665
1666         m_cue = new eCueSheet();
1667         m_service_handler_timeshift.tune(r, 1, m_cue); /* use the decoder demux for everything */
1668         updateDecoder(); /* mainly to switch off PCR */
1669 }
1670
1671 void eDVBServicePlay::updateDecoder()
1672 {
1673         int vpid = -1, vpidtype = -1, apid = -1, apidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
1674
1675         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1676
1677         bool defaultac3=false;
1678         std::string default_ac3;
1679
1680         if (!ePythonConfigQuery::getConfigValue("config.av.defaultac3", default_ac3))
1681                 defaultac3 = default_ac3 == "enable";
1682
1683         eDVBServicePMTHandler::program program;
1684         if (h.getProgramInfo(program))
1685                 eDebug("getting program info failed.");
1686         else
1687         {
1688                 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
1689                 if (!program.videoStreams.empty())
1690                 {
1691                         eDebugNoNewLine(" (");
1692                         for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1693                                 i(program.videoStreams.begin());
1694                                 i != program.videoStreams.end(); ++i)
1695                         {
1696                                 if (vpid == -1)
1697                                 {
1698                                         vpid = i->pid;
1699                                         vpidtype = i->type;
1700                                 }
1701                                 if (i != program.videoStreams.begin())
1702                                         eDebugNoNewLine(", ");
1703                                 eDebugNoNewLine("%04x", i->pid);
1704                         }
1705                         eDebugNoNewLine(")");
1706                 }
1707                 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
1708                 if (!program.audioStreams.empty())
1709                 {
1710                         eDebugNoNewLine(" (");
1711                         for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1712                                 i(program.audioStreams.begin());
1713                                 i != program.audioStreams.end(); ++i)
1714                         {
1715                                 if (apid == -1 || (apidtype == eDVBAudio::aMPEG && defaultac3))
1716                                 {
1717                                         if ( apid == -1 || (i->type != eDVBAudio::aMPEG) )
1718                                         {
1719                                                 apid = i->pid;
1720                                                 apidtype = i->type;
1721                                         }
1722                                 }
1723                                 if (i != program.audioStreams.begin())
1724                                         eDebugNoNewLine(", ");
1725                                 eDebugNoNewLine("%04x", i->pid);
1726                         }
1727                         eDebugNoNewLine(")");
1728                 }
1729                 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
1730                 pcrpid = program.pcrPid;
1731                 eDebug(", and the text pid is %04x", program.textPid);
1732                 tpid = program.textPid;
1733         }
1734
1735         if (!m_decoder)
1736         {
1737                 h.getDecodeDemux(m_decode_demux);
1738                 if (m_decode_demux)
1739                         m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
1740                 if (m_cue)
1741                         m_cue->setDecodingDemux(m_decode_demux, m_decoder);
1742 #ifdef INTERNAL_TELETEXT
1743                 m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
1744                 m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
1745 #endif
1746         }
1747
1748         if (m_decoder)
1749         {
1750                 if (m_dvb_service)
1751                 {
1752                         achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
1753                         ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
1754                         pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
1755                 }
1756                 else // subservice or recording
1757                 {
1758                         eServiceReferenceDVB ref;
1759                         m_service_handler.getServiceReference(ref);
1760                         eServiceReferenceDVB parent = ref.getParentServiceReference();
1761                         if (!parent)
1762                                 parent = ref;
1763                         if (parent)
1764                         {
1765                                 ePtr<eDVBResourceManager> res_mgr;
1766                                 if (!eDVBResourceManager::getInstance(res_mgr))
1767                                 {
1768                                         ePtr<iDVBChannelList> db;
1769                                         if (!res_mgr->getChannelList(db))
1770                                         {
1771                                                 ePtr<eDVBService> origService;
1772                                                 if (!db->getService(parent, origService))
1773                                                 {
1774                                                         ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY);
1775                                                         pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY);
1776                                                 }
1777                                         }
1778                                 }
1779                         }
1780                 }
1781                 m_decoder->setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
1782                 m_decoder->setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
1783
1784                 m_decoder->setVideoPID(vpid, vpidtype);
1785                 m_current_audio_stream = 0;
1786                 m_decoder->setAudioPID(apid, apidtype);
1787                 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
1788                 {
1789                         m_decoder->setSyncPCR(pcrpid);
1790                         if (apid != -1)
1791                         {
1792                                 ePtr<iDVBDemux> data_demux;
1793                                 if (!h.getDataDemux(data_demux))
1794                                 {
1795                                         m_radiotext_parser = new eDVBRadioTextParser(data_demux);
1796                                         m_radiotext_parser->connectUpdatedRadiotext(slot(*this, &eDVBServicePlay::radioTextUpdated), m_radiotext_updated_connection);
1797                                         m_radiotext_parser->start(apid);
1798                                 }
1799                         }
1800                 }
1801                 else
1802                         m_decoder->setSyncPCR(-1);
1803
1804                 m_decoder->setTextPID(tpid);
1805
1806                 if (m_teletext_parser)
1807                         m_teletext_parser->start(tpid);
1808
1809                 if (!m_is_primary)
1810                         m_decoder->setTrickmode(1);
1811
1812                 m_decoder->start();
1813
1814                 if (vpid > 0 && vpid < 0x2000)
1815                         ;
1816                 else
1817                 {
1818                         std::string radio_pic;
1819                         if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic))
1820                                 m_decoder->setRadioPic(radio_pic);
1821                 }
1822
1823                 m_decoder->setAudioChannel(achannel);
1824
1825 // how we can do this better?
1826 // update cache pid when the user changed the audio track or video track
1827 // TODO handling of difference audio types.. default audio types..
1828
1829                 /* don't worry about non-existing services, nor pvr services */
1830                 if (m_dvb_service && !m_is_pvr)
1831                 {
1832                         if (apidtype == eDVBAudio::aMPEG)
1833                         {
1834                                 m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
1835                                 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1836                         }
1837                         else
1838                         {
1839                                 m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1840                                 m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
1841                         }
1842                         m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
1843                         m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype);
1844                         m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
1845                         m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
1846                 }
1847         }
1848         m_have_video_pid = (vpid > 0 && vpid < 0x2000);
1849 }
1850
1851 void eDVBServicePlay::loadCuesheet()
1852 {
1853         std::string filename = m_reference.path + ".cuts";
1854
1855         m_cue_entries.clear();
1856
1857         FILE *f = fopen(filename.c_str(), "rb");
1858
1859         if (f)
1860         {
1861                 eDebug("loading cuts..");
1862                 while (1)
1863                 {
1864                         unsigned long long where;
1865                         unsigned int what;
1866
1867                         if (!fread(&where, sizeof(where), 1, f))
1868                                 break;
1869                         if (!fread(&what, sizeof(what), 1, f))
1870                                 break;
1871
1872 #if BYTE_ORDER == LITTLE_ENDIAN
1873                         where = bswap_64(where);
1874 #endif
1875                         what = ntohl(what);
1876
1877                         if (what > 3)
1878                                 break;
1879
1880                         m_cue_entries.insert(cueEntry(where, what));
1881                 }
1882                 fclose(f);
1883                 eDebug("%d entries", m_cue_entries.size());
1884         } else
1885                 eDebug("cutfile not found!");
1886
1887         m_cuesheet_changed = 0;
1888         cutlistToCuesheet();
1889         m_event((iPlayableService*)this, evCuesheetChanged);
1890 }
1891
1892 void eDVBServicePlay::saveCuesheet()
1893 {
1894         std::string filename = m_reference.path + ".cuts";
1895
1896         FILE *f = fopen(filename.c_str(), "wb");
1897
1898         if (f)
1899         {
1900                 unsigned long long where;
1901                 int what;
1902
1903                 for (std::multiset<cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
1904                 {
1905 #if BYTE_ORDER == BIG_ENDIAN
1906                         where = i->where;
1907 #else
1908                         where = bswap_64(i->where);
1909 #endif
1910                         what = htonl(i->what);
1911                         fwrite(&where, sizeof(where), 1, f);
1912                         fwrite(&what, sizeof(what), 1, f);
1913
1914                 }
1915                 fclose(f);
1916         }
1917
1918         m_cuesheet_changed = 0;
1919 }
1920
1921 void eDVBServicePlay::cutlistToCuesheet()
1922 {
1923         if (!m_cue)
1924         {
1925                 eDebug("no cue sheet");
1926                 return;
1927         }
1928         m_cue->clear();
1929
1930         if (!m_cutlist_enabled)
1931         {
1932                 m_cue->commitSpans();
1933                 eDebug("cutlists were disabled");
1934                 return;
1935         }
1936
1937         pts_t in = 0, out = 0, length = 0;
1938
1939         getLength(length);
1940
1941         std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
1942
1943         while (1)
1944         {
1945                 if (i == m_cue_entries.end())
1946                         out = length;
1947                 else {
1948                         if (i->what == 0) /* in */
1949                         {
1950                                 in = i++->where;
1951                                 continue;
1952                         } else if (i->what == 1) /* out */
1953                                 out = i++->where;
1954                         else /* mark (2) or last play position (3) */
1955                         {
1956                                 i++;
1957                                 continue;
1958                         }
1959                 }
1960
1961                 if (in != out)
1962                         m_cue->addSourceSpan(in, out);
1963
1964                 in = length;
1965
1966                 if (i == m_cue_entries.end())
1967                         break;
1968         }
1969         m_cue->commitSpans();
1970 }
1971
1972 RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, PyObject *entry)
1973 {
1974         if (m_subtitle_widget)
1975                 disableSubtitles(parent);
1976
1977         if (!m_teletext_parser)
1978                 return -1;
1979
1980         if (!PyInt_Check(entry))
1981                 return -1;
1982
1983         m_subtitle_widget = new eSubtitleWidget(parent);
1984         m_subtitle_widget->resize(parent->size()); /* full size */
1985
1986         int page = PyInt_AsLong(entry);
1987
1988         m_teletext_parser->setPage(page);
1989
1990         return 0;
1991 }
1992
1993 RESULT eDVBServicePlay::disableSubtitles(eWidget *parent)
1994 {
1995         delete m_subtitle_widget;
1996         m_subtitle_widget = 0;
1997         return 0;
1998 }
1999
2000 PyObject *eDVBServicePlay::getSubtitleList()
2001 {
2002         if (!m_teletext_parser)
2003         {
2004                 Py_INCREF(Py_None);
2005                 return Py_None;
2006         }
2007
2008         PyObject *l = PyList_New(0);
2009
2010         for (std::set<int>::iterator i(m_teletext_parser->m_found_subtitle_pages.begin()); i != m_teletext_parser->m_found_subtitle_pages.end(); ++i)
2011         {
2012                 PyObject *tuple = PyTuple_New(2);
2013                 char desc[20];
2014                 sprintf(desc, "Page %x", *i);
2015                 PyTuple_SetItem(tuple, 0, PyString_FromString(desc));
2016                 PyTuple_SetItem(tuple, 1, PyInt_FromLong(*i));
2017                 PyList_Append(l, tuple);
2018         }
2019
2020         return l;
2021 }
2022
2023 void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
2024 {
2025         if (m_subtitle_widget)
2026         {
2027                 m_subtitle_pages.push_back(page);
2028
2029                 checkSubtitleTiming();
2030         }
2031 }
2032
2033 void eDVBServicePlay::checkSubtitleTiming()
2034 {
2035         while (1)
2036         {
2037                 if (m_subtitle_pages.empty())
2038                         return;
2039
2040                 eDVBTeletextSubtitlePage p = m_subtitle_pages.front();
2041
2042                 pts_t pos = 0;
2043
2044                 if (m_decoder)
2045                         m_decoder->getPTS(0, pos);
2046
2047                 int diff = p.m_pts - pos;
2048                 if (diff < 0)
2049                 {
2050                         eDebug("[late (%d ms)]", -diff / 90);
2051                         diff = 0;
2052                 }
2053                 if (diff > 900000)
2054                 {
2055                         eDebug("[invalid]");
2056                         diff = 0;
2057                 }
2058
2059                 if (!diff)
2060                 {
2061                         m_subtitle_widget->setPage(p);
2062                         m_subtitle_pages.pop_front();
2063                 } else
2064                 {
2065                         m_subtitle_sync_timer.start(diff / 90, 1);
2066                         break;
2067                 }
2068         }
2069 }
2070
2071 int eDVBServicePlay::getAC3Delay()
2072 {
2073         if (m_dvb_service)
2074                 return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2075         else if (m_decoder)
2076                 return m_decoder->getAC3Delay();
2077         else
2078                 return 0;
2079 }
2080
2081 int eDVBServicePlay::getPCMDelay()
2082 {
2083         if (m_dvb_service)
2084                 return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2085         else if (m_decoder)
2086                 return m_decoder->getPCMDelay();
2087         else
2088                 return 0;
2089 }
2090
2091 void eDVBServicePlay::setAC3Delay(int delay)
2092 {
2093         if (m_dvb_service)
2094                 m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
2095         if (m_decoder)
2096                 m_decoder->setAC3Delay(delay);
2097 }
2098
2099 void eDVBServicePlay::setPCMDelay(int delay)
2100 {
2101         if (m_dvb_service)
2102                 m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
2103         if (m_decoder)
2104                 m_decoder->setPCMDelay(delay);
2105 }
2106
2107 DEFINE_REF(eDVBServicePlay)
2108
2109 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");