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