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/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 #include <lib/base/nconfig.h> // access to python config
  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 class eStaticServiceDVBInformation: public iStaticServiceInformation
  35 {
  36         DECLARE_REF(eStaticServiceDVBInformation);
  37 public:
  38         RESULT getName(const eServiceReference &ref, std::string &name);
  39         int getLength(const eServiceReference &ref);
  40         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore);
  41         PyObject *getInfoObject(const eServiceReference &ref, int);
  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                                                 name=buildShortName(name) + " - ";
  67                                 }
  68                         }
  69                 }
  70                 else
  71                         name="";
  72                 name += ref.name;
  73                 return 0;
  74         }
  75         else
  76                 return -1;
  77 }
  78
  79 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
  80 {
  81         return -1;
  82 }
  83
  84 int eStaticServiceDVBInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
  85 {
  86         ePtr<eDVBResourceManager> res_mgr;
  87         if ( eDVBResourceManager::getInstance( res_mgr ) )
  88                 eDebug("isPlayable... no res manager!!");
  89         else
  90         {
  91                 eDVBChannelID chid, chid_ignore;
  92                 ((const eServiceReferenceDVB&)ref).getChannelID(chid);
  93                 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
  94                 return res_mgr->canAllocateChannel(chid, chid_ignore);
  95         }
  96         return false;
  97 }
  98
  99 extern void PutToDict(ePyObject &dict, const char*key, long value);  // defined in dvb/frontend.cpp
 100 extern void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &feparm); // defined in dvb/frontend.cpp
 101 extern void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial &feparm); // defined in dvb/frontend.cpp
 102 extern void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm); // defined in dvb/frontend.cpp
 103
 104 PyObject *eStaticServiceDVBInformation::getInfoObject(const eServiceReference &r, int what)
 105 {
 106         if (r.type == eServiceReference::idDVB)
 107         {
 108                 const eServiceReferenceDVB &ref = (const eServiceReferenceDVB&)r;
 109                 switch(what)
 110                 {
 111                         case iServiceInformation::sTransponderData:
 112                         {
 113                                 ePtr<eDVBResourceManager> res;
 114                                 if (!eDVBResourceManager::getInstance(res))
 115                                 {
 116                                         ePtr<iDVBChannelList> db;
 117                                         if (!res->getChannelList(db))
 118                                         {
 119                                                 eDVBChannelID chid;
 120                                                 ref.getChannelID(chid);
 121                                                 ePtr<iDVBFrontendParameters> feparm;
 122                                                 if (!db->getChannelFrontendData(chid, feparm))
 123                                                 {
 124                                                         int system;
 125                                                         if (!feparm->getSystem(system))
 126                                                         {
 127                                                                 ePyObject dict = PyDict_New();
 128                                                                 switch(system)
 129                                                                 {
 130                                                                         case iDVBFrontend::feSatellite:
 131                                                                         {
 132                                                                                 eDVBFrontendParametersSatellite s;
 133                                                                                 feparm->getDVBS(s);
 134                                                                                 PutSatelliteDataToDict(dict, s);
 135                                                                                 break;
 136                                                                         }
 137                                                                         case iDVBFrontend::feTerrestrial:
 138                                                                         {
 139                                                                                 eDVBFrontendParametersTerrestrial t;
 140                                                                                 feparm->getDVBT(t);
 141                                                                                 PutTerrestrialDataToDict(dict, t);
 142                                                                                 break;
 143                                                                         }
 144                                                                         case iDVBFrontend::feCable:
 145                                                                         {
 146                                                                                 eDVBFrontendParametersCable c;
 147                                                                                 feparm->getDVBC(c);
 148                                                                                 PutCableDataToDict(dict, c);
 149                                                                                 break;
 150                                                                         }
 151                                                                         default:
 152                                                                                 eDebug("unknown frontend type %d", system);
 153                                                                                 Py_DECREF(dict);
 154                                                                                 break;
 155                                                                 }
 156                                                                 return dict;
 157                                                         }
 158                                                 }
 159                                         }
 160                                 }
 161                         }
 162                 }
 163         }
 164         Py_RETURN_NONE;
 165 }
 166
 167 DEFINE_REF(eStaticServiceDVBBouquetInformation);
 168
 169 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
 170 {
 171         ePtr<iDVBChannelList> db;
 172         ePtr<eDVBResourceManager> res;
 173
 174         int err;
 175         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 176         {
 177                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
 178                 return err;
 179         }
 180         if ((err = res->getChannelList(db)) != 0)
 181         {
 182                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
 183                 return err;
 184         }
 185
 186         eBouquet *bouquet=0;
 187         if ((err = db->getBouquet(ref, bouquet)) != 0)
 188         {
 189                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
 190                 return -1;
 191         }
 192
 193         if ( bouquet && bouquet->m_bouquet_name.length() )
 194         {
 195                 name = bouquet->m_bouquet_name;
 196                 return 0;
 197         }
 198         else
 199                 return -1;
 200 }
 201
 202 int eStaticServiceDVBBouquetInformation::isPlayable(const eServiceReference &ref, const eServiceReference &ignore, bool simulate)
 203 {
 204         if (ref.flags & eServiceReference::isGroup)
 205         {
 206                 ePtr<iDVBChannelList> db;
 207                 ePtr<eDVBResourceManager> res;
 208
 209                 if (eDVBResourceManager::getInstance(res))
 210                 {
 211                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no resource manager!");
 212                         return 0;
 213                 }
 214
 215                 if (res->getChannelList(db))
 216                 {
 217                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. no channel list!");
 218                         return 0;
 219                 }
 220
 221                 eBouquet *bouquet=0;
 222                 if (db->getBouquet(ref, bouquet))
 223                 {
 224                         eDebug("eStaticServiceDVBBouquetInformation::isPlayable failed.. getBouquet failed!");
 225                         return 0;
 226                 }
 227
 228                 int prio_order = eDVBFrontend::getTypePriorityOrder();
 229                 int cur=0;
 230                 eDVBChannelID chid, chid_ignore;
 231                 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
 232                 for (std::list<eServiceReference>::iterator it(bouquet->m_services.begin()); it != bouquet->m_services.end(); ++it)
 233                 {
 234                         static unsigned char prio_map[6][3] = {
 235                                 { 3, 2, 1 }, // -S -C -T
 236                                 { 3, 1, 2 }, // -S -T -C
 237                                 { 2, 3, 1 }, // -C -S -T
 238                                 { 1, 3, 2 }, // -C -T -S
 239                                 { 1, 2, 3 }, // -T -C -S
 240                                 { 2, 1, 3 }  // -T -S -C
 241                         };
 242                         ((const eServiceReferenceDVB&)*it).getChannelID(chid);
 243                         int tmp=res->canAllocateChannel(chid, chid_ignore, simulate);
 244                         switch(tmp)
 245                         {
 246                                 case 0:
 247                                         break;
 248                                 case 30000: // cached DVB-T channel
 249                                 case 1: // DVB-T frontend
 250                                         tmp = prio_map[prio_order][2];
 251                                         break;
 252                                 case 40000: // cached DVB-C channel
 253                                 case 2:
 254                                         tmp = prio_map[prio_order][1];
 255                                         break;
 256                                 default: // DVB-S
 257                                         tmp = prio_map[prio_order][0];
 258                                         break;
 259                         }
 260                         if (tmp > cur)
 261                         {
 262                                 m_playable_service = *it;
 263                                 cur = tmp;
 264                         }
 265                 }
 266                 if (cur)
 267                         return cur;
 268         }
 269         m_playable_service = eServiceReference();
 270         return 0;
 271 }
 272
 273 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
 274 {
 275         return -1;
 276 }
 277
 278 #include <lib/dvb/epgcache.h>
 279
 280 RESULT eStaticServiceDVBBouquetInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time)
 281 {
 282         return eEPGCache::getInstance()->lookupEventTime(ref, start_time, ptr);
 283 }
 284
 285 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
 286 {
 287         DECLARE_REF(eStaticServiceDVBPVRInformation);
 288         eServiceReference m_ref;
 289         eDVBMetaParser m_parser;
 290 public:
 291         eStaticServiceDVBPVRInformation(const eServiceReference &ref);
 292         RESULT getName(const eServiceReference &ref, std::string &name);
 293         int getLength(const eServiceReference &ref);
 294         RESULT getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &SWIG_OUTPUT, time_t start_time);
 295         int isPlayable(const eServiceReference &ref, const eServiceReference &ignore) { return 1; }
 296         int getInfo(const eServiceReference &ref, int w);
 297         std::string getInfoString(const eServiceReference &ref,int w);
 298         PyObject *getInfoObject(const eServiceReference &r, int what);
 299 };
 300
 301 DEFINE_REF(eStaticServiceDVBPVRInformation);
 302
 303 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
 304 {
 305         m_ref = ref;
 306         m_parser.parseFile(ref.path);
 307 }
 308
 309 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
 310 {
 311         ASSERT(ref == m_ref);
 312         if (m_parser.m_name.size())
 313                 name = m_parser.m_name;
 314         else
 315         {
 316                 name = ref.path;
 317                 size_t n = name.rfind('/');
 318                 if (n != std::string::npos)
 319                         name = name.substr(n + 1);
 320         }
 321         return 0;
 322 }
 323
 324 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
 325 {
 326         ASSERT(ref == m_ref);
 327
 328         eDVBTSTools tstools;
 329
 330         struct stat s;
 331         stat(ref.path.c_str(), &s);
 332
 333         if (tstools.openFile(ref.path.c_str(), 1))
 334                 return 0;
 335
 336                         /* check if cached data is still valid */
 337         if (m_parser.m_data_ok && (s.st_size == m_parser.m_filesize) && (m_parser.m_length))
 338                 return m_parser.m_length / 90000;
 339
 340                         /* open again, this time with stream info */
 341         if (tstools.openFile(ref.path.c_str()))
 342                 return 0;
 343
 344                         /* otherwise, re-calc length and update meta file */
 345         pts_t len;
 346         if (tstools.calcLen(len))
 347                 return 0;
 348
 349         m_parser.m_length = len;
 350         m_parser.m_filesize = s.st_size;
 351         m_parser.updateMeta(ref.path);
 352         return m_parser.m_length / 90000;
 353 }
 354
 355 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
 356 {
 357         switch (w)
 358         {
 359         case iServiceInformation::sDescription:
 360                 return iServiceInformation::resIsString;
 361         case iServiceInformation::sServiceref:
 362                 return iServiceInformation::resIsString;
 363         case iServiceInformation::sFileSize:
 364                 return m_parser.m_filesize;
 365         case iServiceInformation::sTimeCreate:
 366                 if (m_parser.m_time_create)
 367                         return m_parser.m_time_create;
 368                 else
 369                         return iServiceInformation::resNA;
 370         default:
 371                 return iServiceInformation::resNA;
 372         }
 373 }
 374
 375 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
 376 {
 377         switch (w)
 378         {
 379         case iServiceInformation::sDescription:
 380                 return m_parser.m_description;
 381         case iServiceInformation::sServiceref:
 382                 return m_parser.m_ref.toString();
 383         case iServiceInformation::sTags:
 384                 return m_parser.m_tags;
 385         default:
 386                 return "";
 387         }
 388 }
 389
 390 PyObject *eStaticServiceDVBPVRInformation::getInfoObject(const eServiceReference &r, int what)
 391 {
 392         switch (what)
 393         {
 394         case iServiceInformation::sFileSize:
 395                 return PyLong_FromLongLong(m_parser.m_filesize);
 396         default:
 397                 Py_RETURN_NONE;
 398         }
 399 }
 400
 401 RESULT eStaticServiceDVBPVRInformation::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &evt, time_t start_time)
 402 {
 403         if (!ref.path.empty())
 404         {
 405                 ePtr<eServiceEvent> event = new eServiceEvent;
 406                 std::string filename = ref.path;
 407                 filename.erase(filename.length()-2, 2);
 408                 filename+="eit";
 409                 if (!event->parseFrom(filename, (m_parser.m_ref.getTransportStreamID().get()<<16)|m_parser.m_ref.getOriginalNetworkID().get()))
 410                 {
 411                         evt = event;
 412                         return 0;
 413                 }
 414         }
 415         evt = 0;
 416         return -1;
 417 }
 418
 419 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
 420 {
 421         DECLARE_REF(eDVBPVRServiceOfflineOperations);
 422         eServiceReferenceDVB m_ref;
 423 public:
 424         eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
 425
 426         RESULT deleteFromDisk(int simulate);
 427         RESULT getListOfFilenames(std::list<std::string> &);
 428         RESULT reindex();
 429 };
 430
 431 DEFINE_REF(eDVBPVRServiceOfflineOperations);
 432
 433 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
 434 {
 435 }
 436
 437 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
 438 {
 439         if (simulate)
 440                 return 0;
 441         else
 442         {
 443                 std::list<std::string> res;
 444                 if (getListOfFilenames(res))
 445                         return -1;
 446
 447                 eBackgroundFileEraser *eraser = eBackgroundFileEraser::getInstance();
 448                 if (!eraser)
 449                         eDebug("FATAL !! can't get background file eraser");
 450
 451                 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
 452                 {
 453                         eDebug("Removing %s...", i->c_str());
 454                         if (eraser)
 455                                 eraser->erase(i->c_str());
 456                         else
 457                                 ::unlink(i->c_str());
 458                 }
 459
 460                 return 0;
 461         }
 462 }
 463
 464 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
 465 {
 466         res.clear();
 467         res.push_back(m_ref.path);
 468
 469 // handling for old splitted recordings (enigma 1)
 470         char buf[255];
 471         int slice=1;
 472         while(true)
 473         {
 474                 snprintf(buf, 255, "%s.%03d", m_ref.path.c_str(), slice++);
 475                 struct stat s;
 476                 if (stat(buf, &s) < 0)
 477                         break;
 478                 res.push_back(buf);
 479         }
 480
 481         res.push_back(m_ref.path + ".meta");
 482         res.push_back(m_ref.path + ".ap");
 483         res.push_back(m_ref.path + ".sc");
 484         res.push_back(m_ref.path + ".cuts");
 485         std::string tmp = m_ref.path;
 486         tmp.erase(m_ref.path.length()-3);
 487         res.push_back(tmp + ".eit");
 488         return 0;
 489 }
 490
 491 RESULT eDVBPVRServiceOfflineOperations::reindex()
 492 {
 493         const char *filename = m_ref.path.c_str();
 494         eDebug("reindexing %s...", filename);
 495
 496         eMPEGStreamInformation info;
 497         eMPEGStreamParserTS parser(info);
 498
 499         info.startSave(filename);
 500
 501         eRawFile f;
 502
 503         int err = f.open(m_ref.path.c_str(), 0);
 504         if (err < 0)
 505                 return -1;
 506
 507         off_t offset = 0;
 508         off_t length = f.length();
 509         unsigned char buffer[188*256*4];
 510         while (1)
 511         {
 512                 eDebug("at %08llx / %08llx (%d %%)", offset, length, (int)(offset * 100 / length));
 513                 int r = f.read(offset, buffer, sizeof(buffer));
 514                 if (!r)
 515                         break;
 516                 if (r < 0)
 517                         return r;
 518                 offset += r;
 519                 parser.parseData(offset, buffer, r);
 520         }
 521
 522         info.stopSave();
 523         f.close();
 524
 525         return 0;
 526 }
 527
 528 DEFINE_REF(eServiceFactoryDVB)
 529
 530 eServiceFactoryDVB::eServiceFactoryDVB()
 531 {
 532         ePtr<eServiceCenter> sc;
 533
 534         eServiceCenter::getPrivInstance(sc);
 535         if (sc)
 536         {
 537                 std::list<std::string> extensions;
 538                 extensions.push_back("ts");
 539                 extensions.push_back("trp");
 540                 sc->addServiceFactory(eServiceFactoryDVB::id, this, extensions);
 541         }
 542
 543         m_StaticServiceDVBInfo = new eStaticServiceDVBInformation;
 544         m_StaticServiceDVBBouquetInfo = new eStaticServiceDVBBouquetInformation;
 545 }
 546
 547 eServiceFactoryDVB::~eServiceFactoryDVB()
 548 {
 549         ePtr<eServiceCenter> sc;
 550
 551         eServiceCenter::getPrivInstance(sc);
 552         if (sc)
 553                 sc->removeServiceFactory(eServiceFactoryDVB::id);
 554 }
 555
 556 DEFINE_REF(eDVBServiceList);
 557
 558 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
 559 {
 560 }
 561
 562 eDVBServiceList::~eDVBServiceList()
 563 {
 564 }
 565
 566 RESULT eDVBServiceList::startQuery()
 567 {
 568         ePtr<iDVBChannelList> db;
 569         ePtr<eDVBResourceManager> res;
 570
 571         int err;
 572         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 573         {
 574                 eDebug("no resource manager");
 575                 return err;
 576         }
 577         if ((err = res->getChannelList(db)) != 0)
 578         {
 579                 eDebug("no channel list");
 580                 return err;
 581         }
 582
 583         ePtr<eDVBChannelQuery> q;
 584
 585         if (!m_parent.path.empty())
 586         {
 587                 eDVBChannelQuery::compile(q, m_parent.path);
 588                 if (!q)
 589                 {
 590                         eDebug("compile query failed");
 591                         return err;
 592                 }
 593         }
 594
 595         if ((err = db->startQuery(m_query, q, m_parent)) != 0)
 596         {
 597                 eDebug("startQuery failed");
 598                 return err;
 599         }
 600
 601         return 0;
 602 }
 603
 604 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list, bool sorted)
 605 {
 606         eServiceReferenceDVB ref;
 607
 608         if (!m_query)
 609                 return -1;
 610
 611         while (!m_query->getNextResult(ref))
 612                 list.push_back(ref);
 613
 614         if (sorted)
 615                 list.sort(iListableServiceCompare(this));
 616
 617         return 0;
 618 }
 619
 620 //   The first argument of this function is a format string to specify the order and
 621 //   the content of the returned list
 622 //   useable format options are
 623 //   R = Service Reference (as swig object .. this is very slow)
 624 //   S = Service Reference (as python string object .. same as ref.toString())
 625 //   C = Service Reference (as python string object .. same as ref.toCompareString())
 626 //   N = Service Name (as python string object)
 627 //   n = Short Service Name (short name brakets used) (as python string object)
 628 //   when exactly one return value per service is selected in the format string,
 629 //   then each value is directly a list entry
 630 //   when more than one value is returned per service, then the list is a list of
 631 //   python tuples
 632 //   unknown format string chars are returned as python None values !
 633 PyObject *eDVBServiceList::getContent(const char* format, bool sorted)
 634 {
 635         ePyObject ret;
 636         std::list<eServiceReference> tmplist;
 637         int retcount=1;
 638
 639         if (!format || !(retcount=strlen(format)))
 640                 format = "R"; // just return service reference swig object ...
 641
 642         if (!getContent(tmplist, sorted))
 643         {
 644                 int services=tmplist.size();
 645                 ePtr<iStaticServiceInformation> sptr;
 646                 eServiceCenterPtr service_center;
 647
 648                 if (strchr(format, 'N') || strchr(format, 'n'))
 649                         eServiceCenter::getPrivInstance(service_center);
 650
 651                 ret = PyList_New(services);
 652                 std::list<eServiceReference>::iterator it(tmplist.begin());
 653
 654                 for (int cnt=0; cnt < services; ++cnt)
 655                 {
 656                         eServiceReference &ref=*it++;
 657                         ePyObject tuple = retcount > 1 ? PyTuple_New(retcount) : ePyObject();
 658                         for (int i=0; i < retcount; ++i)
 659                         {
 660                                 ePyObject tmp;
 661                                 switch(format[i])
 662                                 {
 663                                 case 'R':  // service reference (swig)object
 664                                         tmp = NEW_eServiceReference(ref);
 665                                         break;
 666                                 case 'C':  // service reference compare string
 667                                         tmp = PyString_FromString(ref.toCompareString().c_str());
 668                                         break;
 669                                 case 'S':  // service reference string
 670                                         tmp = PyString_FromString(ref.toString().c_str());
 671                                         break;
 672                                 case 'N':  // service name
 673                                         if (service_center)
 674                                         {
 675                                                 service_center->info(ref, sptr);
 676                                                 if (sptr)
 677                                                 {
 678                                                         std::string name;
 679                                                         sptr->getName(ref, name);
 680
 681                                                         // filter short name brakets
 682                                                         size_t pos;
 683                                                         while((pos = name.find("\xc2\x86")) != std::string::npos)
 684                                                                 name.erase(pos,2);
 685                                                         while((pos = name.find("\xc2\x87")) != std::string::npos)
 686                                                                 name.erase(pos,2);
 687
 688                                                         if (name.length())
 689                                                                 tmp = PyString_FromString(name.c_str());
 690                                                 }
 691                                         }
 692                                         if (!tmp)
 693                                                 tmp = PyString_FromString("<n/a>");
 694                                         break;
 695                                 case 'n':  // short service name
 696                                         if (service_center)
 697                                         {
 698                                                 service_center->info(ref, sptr);
 699                                                 if (sptr)
 700                                                 {
 701                                                         std::string name;
 702                                                         sptr->getName(ref, name);
 703                                                         name = buildShortName(name);
 704                                                         if (name.length())
 705                                                                 tmp = PyString_FromString(name.c_str());
 706                                                 }
 707                                         }
 708                                         if (!tmp)
 709                                                 tmp = PyString_FromString("<n/a>");
 710                                         break;
 711                                 default:
 712                                         if (tuple)
 713                                         {
 714                                                 tmp = Py_None;
 715                                                 Py_INCREF(Py_None);
 716                                         }
 717                                         break;
 718                                 }
 719                                 if (tmp)
 720                                 {
 721                                         if (tuple)
 722                                                 PyTuple_SET_ITEM(tuple, i, tmp);
 723                                         else
 724                                                 PyList_SET_ITEM(ret, cnt, tmp);
 725                                 }
 726                         }
 727                         if (tuple)
 728                                 PyList_SET_ITEM(ret, cnt, tuple);
 729                 }
 730         }
 731         return ret ? (PyObject*)ret : (PyObject*)PyList_New(0);
 732 }
 733
 734 RESULT eDVBServiceList::getNext(eServiceReference &ref)
 735 {
 736         if (!m_query)
 737                 return -1;
 738
 739         return m_query->getNextResult((eServiceReferenceDVB&)ref);
 740 }
 741
 742 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
 743 {
 744         if (m_parent.flags & eServiceReference::canDescent) // bouquet
 745         {
 746                 ePtr<iDVBChannelList> db;
 747                 ePtr<eDVBResourceManager> resm;
 748
 749                 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
 750                         return -1;
 751
 752                 if (db->getBouquet(m_parent, m_bouquet) != 0)
 753                         return -1;
 754
 755                 res = this;
 756
 757                 return 0;
 758         }
 759         res = 0;
 760         return -1;
 761 }
 762
 763 RESULT eDVBServiceList::addService(eServiceReference &ref, eServiceReference before)
 764 {
 765         if (!m_bouquet)
 766                 return -1;
 767         return m_bouquet->addService(ref, before);
 768 }
 769
 770 RESULT eDVBServiceList::removeService(eServiceReference &ref)
 771 {
 772         if (!m_bouquet)
 773                 return -1;
 774         return m_bouquet->removeService(ref);
 775 }
 776
 777 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
 778 {
 779         if (!m_bouquet)
 780                 return -1;
 781         return m_bouquet->moveService(ref, pos);
 782 }
 783
 784 RESULT eDVBServiceList::flushChanges()
 785 {
 786         if (!m_bouquet)
 787                 return -1;
 788         return m_bouquet->flushChanges();
 789 }
 790
 791 RESULT eDVBServiceList::setListName(const std::string &name)
 792 {
 793         if (!m_bouquet)
 794                 return -1;
 795         return m_bouquet->setListName(name);
 796 }
 797
 798 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
 799 {
 800         ePtr<eDVBService> service;
 801         int r = lookupService(service, ref);
 802         if (r)
 803                 service = 0;
 804                 // check resources...
 805         ptr = new eDVBServicePlay(ref, service);
 806         return 0;
 807 }
 808
 809 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
 810 {
 811         if (ref.path.empty())
 812         {
 813                 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
 814                 return 0;
 815         } else
 816         {
 817                 ptr = 0;
 818                 return -1;
 819         }
 820 }
 821
 822 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
 823 {
 824         ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
 825         if (list->startQuery())
 826         {
 827                 ptr = 0;
 828                 return -1;
 829         }
 830
 831         ptr = list;
 832         return 0;
 833 }
 834
 835 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
 836 {
 837         /* is a listable service? */
 838         if (ref.flags & eServiceReference::canDescent) // bouquet
 839         {
 840                 if ( !ref.name.empty() )  // satellites or providers list
 841                         ptr = m_StaticServiceDVBInfo;
 842                 else // a dvb bouquet
 843                         ptr = m_StaticServiceDVBBouquetInfo;
 844         }
 845         else if (!ref.path.empty()) /* do we have a PVR service? */
 846                 ptr = new eStaticServiceDVBPVRInformation(ref);
 847         else // normal dvb service
 848         {
 849                 ePtr<eDVBService> service;
 850                 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
 851                         ptr = m_StaticServiceDVBInfo;
 852                 else
 853                         /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
 854                         ptr = service;
 855         }
 856         return 0;
 857 }
 858
 859 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
 860 {
 861         if (ref.path.empty())
 862         {
 863                 ptr = 0;
 864                 return -1;
 865         } else
 866         {
 867                 ptr = new eDVBPVRServiceOfflineOperations(ref);
 868                 return 0;
 869         }
 870 }
 871
 872 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
 873 {
 874         if (!ref.path.empty()) // playback
 875         {
 876                 eDVBMetaParser parser;
 877                 int ret=parser.parseFile(ref.path);
 878                 service = new eDVBService;
 879                 if (!ret)
 880                         eDVBDB::getInstance()->parseServiceData(service, parser.m_service_data);
 881         }
 882         else
 883         {
 884                         // TODO: handle the listing itself
 885                 // if (ref.... == -1) .. return "... bouquets ...";
 886                 // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
 887                         // TODO: cache
 888                 ePtr<iDVBChannelList> db;
 889                 ePtr<eDVBResourceManager> res;
 890
 891                 int err;
 892                 if ((err = eDVBResourceManager::getInstance(res)) != 0)
 893                 {
 894                         eDebug("no resource manager");
 895                         return err;
 896                 }
 897                 if ((err = res->getChannelList(db)) != 0)
 898                 {
 899                         eDebug("no channel list");
 900                         return err;
 901                 }
 902
 903                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
 904                 if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
 905                 {
 906                         eDebug("getService failed!");
 907                         return err;
 908                 }
 909         }
 910
 911         return 0;
 912 }
 913
 914 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
 915         m_reference(ref), m_dvb_service(service), m_have_video_pid(0), m_is_paused(0)
 916 {
 917         m_is_primary = 1;
 918         m_is_pvr = !m_reference.path.empty();
 919
 920         m_timeshift_enabled = m_timeshift_active = 0, m_timeshift_changed = 0;
 921         m_skipmode = m_fastforward = m_slowmotion = 0;
 922
 923         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
 924         CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
 925         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 926
 927         m_cuesheet_changed = 0;
 928         m_cutlist_enabled = 1;
 929
 930         m_subtitle_widget = 0;
 931
 932         m_tune_state = -1;
 933
 934         m_subtitle_sync_timer = eTimer::create(eApp);
 935
 936         CONNECT(m_subtitle_sync_timer->timeout, eDVBServicePlay::checkSubtitleTiming);
 937 }
 938
 939 eDVBServicePlay::~eDVBServicePlay()
 940 {
 941         if (m_is_pvr)
 942         {
 943                 eDVBMetaParser meta;
 944                 int ret=meta.parseFile(m_reference.path);
 945                 if (!ret)
 946                 {
 947                         char tmp[255];
 948                         meta.m_service_data="";
 949                         sprintf(tmp, "f:%x", m_dvb_service->m_flags);
 950                         meta.m_service_data += tmp;
 951                         // cached pids
 952                         for (int x=0; x < eDVBService::cacheMax; ++x)
 953                         {
 954                                 int entry = m_dvb_service->getCacheEntry((eDVBService::cacheID)x);
 955                                 if (entry != -1)
 956                                 {
 957                                         sprintf(tmp, ",c:%02d%04x", x, entry);
 958                                         meta.m_service_data += tmp;
 959                                 }
 960                         }
 961                         meta.updateMeta(m_reference.path);
 962                 }
 963         }
 964         delete m_subtitle_widget;
 965 }
 966
 967 void eDVBServicePlay::gotNewEvent()
 968 {
 969 #if 0
 970                 // debug only
 971         ePtr<eServiceEvent> m_event_now, m_event_next;
 972         getEvent(m_event_now, 0);
 973         getEvent(m_event_next, 1);
 974
 975         if (m_event_now)
 976                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
 977         if (m_event_next)
 978                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
 979 #endif
 980         m_event((iPlayableService*)this, evUpdatedEventInfo);
 981 }
 982
 983 void eDVBServicePlay::serviceEvent(int event)
 984 {
 985         m_tune_state = event;
 986
 987         switch (event)
 988         {
 989         case eDVBServicePMTHandler::eventTuned:
 990         {
 991                 ePtr<iDVBDemux> m_demux;
 992                 if (!m_service_handler.getDataDemux(m_demux))
 993                 {
 994                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
 995                         int sid = ref.getParentServiceID().get();
 996                         if (!sid)
 997                                 sid = ref.getServiceID().get();
 998                         if ( ref.getParentTransportStreamID().get() &&
 999                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
1000                                 m_event_handler.startOther(m_demux, sid);
1001                         else
1002                                 m_event_handler.start(m_demux, sid);
1003                 }
1004                 m_event((iPlayableService*)this, evTunedIn);
1005                 break;
1006         }
1007         case eDVBServicePMTHandler::eventNoResources:
1008         case eDVBServicePMTHandler::eventNoPAT:
1009         case eDVBServicePMTHandler::eventNoPATEntry:
1010         case eDVBServicePMTHandler::eventNoPMT:
1011         case eDVBServicePMTHandler::eventTuneFailed:
1012         case eDVBServicePMTHandler::eventMisconfiguration:
1013         {
1014                 eDebug("DVB service failed to tune - error %d", event);
1015                 m_event((iPlayableService*)this, evTuneFailed);
1016                 break;
1017         }
1018         case eDVBServicePMTHandler::eventNewProgramInfo:
1019         {
1020                 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
1021                 if (m_timeshift_enabled)
1022                         updateTimeshiftPids();
1023                 if (!m_timeshift_active)
1024                         updateDecoder();
1025                 if (m_first_program_info & 1 && m_is_pvr)
1026                 {
1027                         m_first_program_info &= ~1;
1028                         seekTo(0);
1029                 }
1030                 if (!m_timeshift_active)
1031                         m_event((iPlayableService*)this, evUpdatedInfo);
1032                 break;
1033         }
1034         case eDVBServicePMTHandler::eventPreStart:
1035                 loadCuesheet();
1036                 break;
1037         case eDVBServicePMTHandler::eventEOF:
1038                 m_event((iPlayableService*)this, evEOF);
1039                 break;
1040         case eDVBServicePMTHandler::eventSOF:
1041                 m_event((iPlayableService*)this, evSOF);
1042                 break;
1043         }
1044 }
1045
1046 void eDVBServicePlay::serviceEventTimeshift(int event)
1047 {
1048         switch (event)
1049         {
1050         case eDVBServicePMTHandler::eventNewProgramInfo:
1051                 eDebug("eventNewProgramInfo TS");
1052                 if (m_timeshift_active)
1053                 {
1054                         updateDecoder();
1055                         if (m_first_program_info & 2)
1056                         {
1057                                 if (m_slowmotion)
1058                                 {
1059                                         eDebug("re-apply slowmotion after timeshift file change");
1060                                         m_decoder->setSlowMotion(m_slowmotion);
1061                                 }
1062                                 if (m_fastforward)
1063                                 {
1064                                         eDebug("re-apply skip %d, ratio %d after timeshift file change", m_skipmode, m_fastforward);
1065                                         if (m_skipmode)
1066                                                 m_cue->setSkipmode(m_skipmode * 90000); /* convert to 90000 per second */
1067                                         if (m_fastforward != 1)
1068                                                 m_decoder->setFastForward(m_fastforward);
1069                                         else
1070                                                 m_decoder->setTrickmode();
1071                                 }
1072                                 else
1073                                         seekTo(0);
1074                                 m_first_program_info &= ~2;
1075                         }
1076                         m_event((iPlayableService*)this, evUpdatedInfo);
1077                 }
1078                 break;
1079         case eDVBServicePMTHandler::eventSOF:
1080 #if 0
1081                 if (!m_timeshift_file_next.empty())
1082                 {
1083                         eDebug("timeshift SOF, switch to next file");
1084                         m_decoder->pause();
1085
1086                         m_first_program_info |= 2;
1087
1088                         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1089                         r.path = m_timeshift_file_next;
1090
1091                         /* free the timeshift service handler, we need the resources */
1092                         m_service_handler_timeshift.free();
1093                         resetTimeshift(1);
1094
1095                         if (m_skipmode < 0)
1096                                 m_cue->seekTo(0, -1000);
1097                         ePtr<iTsSource> source = createTsSource(r);
1098                         m_service_handler_timeshift.tuneExt(r, 1, source, r.path.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
1099
1100                         m_event((iPlayableService*)this, evUser+1);
1101                 }
1102                 else
1103 #endif
1104                         m_event((iPlayableService*)this, evSOF);
1105                 break;
1106         case eDVBServicePMTHandler::eventEOF:
1107                 if ((!m_is_paused) && (m_skipmode >= 0))
1108                 {
1109                         if (m_timeshift_file_next.empty())
1110                         {
1111                                 eDebug("timeshift EOF, so let's go live");
1112                                 switchToLive();
1113                         }
1114                         else
1115                         {
1116                                 eDebug("timeshift EOF, switch to next file");
1117
1118                                 m_first_program_info |= 2;
1119
1120                                 eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1121                                 r.path = m_timeshift_file_next;
1122
1123                                 /* free the timeshift service handler, we need the resources */
1124                                 m_service_handler_timeshift.free();
1125                                 resetTimeshift(1);
1126
1127                                 ePtr<iTsSource> source = createTsSource(r);
1128                                 m_service_handler_timeshift.tuneExt(r, 1, source, m_timeshift_file_next.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
1129
1130                                 m_event((iPlayableService*)this, evUser+1);
1131                         }
1132                 }
1133                 break;
1134         }
1135 }
1136
1137 RESULT eDVBServicePlay::start()
1138 {
1139         eServiceReferenceDVB service = (eServiceReferenceDVB&)m_reference;
1140
1141                 /* in pvr mode, we only want to use one demux. in tv mode, we're using
1142                    two (one for decoding, one for data source), as we must be prepared
1143                    to start recording from the data demux. */
1144         if (m_is_pvr)
1145         {
1146                 eDVBMetaParser meta;
1147                 if (!meta.parseFile(m_reference.path))
1148                 {
1149                         service = meta.m_ref;
1150                         service.path = m_reference.path;
1151                 }
1152                 m_cue = new eCueSheet();
1153         }
1154         else
1155                 m_event(this, evStart);
1156
1157         m_first_program_info = 1;
1158         ePtr<iTsSource> source = createTsSource(service);
1159         m_service_handler.tuneExt(service, m_is_pvr, source, service.path.c_str(), m_cue, false, m_dvb_service);
1160
1161         if (m_is_pvr)
1162         {
1163                 /* inject EIT if there is a stored one */
1164                 std::string filename = service.path;
1165                 filename.erase(filename.length()-2, 2);
1166                 filename+="eit";
1167                 ePtr<eServiceEvent> event = new eServiceEvent;
1168                 if (!event->parseFrom(filename, (service.getTransportStreamID().get()<<16)|service.getOriginalNetworkID().get()))
1169                 {
1170                         ePtr<eServiceEvent> empty;
1171                         m_event_handler.inject(event, 0);
1172                         m_event_handler.inject(empty, 1);
1173                 }
1174                 m_event(this, evStart);
1175         }
1176         return 0;
1177 }
1178
1179 RESULT eDVBServicePlay::stop()
1180 {
1181                 /* add bookmark for last play position */
1182         if (m_is_pvr)
1183         {
1184                 pts_t play_position, length;
1185                 if (!getPlayPosition(play_position))
1186                 {
1187                                 /* remove last position */
1188                         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end();)
1189                         {
1190                                 if (i->what == 3) /* current play position */
1191                                 {
1192                                         m_cue_entries.erase(i);
1193                                         i = m_cue_entries.begin();
1194                                         continue;
1195                                 } else
1196                                         ++i;
1197                         }
1198
1199                         if (getLength(length))
1200                                 length = 0;
1201
1202                         if (length)
1203                         {
1204                                 m_cue_entries.insert(cueEntry(play_position, 3)); /* last play position */
1205                         }
1206                         m_cuesheet_changed = 1;
1207                 }
1208         }
1209
1210         stopTimeshift(); /* in case timeshift was enabled, remove buffer etc. */
1211
1212         m_service_handler_timeshift.free();
1213         m_service_handler.free();
1214
1215         if (m_is_pvr && m_cuesheet_changed)
1216         {
1217                 struct stat s;
1218                                 /* save cuesheet only when main file is accessible. */
1219                 if (!::stat(m_reference.path.c_str(), &s))
1220                         saveCuesheet();
1221         }
1222         m_event((iPlayableService*)this, evStopped);
1223         return 0;
1224 }
1225
1226 RESULT eDVBServicePlay::setTarget(int target)
1227 {
1228         m_is_primary = !target;
1229         return 0;
1230 }
1231
1232 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
1233 {
1234         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
1235         return 0;
1236 }
1237
1238 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
1239 {
1240                 /* note: we check for timeshift to be enabled,
1241                    not neccessary active. if you pause when timeshift
1242                    is not active, you should activate it when unpausing */
1243         if ((!m_is_pvr) && (!m_timeshift_enabled))
1244         {
1245                 ptr = 0;
1246                 return -1;
1247         }
1248
1249         ptr = this;
1250         return 0;
1251 }
1252
1253 RESULT eDVBServicePlay::setSlowMotion(int ratio)
1254 {
1255         ASSERT(ratio); /* The API changed: instead of calling setSlowMotion(0), call play! */
1256         eDebug("eDVBServicePlay::setSlowMotion(%d)", ratio);
1257         setFastForward_internal(0);
1258         if (m_decoder)
1259         {
1260                 m_slowmotion = ratio;
1261                 return m_decoder->setSlowMotion(ratio);
1262         }
1263         else
1264                 return -1;
1265 }
1266
1267 RESULT eDVBServicePlay::setFastForward(int ratio)
1268 {
1269         eDebug("eDVBServicePlay::setFastForward(%d)", ratio);
1270         ASSERT(ratio);
1271         return setFastForward_internal(ratio);
1272 }
1273
1274 RESULT eDVBServicePlay::setFastForward_internal(int ratio, bool final_seek)
1275 {
1276         int skipmode, ffratio, ret = 0;
1277         pts_t pos=0;
1278
1279         if (ratio > 8)
1280         {
1281                 skipmode = ratio;
1282                 ffratio = 1;
1283         } else if (ratio > 0)
1284         {
1285                 skipmode = 0;
1286                 ffratio = ratio;
1287         } else if (!ratio)
1288         {
1289                 skipmode = 0;
1290                 ffratio = 0;
1291         } else // if (ratio < 0)
1292         {
1293                 skipmode = ratio;
1294                 ffratio = 1;
1295         }
1296
1297         if (m_skipmode != skipmode)
1298         {
1299                 eDebug("setting cue skipmode to %d", skipmode);
1300                 if (m_cue)
1301                         m_cue->setSkipmode(skipmode * 90000); /* convert to 90000 per second */
1302         }
1303
1304         m_skipmode = skipmode;
1305
1306         if (final_seek)
1307                 eDebug("trickplay stopped .. ret %d, pos %lld", getPlayPosition(pos), pos);
1308
1309         m_fastforward = ffratio;
1310
1311         if (!m_decoder)
1312                 return -1;
1313
1314         if (ffratio == 0)
1315                 ; /* return m_decoder->play(); is done in caller*/
1316         else if (ffratio != 1)
1317                 ret = m_decoder->setFastForward(ffratio);
1318         else
1319                 ret = m_decoder->setTrickmode();
1320
1321         if (pos)
1322                 eDebug("final seek after trickplay ret %d", seekTo(pos));
1323
1324         return ret;
1325 }
1326
1327 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
1328 {
1329         if (m_is_pvr || m_timeshift_enabled)
1330         {
1331                 ptr = this;
1332                 return 0;
1333         }
1334
1335         ptr = 0;
1336         return -1;
1337 }
1338
1339         /* TODO: when timeshift is enabled but not active, this doesn't work. */
1340 RESULT eDVBServicePlay::getLength(pts_t &len)
1341 {
1342         ePtr<iDVBPVRChannel> pvr_channel;
1343
1344         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1345                 return -1;
1346
1347         return pvr_channel->getLength(len);
1348 }
1349
1350 RESULT eDVBServicePlay::pause()
1351 {
1352         eDebug("eDVBServicePlay::pause");
1353         setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
1354         if (m_decoder)
1355         {
1356                 m_slowmotion = 0;
1357                 m_is_paused = 1;
1358                 return m_decoder->pause();
1359         } else
1360                 return -1;
1361 }
1362
1363 RESULT eDVBServicePlay::unpause()
1364 {
1365         eDebug("eDVBServicePlay::unpause");
1366         setFastForward_internal(0, m_slowmotion || m_fastforward > 1);
1367         if (m_decoder)
1368         {
1369                 m_slowmotion = 0;
1370                 m_is_paused = 0;
1371                 return m_decoder->play();
1372         } else
1373                 return -1;
1374 }
1375
1376 RESULT eDVBServicePlay::seekTo(pts_t to)
1377 {
1378         eDebug("eDVBServicePlay::seekTo: jump %lld", to);
1379
1380         if (!m_decode_demux)
1381                 return -1;
1382
1383         ePtr<iDVBPVRChannel> pvr_channel;
1384
1385         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1386                 return -1;
1387
1388         if (!m_cue)
1389                 return -1;
1390
1391         m_cue->seekTo(0, to);
1392         m_dvb_subtitle_pages.clear();
1393         m_subtitle_pages.clear();
1394
1395         return 0;
1396 }
1397
1398 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
1399 {
1400         eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
1401
1402         if (!m_decode_demux)
1403                 return -1;
1404
1405         ePtr<iDVBPVRChannel> pvr_channel;
1406
1407         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1408                 return -1;
1409
1410         int mode = 1;
1411
1412                         /* HACK until we have skip-AP api */
1413         if ((to > 0) && (to < 100))
1414                 mode = 2;
1415
1416         to *= direction;
1417
1418         if (!m_cue)
1419                 return 0;
1420
1421         m_cue->seekTo(mode, to);
1422         m_dvb_subtitle_pages.clear();
1423         m_subtitle_pages.clear();
1424         return 0;
1425 }
1426
1427 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
1428 {
1429         ePtr<iDVBPVRChannel> pvr_channel;
1430
1431         if (!m_decode_demux)
1432                 return -1;
1433
1434         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
1435                 return -1;
1436
1437         int r = 0;
1438
1439                 /* if there is a decoder, use audio or video PTS */
1440         if (m_decoder)
1441         {
1442                 r = m_decoder->getPTS(0, pos);
1443                 if (r)
1444                         return r;
1445         }
1446
1447                 /* fixup */
1448         return pvr_channel->getCurrentPosition(m_decode_demux, pos, m_decoder ? 1 : 0);
1449 }
1450
1451 RESULT eDVBServicePlay::setTrickmode(int trick)
1452 {
1453                 /* currently unimplemented */
1454         return -1;
1455 }
1456
1457 RESULT eDVBServicePlay::isCurrentlySeekable()
1458 {
1459         int ret = 0;
1460         if (m_decoder)
1461         {
1462                 ret = (m_is_pvr || m_timeshift_active) ? 3 : 0; // fast forward/backward possible and seeking possible
1463                 if (m_decoder->getVideoProgressive() == -1)
1464                         ret &= ~2;
1465         }
1466         return ret;
1467 }
1468
1469 RESULT eDVBServicePlay::frontendInfo(ePtr<iFrontendInformation> &ptr)
1470 {
1471         ptr = this;
1472         return 0;
1473 }
1474
1475 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
1476 {
1477         ptr = this;
1478         return 0;
1479 }
1480
1481 RESULT eDVBServicePlay::audioChannel(ePtr<iAudioChannelSelection> &ptr)
1482 {
1483         ptr = this;
1484         return 0;
1485 }
1486
1487 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
1488 {
1489         ptr = this;
1490         return 0;
1491 }
1492
1493 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
1494 {
1495         ptr = this;
1496         return 0;
1497 }
1498
1499 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
1500 {
1501         ptr = 0;
1502         if (m_have_video_pid &&  // HACK !!! FIXMEE !! temporary no timeshift on radio services !!
1503                 (m_timeshift_enabled || !m_is_pvr))
1504         {
1505                 if (!m_timeshift_enabled)
1506                 {
1507                         /* query config path */
1508                         std::string tspath;
1509                         if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
1510                                 eDebug("could not query ts path from config");
1511                                 return -4;
1512                         }
1513                         tspath.append("/");
1514                         /* we need enough diskspace */
1515                         struct statfs fs;
1516                         if (statfs(tspath.c_str(), &fs) < 0)
1517                         {
1518                                 eDebug("statfs failed!");
1519                                 return -2;
1520                         }
1521
1522                         if (((off_t)fs.f_bavail) * ((off_t)fs.f_bsize) < 1024*1024*1024LL)
1523                         {
1524                                 eDebug("not enough diskspace for timeshift! (less than 1GB)");
1525                                 return -3;
1526                         }
1527                 }
1528                 ptr = this;
1529                 return 0;
1530         }
1531         return -1;
1532 }
1533
1534 RESULT eDVBServicePlay::cueSheet(ePtr<iCueSheet> &ptr)
1535 {
1536         if (m_is_pvr)
1537         {
1538                 ptr = this;
1539                 return 0;
1540         }
1541         ptr = 0;
1542         return -1;
1543 }
1544
1545 RESULT eDVBServicePlay::subtitle(ePtr<iSubtitleOutput> &ptr)
1546 {
1547         ptr = this;
1548         return 0;
1549 }
1550
1551 RESULT eDVBServicePlay::audioDelay(ePtr<iAudioDelay> &ptr)
1552 {
1553         ptr = this;
1554         return 0;
1555 }
1556
1557 RESULT eDVBServicePlay::rdsDecoder(ePtr<iRdsDecoder> &ptr)
1558 {
1559         ptr = this;
1560         return 0;
1561 }
1562
1563 RESULT eDVBServicePlay::getName(std::string &name)
1564 {
1565         if (m_is_pvr)
1566         {
1567                 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
1568                 return i->getName(m_reference, name);
1569         }
1570         else if (m_dvb_service)
1571         {
1572                 m_dvb_service->getName(m_reference, name);
1573                 if (name.empty())
1574                         name = "(...)";
1575         }
1576         else if (!m_reference.name.empty())
1577                 eStaticServiceDVBInformation().getName(m_reference, name);
1578         else
1579                 name = "DVB service";
1580         return 0;
1581 }
1582
1583 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
1584 {
1585         return m_event_handler.getEvent(evt, nownext);
1586 }
1587
1588 int eDVBServicePlay::getInfo(int w)
1589 {
1590         eDVBServicePMTHandler::program program;
1591
1592         if (w == sCAIDs)
1593                 return resIsPyObject;
1594
1595         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1596
1597         int no_program_info = 0;
1598
1599         if (h.getProgramInfo(program))
1600                 no_program_info = 1;
1601
1602         switch (w)
1603         {
1604         case sVideoHeight:
1605                 if (m_decoder)
1606                         return m_decoder->getVideoHeight();
1607                 break;
1608         case sVideoWidth:
1609                 if (m_decoder)
1610                         return m_decoder->getVideoWidth();
1611                 break;
1612         case sFrameRate:
1613                 if (m_decoder)
1614                         return m_decoder->getVideoFrameRate();
1615                 break;
1616         case sProgressive:
1617                 if (m_decoder)
1618                         return m_decoder->getVideoProgressive();
1619                 break;
1620         case sAspect:
1621         {
1622                 int aspect = -1;
1623                 if (m_decoder)
1624                         aspect = m_decoder->getVideoAspect();
1625                 if (aspect == -1 && no_program_info)
1626                         break;
1627                 else if (aspect == -1 && !program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
1628                 {
1629                         ePtr<eServiceEvent> evt;
1630                         if (!m_event_handler.getEvent(evt, 0))
1631                         {
1632                                 ePtr<eComponentData> data;
1633                                 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
1634                                 {
1635                                         if ( data->getStreamContent() == 1 )
1636                                         {
1637                                                 switch(data->getComponentType())
1638                                                 {
1639                                                         // SD
1640                                                         case 1: // 4:3 SD PAL
1641                                                         case 2:
1642                                                         case 3: // 16:9 SD PAL
1643                                                         case 4: // > 16:9 PAL
1644                                                         case 5: // 4:3 SD NTSC
1645                                                         case 6:
1646                                                         case 7: // 16:9 SD NTSC
1647                                                         case 8: // > 16:9 NTSC
1648
1649                                                         // HD
1650                                                         case 9: // 4:3 HD PAL
1651                                                         case 0xA:
1652                                                         case 0xB: // 16:9 HD PAL
1653                                                         case 0xC: // > 16:9 HD PAL
1654                                                         case 0xD: // 4:3 HD NTSC
1655                                                         case 0xE:
1656                                                         case 0xF: // 16:9 HD NTSC
1657                                                         case 0x10: // > 16:9 HD PAL
1658                                                                 return data->getComponentType();
1659                                                 }
1660                                         }
1661                                 }
1662                         }
1663                 }
1664                 else
1665                         return aspect;
1666                 break;
1667         }
1668         case sIsCrypted: if (no_program_info) return -1; return program.isCrypted();
1669         case sVideoPID:
1670                 if (m_dvb_service)
1671                 {
1672                         int vpid = m_dvb_service->getCacheEntry(eDVBService::cVPID);
1673                         if (vpid != -1)
1674                                 return vpid;
1675                 }
1676                 if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
1677         case sVideoType: if (no_program_info) return -1; if (program.videoStreams.empty()) return -1; return program.videoStreams[0].type;
1678         case sAudioPID:
1679                 if (m_dvb_service)
1680                 {
1681                         int apid = m_dvb_service->getCacheEntry(eDVBService::cAPID);
1682                         if (apid != -1)
1683                                 return apid;
1684                         apid = m_dvb_service->getCacheEntry(eDVBService::cAC3PID);
1685                         if (apid != -1)
1686                                 return apid;
1687                 }
1688                 if (no_program_info) return -1; if (program.audioStreams.empty()) return -1; return program.audioStreams[0].pid;
1689         case sPCRPID:
1690                 if (m_dvb_service)
1691                 {
1692                         int pcrpid = m_dvb_service->getCacheEntry(eDVBService::cPCRPID);
1693                         if (pcrpid != -1)
1694                                 return pcrpid;
1695                 }
1696                 if (no_program_info) return -1; return program.pcrPid;
1697         case sPMTPID: if (no_program_info) return -1; return program.pmtPid;
1698         case sTXTPID: if (no_program_info) return -1; return program.textPid;
1699         case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
1700         case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
1701         case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
1702         case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
1703         case sProvider: if (!m_dvb_service) return -1; return -2;
1704         case sServiceref: return resIsString;
1705         case sDVBState: return m_tune_state;
1706         default:
1707                 break;
1708         }
1709         return -1;
1710 }
1711
1712 std::string eDVBServicePlay::getInfoString(int w)
1713 {
1714         switch (w)
1715         {
1716         case sProvider:
1717                 if (!m_dvb_service) return "";
1718                 return m_dvb_service->m_provider_name;
1719         case sServiceref:
1720                 return m_reference.toString();
1721         default:
1722                 break;
1723         }
1724         return iServiceInformation::getInfoString(w);
1725 }
1726
1727 PyObject *eDVBServicePlay::getInfoObject(int w)
1728 {
1729         switch (w)
1730         {
1731         case sCAIDs:
1732                 return m_service_handler.getCaIds();
1733         case sTransponderData:
1734                 return eStaticServiceDVBInformation().getInfoObject(m_reference, w);
1735         default:
1736                 break;
1737         }
1738         return iServiceInformation::getInfoObject(w);
1739 }
1740
1741 int eDVBServicePlay::getNumberOfTracks()
1742 {
1743         eDVBServicePMTHandler::program program;
1744         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1745         if (h.getProgramInfo(program))
1746                 return 0;
1747         return program.audioStreams.size();
1748 }
1749
1750 int eDVBServicePlay::getCurrentTrack()
1751 {
1752         eDVBServicePMTHandler::program program;
1753         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1754         if (h.getProgramInfo(program))
1755                 return 0;
1756
1757         int max = program.audioStreams.size();
1758         int i;
1759
1760         for (i = 0; i < max; ++i)
1761                 if (program.audioStreams[i].pid == m_current_audio_pid)
1762                         return i;
1763
1764         return 0;
1765 }
1766
1767 RESULT eDVBServicePlay::selectTrack(unsigned int i)
1768 {
1769         int ret = selectAudioStream(i);
1770
1771         if (m_decoder->set())
1772                 return -5;
1773
1774         return ret;
1775 }
1776
1777 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
1778 {
1779         eDVBServicePMTHandler::program program;
1780         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1781
1782         if (h.getProgramInfo(program))
1783                 return -1;
1784
1785         if (i >= program.audioStreams.size())
1786                 return -2;
1787
1788         info.m_pid = program.audioStreams[i].pid;
1789
1790         if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
1791                 info.m_description = "MPEG";
1792         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
1793                 info.m_description = "AC3";
1794         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAAC)
1795                 info.m_description = "AAC";
1796         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAACHE)
1797                 info.m_description = "AAC-HE";
1798         else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
1799                 info.m_description = "DTS";
1800         else
1801                 info.m_description = "???";
1802
1803         if (program.audioStreams[i].component_tag != -1)
1804         {
1805                 ePtr<eServiceEvent> evt;
1806                 if (!m_event_handler.getEvent(evt, 0))
1807                 {
1808                         ePtr<eComponentData> data;
1809                         if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
1810                                 info.m_language = data->getText();
1811                 }
1812         }
1813
1814         if (info.m_language.empty())
1815                 info.m_language = program.audioStreams[i].language_code;
1816
1817         return 0;
1818 }
1819
1820 int eDVBServicePlay::selectAudioStream(int i)
1821 {
1822         eDVBServicePMTHandler::program program;
1823         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1824         pts_t position = -1;
1825
1826         if (h.getProgramInfo(program))
1827                 return -1;
1828
1829         if ((i != -1) && ((unsigned int)i >= program.audioStreams.size()))
1830                 return -2;
1831
1832         if (!m_decoder)
1833                 return -3;
1834
1835         int stream = i;
1836         if (stream == -1)
1837                 stream = program.defaultAudioStream;
1838
1839         int apid = -1, apidtype = -1;
1840
1841         if (((unsigned int)stream) < program.audioStreams.size())
1842         {
1843                 apid = program.audioStreams[stream].pid;
1844                 apidtype = program.audioStreams[stream].type;
1845         }
1846
1847         if (i != -1 && apid != m_current_audio_pid && (m_is_pvr || m_timeshift_active))
1848                 eDebug("getPlayPosition ret %d, pos %lld in selectAudioStream", getPlayPosition(position), position);
1849
1850         m_current_audio_pid = apid;
1851
1852         if (m_is_primary && m_decoder->setAudioPID(apid, apidtype))
1853         {
1854                 eDebug("set audio pid failed");
1855                 return -4;
1856         }
1857
1858         if (position != -1)
1859                 eDebug("seekTo ret %d", seekTo(position));
1860
1861         int rdsPid = apid;
1862
1863                 /* if we are not in PVR mode, timeshift is not active and we are not in pip mode, check if we need to enable the rds reader */
1864         if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
1865         {
1866                 int different_pid = program.videoStreams.empty() && program.audioStreams.size() == 1 && program.audioStreams[stream].rdsPid != -1;
1867                 if (different_pid)
1868                         rdsPid = program.audioStreams[stream].rdsPid;
1869                 if (!m_rds_decoder || m_rds_decoder->getPid() != rdsPid)
1870                 {
1871                         m_rds_decoder = 0;
1872                         ePtr<iDVBDemux> data_demux;
1873                         if (!h.getDataDemux(data_demux))
1874                         {
1875                                 m_rds_decoder = new eDVBRdsDecoder(data_demux, different_pid);
1876                                 m_rds_decoder->connectEvent(slot(*this, &eDVBServicePlay::rdsDecoderEvent), m_rds_decoder_event_connection);
1877                                 m_rds_decoder->start(rdsPid);
1878                         }
1879                 }
1880         }
1881
1882                         /* store new pid as default only when:
1883                                 a.) we have an entry in the service db for the current service,
1884                                 b.) we are not playing back something,
1885                                 c.) we are not selecting the default entry. (we wouldn't change
1886                                     anything in the best case, or destroy the default setting in
1887                                     case the real default is not yet available.)
1888                         */
1889         if (m_dvb_service && ((i != -1)
1890                 || ((m_dvb_service->getCacheEntry(eDVBService::cAPID) == -1) && (m_dvb_service->getCacheEntry(eDVBService::cAC3PID)==-1))))
1891         {
1892                 if (apidtype == eDVBAudio::aMPEG)
1893                 {
1894                         m_dvb_service->setCacheEntry(eDVBService::cAPID, apid);
1895                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1896                 }
1897                 else if (apidtype == eDVBAudio::aAC3)
1898                 {
1899                         m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1900                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, apid);
1901                 }
1902                 else
1903                 {
1904                         m_dvb_service->setCacheEntry(eDVBService::cAPID, -1);
1905                         m_dvb_service->setCacheEntry(eDVBService::cAC3PID, -1);
1906                 }
1907         }
1908
1909         h.resetCachedProgram();
1910
1911         return 0;
1912 }
1913
1914 int eDVBServicePlay::getCurrentChannel()
1915 {
1916         return m_decoder ? m_decoder->getAudioChannel() : STEREO;
1917 }
1918
1919 RESULT eDVBServicePlay::selectChannel(int i)
1920 {
1921         if (i < LEFT || i > RIGHT || i == STEREO)
1922                 i = -1;  // Stereo
1923         if (m_dvb_service)
1924                 m_dvb_service->setCacheEntry(eDVBService::cACHANNEL, i);
1925         if (m_decoder)
1926                 m_decoder->setAudioChannel(i);
1927         return 0;
1928 }
1929
1930 std::string eDVBServicePlay::getText(int x)
1931 {
1932         if (m_rds_decoder)
1933                 switch(x)
1934                 {
1935                         case RadioText:
1936                                 return convertLatin1UTF8(m_rds_decoder->getRadioText());
1937                         case RtpText:
1938                                 return convertLatin1UTF8(m_rds_decoder->getRtpText());
1939                 }
1940         return "";
1941 }
1942
1943 void eDVBServicePlay::rdsDecoderEvent(int what)
1944 {
1945         switch(what)
1946         {
1947                 case eDVBRdsDecoder::RadioTextChanged:
1948                         m_event((iPlayableService*)this, evUpdatedRadioText);
1949                         break;
1950                 case eDVBRdsDecoder::RtpTextChanged:
1951                         m_event((iPlayableService*)this, evUpdatedRtpText);
1952                         break;
1953                 case eDVBRdsDecoder::RassInteractivePicMaskChanged:
1954                         m_event((iPlayableService*)this, evUpdatedRassInteractivePicMask);
1955                         break;
1956                 case eDVBRdsDecoder::RecvRassSlidePic:
1957                         m_event((iPlayableService*)this, evUpdatedRassSlidePic);
1958                         break;
1959         }
1960 }
1961
1962 void eDVBServicePlay::showRassSlidePicture()
1963 {
1964         if (m_rds_decoder)
1965         {
1966                 if (m_decoder)
1967                 {
1968                         std::string rass_slide_pic = m_rds_decoder->getRassSlideshowPicture();
1969                         if (rass_slide_pic.length())
1970                                 m_decoder->showSinglePic(rass_slide_pic.c_str());
1971                         else
1972                                 eDebug("empty filename for rass slide picture received!!");
1973                 }
1974                 else
1975                         eDebug("no MPEG Decoder to show iframes avail");
1976         }
1977         else
1978                 eDebug("showRassSlidePicture called.. but not decoder");
1979 }
1980
1981 void eDVBServicePlay::showRassInteractivePic(int page, int subpage)
1982 {
1983         if (m_rds_decoder)
1984         {
1985                 if (m_decoder)
1986                 {
1987                         std::string rass_interactive_pic = m_rds_decoder->getRassPicture(page, subpage);
1988                         if (rass_interactive_pic.length())
1989                                 m_decoder->showSinglePic(rass_interactive_pic.c_str());
1990                         else
1991                                 eDebug("empty filename for rass interactive picture %d/%d received!!", page, subpage);
1992                 }
1993                 else
1994                         eDebug("no MPEG Decoder to show iframes avail");
1995         }
1996         else
1997                 eDebug("showRassInteractivePic called.. but not decoder");
1998 }
1999
2000 ePyObject eDVBServicePlay::getRassInteractiveMask()
2001 {
2002         if (m_rds_decoder)
2003                 return m_rds_decoder->getRassPictureMask();
2004         Py_RETURN_NONE;
2005 }
2006
2007 int eDVBServiceBase::getFrontendInfo(int w)
2008 {
2009         eUsePtr<iDVBChannel> channel;
2010         if(m_service_handler.getChannel(channel))
2011                 return 0;
2012         ePtr<iDVBFrontend> fe;
2013         if(channel->getFrontend(fe))
2014                 return 0;
2015         return fe->readFrontendData(w);
2016 }
2017
2018 PyObject *eDVBServiceBase::getFrontendData()
2019 {
2020         ePyObject ret = PyDict_New();
2021         if (ret)
2022         {
2023                 eUsePtr<iDVBChannel> channel;
2024                 if(!m_service_handler.getChannel(channel))
2025                 {
2026                         ePtr<iDVBFrontend> fe;
2027                         if(!channel->getFrontend(fe))
2028                                 fe->getFrontendData(ret);
2029                 }
2030         }
2031         else
2032                 Py_RETURN_NONE;
2033         return ret;
2034 }
2035
2036 PyObject *eDVBServiceBase::getFrontendStatus()
2037 {
2038         ePyObject ret = PyDict_New();
2039         if (ret)
2040         {
2041                 eUsePtr<iDVBChannel> channel;
2042                 if(!m_service_handler.getChannel(channel))
2043                 {
2044                         ePtr<iDVBFrontend> fe;
2045                         if(!channel->getFrontend(fe))
2046                                 fe->getFrontendStatus(ret);
2047                 }
2048         }
2049         else
2050                 Py_RETURN_NONE;
2051         return ret;
2052 }
2053
2054 PyObject *eDVBServiceBase::getTransponderData(bool original)
2055 {
2056         ePyObject ret = PyDict_New();
2057         if (ret)
2058         {
2059                 eUsePtr<iDVBChannel> channel;
2060                 if(!m_service_handler.getChannel(channel))
2061                 {
2062                         ePtr<iDVBFrontend> fe;
2063                         if(!channel->getFrontend(fe))
2064                                 fe->getTransponderData(ret, original);
2065                 }
2066         }
2067         else
2068                 Py_RETURN_NONE;
2069         return ret;
2070 }
2071
2072 PyObject *eDVBServiceBase::getAll(bool original)
2073 {
2074         ePyObject ret = getTransponderData(original);
2075         if (ret != Py_None)
2076         {
2077                 eUsePtr<iDVBChannel> channel;
2078                 if(!m_service_handler.getChannel(channel))
2079                 {
2080                         ePtr<iDVBFrontend> fe;
2081                         if(!channel->getFrontend(fe))
2082                         {
2083                                 fe->getFrontendData(ret);
2084                                 fe->getFrontendStatus(ret);
2085                         }
2086                 }
2087         }
2088         return ret;
2089 }
2090
2091 int eDVBServicePlay::getNumberOfSubservices()
2092 {
2093         ePtr<eServiceEvent> evt;
2094         if (!m_event_handler.getEvent(evt, 0))
2095                 return evt->getNumOfLinkageServices();
2096         return 0;
2097 }
2098
2099 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
2100 {
2101         ePtr<eServiceEvent> evt;
2102         if (!m_event_handler.getEvent(evt, 0))
2103         {
2104                 if (!evt->getLinkageService(sub, m_reference, n))
2105                         return 0;
2106         }
2107         sub.type=eServiceReference::idInvalid;
2108         return -1;
2109 }
2110
2111 RESULT eDVBServicePlay::startTimeshift()
2112 {
2113         ePtr<iDVBDemux> demux;
2114
2115         eDebug("Start timeshift!");
2116
2117         if (m_timeshift_enabled)
2118                 return -1;
2119
2120                 /* start recording with the data demux. */
2121         if (m_service_handler.getDataDemux(demux))
2122                 return -2;
2123
2124         demux->createTSRecorder(m_record);
2125         if (!m_record)
2126                 return -3;
2127
2128         std::string tspath;
2129         if(ePythonConfigQuery::getConfigValue("config.usage.timeshift_path", tspath) == -1){
2130                 eDebug("could not query ts path");
2131                 return -5;
2132         }
2133         tspath.append("/timeshift.XXXXXX");
2134         char* templ;
2135         templ = new char[tspath.length() + 1];
2136         strcpy(templ, tspath.c_str());
2137
2138         m_timeshift_fd = mkstemp(templ);
2139         m_timeshift_file = std::string(templ);
2140
2141         eDebug("recording to %s", templ);
2142
2143         delete [] templ;
2144
2145         if (m_timeshift_fd < 0)
2146         {
2147                 m_record = 0;
2148                 return -4;
2149         }
2150
2151         m_record->setTargetFD(m_timeshift_fd);
2152
2153         m_timeshift_enabled = 1;
2154
2155         updateTimeshiftPids();
2156         m_record->start();
2157
2158         return 0;
2159 }
2160
2161 RESULT eDVBServicePlay::stopTimeshift(bool swToLive)
2162 {
2163         if (!m_timeshift_enabled)
2164                 return -1;
2165
2166         if (swToLive)
2167                 switchToLive();
2168
2169         m_timeshift_enabled = 0;
2170
2171         m_record->stop();
2172         m_record = 0;
2173
2174         close(m_timeshift_fd);
2175         eDebug("remove timeshift file");
2176         eBackgroundFileEraser::getInstance()->erase(m_timeshift_file.c_str());
2177
2178         return 0;
2179 }
2180
2181 int eDVBServicePlay::isTimeshiftActive()
2182 {
2183         return m_timeshift_enabled && m_timeshift_active;
2184 }
2185
2186 RESULT eDVBServicePlay::activateTimeshift()
2187 {
2188         if (!m_timeshift_enabled)
2189                 return -1;
2190
2191         if (!m_timeshift_active)
2192         {
2193                 switchToTimeshift();
2194                 return 0;
2195         }
2196
2197         return -2;
2198 }
2199
2200 PyObject *eDVBServicePlay::getCutList()
2201 {
2202         ePyObject list = PyList_New(0);
2203
2204         for (std::multiset<struct cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2205         {
2206                 ePyObject tuple = PyTuple_New(2);
2207                 PyTuple_SET_ITEM(tuple, 0, PyLong_FromLongLong(i->where));
2208                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(i->what));
2209                 PyList_Append(list, tuple);
2210                 Py_DECREF(tuple);
2211         }
2212
2213         return list;
2214 }
2215
2216 void eDVBServicePlay::setCutList(ePyObject list)
2217 {
2218         if (!PyList_Check(list))
2219                 return;
2220         int size = PyList_Size(list);
2221         int i;
2222
2223         m_cue_entries.clear();
2224
2225         for (i=0; i<size; ++i)
2226         {
2227                 ePyObject tuple = PyList_GET_ITEM(list, i);
2228                 if (!PyTuple_Check(tuple))
2229                 {
2230                         eDebug("non-tuple in cutlist");
2231                         continue;
2232                 }
2233                 if (PyTuple_Size(tuple) != 2)
2234                 {
2235                         eDebug("cutlist entries need to be a 2-tuple");
2236                         continue;
2237                 }
2238                 ePyObject ppts = PyTuple_GET_ITEM(tuple, 0), ptype = PyTuple_GET_ITEM(tuple, 1);
2239                 if (!(PyLong_Check(ppts) && PyInt_Check(ptype)))
2240                 {
2241                         eDebug("cutlist entries need to be (pts, type)-tuples (%d %d)", PyLong_Check(ppts), PyInt_Check(ptype));
2242                         continue;
2243                 }
2244                 pts_t pts = PyLong_AsLongLong(ppts);
2245                 int type = PyInt_AsLong(ptype);
2246                 m_cue_entries.insert(cueEntry(pts, type));
2247                 eDebug("adding %08llx, %d", pts, type);
2248         }
2249         m_cuesheet_changed = 1;
2250
2251         cutlistToCuesheet();
2252         m_event((iPlayableService*)this, evCuesheetChanged);
2253 }
2254
2255 void eDVBServicePlay::setCutListEnable(int enable)
2256 {
2257         m_cutlist_enabled = enable;
2258         cutlistToCuesheet();
2259 }
2260
2261 void eDVBServicePlay::updateTimeshiftPids()
2262 {
2263         if (!m_record)
2264                 return;
2265
2266         eDVBServicePMTHandler::program program;
2267         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2268
2269         if (h.getProgramInfo(program))
2270                 return;
2271         else
2272         {
2273                 std::set<int> pids_to_record;
2274                 pids_to_record.insert(0); // PAT
2275                 if (program.pmtPid != -1)
2276                         pids_to_record.insert(program.pmtPid); // PMT
2277
2278                 if (program.textPid != -1)
2279                         pids_to_record.insert(program.textPid); // Videotext
2280
2281                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2282                         i(program.videoStreams.begin());
2283                         i != program.videoStreams.end(); ++i)
2284                         pids_to_record.insert(i->pid);
2285
2286                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2287                         i(program.audioStreams.begin());
2288                         i != program.audioStreams.end(); ++i)
2289                                 pids_to_record.insert(i->pid);
2290
2291                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
2292                         i(program.subtitleStreams.begin());
2293                         i != program.subtitleStreams.end(); ++i)
2294                                 pids_to_record.insert(i->pid);
2295
2296                 std::set<int> new_pids, obsolete_pids;
2297
2298                 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
2299                                 m_pids_active.begin(), m_pids_active.end(),
2300                                 std::inserter(new_pids, new_pids.begin()));
2301
2302                 std::set_difference(
2303                                 m_pids_active.begin(), m_pids_active.end(),
2304                                 pids_to_record.begin(), pids_to_record.end(),
2305                                 std::inserter(new_pids, new_pids.begin())
2306                                 );
2307
2308                 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
2309                         m_record->addPID(*i);
2310
2311                 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
2312                         m_record->removePID(*i);
2313         }
2314 }
2315
2316 RESULT eDVBServicePlay::setNextPlaybackFile(const char *f)
2317 {
2318         m_timeshift_file_next = f;
2319         return 0;
2320 }
2321
2322 void eDVBServicePlay::switchToLive()
2323 {
2324         if (!m_timeshift_active)
2325                 return;
2326
2327         eDebug("SwitchToLive");
2328
2329         resetTimeshift(0);
2330
2331         m_is_paused = m_skipmode = m_fastforward = m_slowmotion = 0; /* not supported in live mode */
2332
2333         /* free the timeshift service handler, we need the resources */
2334         m_service_handler_timeshift.free();
2335
2336         updateDecoder(true);
2337 }
2338
2339 void eDVBServicePlay::resetTimeshift(int start)
2340 {
2341         m_cue = 0;
2342         m_decode_demux = 0;
2343         m_decoder = 0;
2344         m_teletext_parser = 0;
2345         m_rds_decoder = 0;
2346         m_subtitle_parser = 0;
2347         m_new_subtitle_page_connection = 0;
2348         m_new_dvb_subtitle_page_connection = 0;
2349         m_rds_decoder_event_connection = 0;
2350         m_video_event_connection = 0;
2351         m_timeshift_changed = 1;
2352         m_timeshift_file_next.clear();
2353
2354         if (start)
2355         {
2356                 m_cue = new eCueSheet();
2357                 m_timeshift_active = 1;
2358         }
2359         else
2360                 m_timeshift_active = 0;
2361 }
2362
2363 ePtr<iTsSource> eDVBServicePlay::createTsSource(eServiceReferenceDVB &ref)
2364 {
2365         eRawFile *f = new eRawFile();
2366         f->open(ref.path.c_str());
2367         return ePtr<iTsSource>(f);
2368 }
2369
2370 void eDVBServicePlay::switchToTimeshift()
2371 {
2372         if (m_timeshift_active)
2373                 return;
2374
2375         resetTimeshift(1);
2376
2377         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
2378         r.path = m_timeshift_file;
2379
2380         m_cue->seekTo(0, -1000);
2381
2382         ePtr<iTsSource> source = createTsSource(r);
2383         m_service_handler_timeshift.tuneExt(r, 1, source, m_timeshift_file.c_str(), m_cue, 0, m_dvb_service); /* use the decoder demux for everything */
2384
2385         eDebug("eDVBServicePlay::switchToTimeshift, in pause mode now.");
2386         pause();
2387         updateDecoder(true); /* mainly to switch off PCR, and to set pause */
2388 }
2389
2390 void eDVBServicePlay::updateDecoder(bool sendSeekableStateChanged)
2391 {
2392         int vpid = -1, vpidtype = -1, pcrpid = -1, tpid = -1, achannel = -1, ac3_delay=-1, pcm_delay=-1;
2393         bool mustPlay = false;
2394
2395         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2396
2397         eDVBServicePMTHandler::program program;
2398         if (h.getProgramInfo(program))
2399                 eDebug("getting program info failed.");
2400         else
2401         {
2402                 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
2403                 if (!program.videoStreams.empty())
2404                 {
2405                         eDebugNoNewLine(" (");
2406                         for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
2407                                 i(program.videoStreams.begin());
2408                                 i != program.videoStreams.end(); ++i)
2409                         {
2410                                 if (vpid == -1)
2411                                 {
2412                                         vpid = i->pid;
2413                                         vpidtype = i->type;
2414                                 }
2415                                 if (i != program.videoStreams.begin())
2416                                         eDebugNoNewLine(", ");
2417                                 eDebugNoNewLine("%04x", i->pid);
2418                         }
2419                         eDebugNoNewLine(")");
2420                 }
2421                 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
2422                 if (!program.audioStreams.empty())
2423                 {
2424                         eDebugNoNewLine(" (");
2425                         for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
2426                                 i(program.audioStreams.begin());
2427                                 i != program.audioStreams.end(); ++i)
2428                         {
2429                                 if (i != program.audioStreams.begin())
2430                                         eDebugNoNewLine(", ");
2431                                 eDebugNoNewLine("%04x", i->pid);
2432                         }
2433                         eDebugNoNewLine(")");
2434                 }
2435                 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
2436                 pcrpid = program.pcrPid;
2437                 eDebug(", and the text pid is %04x", program.textPid);
2438                 tpid = program.textPid;
2439         }
2440
2441         if (!m_decoder)
2442         {
2443                 h.getDecodeDemux(m_decode_demux);
2444                 if (m_decode_demux)
2445                 {
2446                         m_decode_demux->getMPEGDecoder(m_decoder, m_is_primary);
2447                         if (m_decoder)
2448                                 m_decoder->connectVideoEvent(slot(*this, &eDVBServicePlay::video_event), m_video_event_connection);
2449                         if (m_is_primary)
2450                         {
2451                                 m_teletext_parser = new eDVBTeletextParser(m_decode_demux);
2452                                 m_teletext_parser->connectNewPage(slot(*this, &eDVBServicePlay::newSubtitlePage), m_new_subtitle_page_connection);
2453                                 m_subtitle_parser = new eDVBSubtitleParser(m_decode_demux);
2454                                 m_subtitle_parser->connectNewPage(slot(*this, &eDVBServicePlay::newDVBSubtitlePage), m_new_dvb_subtitle_page_connection);
2455                                 if (m_timeshift_changed)
2456                                 {
2457                                         ePyObject subs = getCachedSubtitle();
2458                                         if (subs != Py_None)
2459                                         {
2460                                                 int type = PyInt_AsLong(PyTuple_GET_ITEM(subs, 0)),
2461                                                     pid = PyInt_AsLong(PyTuple_GET_ITEM(subs, 1)),
2462                                                     comp_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 2)), // ttx page
2463                                                     anc_page = PyInt_AsLong(PyTuple_GET_ITEM(subs, 3)); // ttx magazine
2464                                                 if (type == 0) // dvb
2465                                                         m_subtitle_parser->start(pid, comp_page, anc_page);
2466                                                 else if (type == 1) // ttx
2467                                                         m_teletext_parser->setPageAndMagazine(comp_page, anc_page);
2468                                         }
2469                                         Py_DECREF(subs);
2470                                 }
2471                         }
2472                 }
2473                 if (m_cue)
2474                         m_cue->setDecodingDemux(m_decode_demux, m_decoder);
2475                 mustPlay = true;
2476         }
2477
2478         m_timeshift_changed = 0;
2479
2480         if (m_decoder)
2481         {
2482                 bool wasSeekable = m_decoder->getVideoProgressive() != -1;
2483                 if (m_dvb_service)
2484                 {
2485                         achannel = m_dvb_service->getCacheEntry(eDVBService::cACHANNEL);
2486                         ac3_delay = m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
2487                         pcm_delay = m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
2488                 }
2489                 else // subservice
2490                 {
2491                         eServiceReferenceDVB ref;
2492                         m_service_handler.getServiceReference(ref);
2493                         eServiceReferenceDVB parent = ref.getParentServiceReference();
2494                         if (!parent)
2495                                 parent = ref;
2496                         if (parent)
2497                         {
2498                                 ePtr<eDVBResourceManager> res_mgr;
2499                                 if (!eDVBResourceManager::getInstance(res_mgr))
2500                                 {
2501                                         ePtr<iDVBChannelList> db;
2502                                         if (!res_mgr->getChannelList(db))
2503                                         {
2504                                                 ePtr<eDVBService> origService;
2505                                                 if (!db->getService(parent, origService))
2506                                                 {
2507                                                         ac3_delay = origService->getCacheEntry(eDVBService::cAC3DELAY);
2508                                                         pcm_delay = origService->getCacheEntry(eDVBService::cPCMDELAY);
2509                                                 }
2510                                         }
2511                                 }
2512                         }
2513                 }
2514
2515                 setAC3Delay(ac3_delay == -1 ? 0 : ac3_delay);
2516                 setPCMDelay(pcm_delay == -1 ? 0 : pcm_delay);
2517
2518                 m_decoder->setVideoPID(vpid, vpidtype);
2519                 selectAudioStream();
2520
2521                 if (!(m_is_pvr || m_timeshift_active || !m_is_primary))
2522                         m_decoder->setSyncPCR(pcrpid);
2523                 else
2524                         m_decoder->setSyncPCR(-1);
2525
2526                 if (m_is_primary)
2527                 {
2528                         m_decoder->setTextPID(tpid);
2529                         m_teletext_parser->start(program.textPid);
2530                 }
2531
2532                 if (vpid > 0 && vpid < 0x2000)
2533                         ;
2534                 else
2535                 {
2536                         std::string radio_pic;
2537                         if (!ePythonConfigQuery::getConfigValue("config.misc.radiopic", radio_pic))
2538                                 m_decoder->setRadioPic(radio_pic);
2539                 }
2540
2541                 if (mustPlay)
2542                         m_decoder->play();
2543                 else
2544                         m_decoder->set();
2545
2546                 m_decoder->setAudioChannel(achannel);
2547
2548                 /* don't worry about non-existing services, nor pvr services */
2549                 if (m_dvb_service)
2550                 {
2551                                 /* (audio pid will be set in selectAudioTrack */
2552                         m_dvb_service->setCacheEntry(eDVBService::cVPID, vpid);
2553                         m_dvb_service->setCacheEntry(eDVBService::cVTYPE, vpidtype == eDVBVideo::MPEG2 ? -1 : vpidtype);
2554                         m_dvb_service->setCacheEntry(eDVBService::cPCRPID, pcrpid);
2555                         m_dvb_service->setCacheEntry(eDVBService::cTPID, tpid);
2556                 }
2557                 if (!sendSeekableStateChanged && (m_decoder->getVideoProgressive() != -1) != wasSeekable)
2558                         sendSeekableStateChanged = true;
2559         }
2560         m_have_video_pid = (vpid > 0 && vpid < 0x2000);
2561
2562         if (sendSeekableStateChanged)
2563                 m_event((iPlayableService*)this, evSeekableStatusChanged);
2564 }
2565
2566 void eDVBServicePlay::loadCuesheet()
2567 {
2568         std::string filename = m_reference.path + ".cuts";
2569
2570         m_cue_entries.clear();
2571
2572         FILE *f = fopen(filename.c_str(), "rb");
2573
2574         if (f)
2575         {
2576                 eDebug("loading cuts..");
2577                 while (1)
2578                 {
2579                         unsigned long long where;
2580                         unsigned int what;
2581
2582                         if (!fread(&where, sizeof(where), 1, f))
2583                                 break;
2584                         if (!fread(&what, sizeof(what), 1, f))
2585                                 break;
2586
2587 #if BYTE_ORDER == LITTLE_ENDIAN
2588                         where = bswap_64(where);
2589 #endif
2590                         what = ntohl(what);
2591
2592                         if (what > 3)
2593                                 break;
2594
2595                         m_cue_entries.insert(cueEntry(where, what));
2596                 }
2597                 fclose(f);
2598                 eDebug("%d entries", m_cue_entries.size());
2599         } else
2600                 eDebug("cutfile not found!");
2601
2602         m_cuesheet_changed = 0;
2603         cutlistToCuesheet();
2604         m_event((iPlayableService*)this, evCuesheetChanged);
2605 }
2606
2607 void eDVBServicePlay::saveCuesheet()
2608 {
2609         std::string filename = m_reference.path + ".cuts";
2610
2611         FILE *f = fopen(filename.c_str(), "wb");
2612
2613         if (f)
2614         {
2615                 unsigned long long where;
2616                 int what;
2617
2618                 for (std::multiset<cueEntry>::iterator i(m_cue_entries.begin()); i != m_cue_entries.end(); ++i)
2619                 {
2620 #if BYTE_ORDER == BIG_ENDIAN
2621                         where = i->where;
2622 #else
2623                         where = bswap_64(i->where);
2624 #endif
2625                         what = htonl(i->what);
2626                         fwrite(&where, sizeof(where), 1, f);
2627                         fwrite(&what, sizeof(what), 1, f);
2628
2629                 }
2630                 fclose(f);
2631         }
2632
2633         m_cuesheet_changed = 0;
2634 }
2635
2636 void eDVBServicePlay::cutlistToCuesheet()
2637 {
2638         if (!m_cue)
2639         {
2640                 eDebug("no cue sheet");
2641                 return;
2642         }
2643         m_cue->clear();
2644
2645         if (!m_cutlist_enabled)
2646         {
2647                 m_cue->commitSpans();
2648                 eDebug("cutlists were disabled");
2649                 return;
2650         }
2651
2652         pts_t in = 0, out = 0, length = 0;
2653
2654         getLength(length);
2655
2656         std::multiset<cueEntry>::iterator i(m_cue_entries.begin());
2657
2658         int have_any_span = 0;
2659
2660         while (1)
2661         {
2662                 if (i == m_cue_entries.end())
2663                 {
2664                         if (!have_any_span && !in)
2665                                 break;
2666                         out = length;
2667                 } else {
2668                         if (i->what == 0) /* in */
2669                         {
2670                                 in = i++->where;
2671                                 continue;
2672                         } else if (i->what == 1) /* out */
2673                                 out = i++->where;
2674                         else /* mark (2) or last play position (3) */
2675                         {
2676                                 i++;
2677                                 continue;
2678                         }
2679                 }
2680
2681                 if (in < 0)
2682                         in = 0;
2683                 if (out < 0)
2684                         out = 0;
2685                 if (in > length)
2686                         in = length;
2687                 if (out > length)
2688                         out = length;
2689
2690                 if (in < out)
2691                 {
2692                         have_any_span = 1;
2693                         m_cue->addSourceSpan(in, out);
2694                         in = out = 0;
2695                 }
2696
2697                 in = length;
2698
2699                 if (i == m_cue_entries.end())
2700                         break;
2701         }
2702         m_cue->commitSpans();
2703 }
2704
2705 RESULT eDVBServicePlay::enableSubtitles(eWidget *parent, ePyObject tuple)
2706 {
2707         if (m_subtitle_widget)
2708                 disableSubtitles(parent);
2709
2710         ePyObject entry;
2711         int tuplesize = PyTuple_Size(tuple);
2712         int type = 0;
2713
2714         if (!PyTuple_Check(tuple))
2715                 goto error_out;
2716
2717         if (tuplesize < 1)
2718                 goto error_out;
2719
2720         entry = PyTuple_GET_ITEM(tuple, 0);
2721
2722         if (!PyInt_Check(entry))
2723                 goto error_out;
2724
2725         type = PyInt_AsLong(entry);
2726
2727         if (type == 1)  // teletext subtitles
2728         {
2729                 int page, magazine, pid;
2730                 if (tuplesize < 4)
2731                         goto error_out;
2732
2733                 if (!m_teletext_parser)
2734                 {
2735                         eDebug("enable teletext subtitles.. no parser !!!");
2736                         return -1;
2737                 }
2738
2739                 entry = PyTuple_GET_ITEM(tuple, 1);
2740                 if (!PyInt_Check(entry))
2741                         goto error_out;
2742                 pid = PyInt_AsLong(entry);
2743
2744                 entry = PyTuple_GET_ITEM(tuple, 2);
2745                 if (!PyInt_Check(entry))
2746                         goto error_out;
2747                 page = PyInt_AsLong(entry);
2748
2749                 entry = PyTuple_GET_ITEM(tuple, 3);
2750                 if (!PyInt_Check(entry))
2751                         goto error_out;
2752                 magazine = PyInt_AsLong(entry);
2753
2754                 m_subtitle_widget = new eSubtitleWidget(parent);
2755                 m_subtitle_widget->resize(parent->size()); /* full size */
2756                 m_teletext_parser->setPageAndMagazine(page, magazine);
2757                 if (m_dvb_service)
2758                         m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE,((pid&0xFFFF)<<16)|((page&0xFF)<<8)|(magazine&0xFF));
2759         }
2760         else if (type == 0)
2761         {
2762                 int pid = 0, composition_page_id = 0, ancillary_page_id = 0;
2763                 if (!m_subtitle_parser)
2764                 {
2765                         eDebug("enable dvb subtitles.. no parser !!!");
2766                         return -1;
2767                 }
2768                 if (tuplesize < 4)
2769                         goto error_out;
2770
2771                 entry = PyTuple_GET_ITEM(tuple, 1);
2772                 if (!PyInt_Check(entry))
2773                         goto error_out;
2774                 pid = PyInt_AsLong(entry);
2775
2776                 entry = PyTuple_GET_ITEM(tuple, 2);
2777                 if (!PyInt_Check(entry))
2778                         goto error_out;
2779                 composition_page_id = PyInt_AsLong(entry);
2780
2781                 entry = PyTuple_GET_ITEM(tuple, 3);
2782                 if (!PyInt_Check(entry))
2783                         goto error_out;
2784                 ancillary_page_id = PyInt_AsLong(entry);
2785
2786                 m_subtitle_widget = new eSubtitleWidget(parent);
2787                 m_subtitle_widget->resize(parent->size()); /* full size */
2788                 m_subtitle_parser->start(pid, composition_page_id, ancillary_page_id);
2789                 if (m_dvb_service)
2790                         m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, ((pid&0xFFFF)<<16)|((composition_page_id&0xFF)<<8)|(ancillary_page_id&0xFF));
2791         }
2792         else
2793                 goto error_out;
2794         return 0;
2795 error_out:
2796         eDebug("enableSubtitles needs a tuple as 2nd argument!\n"
2797                 "for teletext subtitles (0, pid, teletext_page, teletext_magazine)\n"
2798                 "for dvb subtitles (1, pid, composition_page_id, ancillary_page_id)");
2799         return -1;
2800 }
2801
2802 RESULT eDVBServicePlay::disableSubtitles(eWidget *parent)
2803 {
2804         delete m_subtitle_widget;
2805         m_subtitle_widget = 0;
2806         if (m_subtitle_parser)
2807         {
2808                 m_subtitle_parser->stop();
2809                 m_dvb_subtitle_pages.clear();
2810         }
2811         if (m_teletext_parser)
2812         {
2813                 m_teletext_parser->setPageAndMagazine(-1, -1);
2814                 m_subtitle_pages.clear();
2815         }
2816         if (m_dvb_service)
2817                 m_dvb_service->setCacheEntry(eDVBService::cSUBTITLE, -1);
2818         return 0;
2819 }
2820
2821 PyObject *eDVBServicePlay::getCachedSubtitle()
2822 {
2823         if (m_dvb_service)
2824         {
2825                 int tmp = m_dvb_service->getCacheEntry(eDVBService::cSUBTITLE);
2826                 if (tmp != -1)
2827                 {
2828                         unsigned int data = (unsigned int)tmp;
2829                         int pid = (data&0xFFFF0000)>>16;
2830                         ePyObject tuple = PyTuple_New(4);
2831                         eDVBServicePMTHandler::program program;
2832                         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2833                         if (!h.getProgramInfo(program))
2834                         {
2835                                 if (program.textPid==pid) // teletext
2836                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1)); // type teletext
2837                                 else
2838                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0)); // type dvb
2839                                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(pid)); // pid
2840                                 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong((data&0xFF00)>>8)); // composition_page / page
2841                                 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(data&0xFF)); // ancillary_page / magazine
2842                                 return tuple;
2843                         }
2844                 }
2845         }
2846         Py_RETURN_NONE;
2847 }
2848
2849 PyObject *eDVBServicePlay::getSubtitleList()
2850 {
2851         if (!m_teletext_parser)
2852                 Py_RETURN_NONE;
2853
2854         ePyObject l = PyList_New(0);
2855         std::set<int> added_ttx_pages;
2856
2857         std::set<eDVBServicePMTHandler::subtitleStream> &subs =
2858                 m_teletext_parser->m_found_subtitle_pages;
2859
2860         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
2861         eDVBServicePMTHandler::program program;
2862         if (h.getProgramInfo(program))
2863                 eDebug("getting program info failed.");
2864         else
2865         {
2866                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::iterator it(program.subtitleStreams.begin());
2867                         it != program.subtitleStreams.end(); ++it)
2868                 {
2869                         switch(it->subtitling_type)
2870                         {
2871                                 case 0x01: // ebu teletext subtitles
2872                                 {
2873                                         int page_number = it->teletext_page_number & 0xFF;
2874                                         int magazine_number = it->teletext_magazine_number & 7;
2875                                         int hash = magazine_number << 8 | page_number;
2876                                         if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2877                                         {
2878                                                 ePyObject tuple = PyTuple_New(5);
2879                                                 PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2880                                                 PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2881                                                 PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2882                                                 PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2883                                                 PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2884                                                 PyList_Append(l, tuple);
2885                                                 Py_DECREF(tuple);
2886                                                 added_ttx_pages.insert(hash);
2887                                         }
2888                                         break;
2889                                 }
2890                                 case 0x10 ... 0x13:
2891                                 case 0x20 ... 0x23: // dvb subtitles
2892                                 {
2893                                         ePyObject tuple = PyTuple_New(5);
2894                                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(0));
2895                                         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2896                                         PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(it->composition_page_id));
2897                                         PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(it->ancillary_page_id));
2898                                         PyTuple_SET_ITEM(tuple, 4, PyString_FromString(it->language_code.c_str()));
2899                                         PyList_Insert(l, 0, tuple);
2900                                         Py_DECREF(tuple);
2901                                         break;
2902                                 }
2903                         }
2904                 }
2905         }
2906
2907         for (std::set<eDVBServicePMTHandler::subtitleStream>::iterator it(subs.begin());
2908                 it != subs.end(); ++it)
2909         {
2910                 int page_number = it->teletext_page_number & 0xFF;
2911                 int magazine_number = it->teletext_magazine_number & 7;
2912                 int hash = magazine_number << 8 | page_number;
2913                 if (added_ttx_pages.find(hash) == added_ttx_pages.end())
2914                 {
2915                         ePyObject tuple = PyTuple_New(5);
2916                         PyTuple_SET_ITEM(tuple, 0, PyInt_FromLong(1));
2917                         PyTuple_SET_ITEM(tuple, 1, PyInt_FromLong(it->pid));
2918                         PyTuple_SET_ITEM(tuple, 2, PyInt_FromLong(page_number));
2919                         PyTuple_SET_ITEM(tuple, 3, PyInt_FromLong(magazine_number));
2920                         PyTuple_SET_ITEM(tuple, 4, PyString_FromString("und"));  // undetermined
2921                         PyList_Append(l, tuple);
2922                         Py_DECREF(tuple);
2923                 }
2924         }
2925
2926         return l;
2927 }
2928
2929 void eDVBServicePlay::newSubtitlePage(const eDVBTeletextSubtitlePage &page)
2930 {
2931         if (m_subtitle_widget)
2932         {
2933                 pts_t pos = 0;
2934                 if (m_decoder)
2935                         m_decoder->getPTS(0, pos);
2936                 eDebug("got new subtitle page %lld %lld %d", pos, page.m_pts, page.m_have_pts);
2937                 m_subtitle_pages.push_back(page);
2938                 checkSubtitleTiming();
2939         }
2940 }
2941
2942 void eDVBServicePlay::checkSubtitleTiming()
2943 {
2944         eDebug("checkSubtitleTiming");
2945         if (!m_subtitle_widget)
2946                 return;
2947         while (1)
2948         {
2949                 enum { TELETEXT, DVB } type;
2950                 eDVBTeletextSubtitlePage page;
2951                 eDVBSubtitlePage dvb_page;
2952                 pts_t show_time;
2953                 if (!m_subtitle_pages.empty())
2954                 {
2955                         page = m_subtitle_pages.front();
2956                         type = TELETEXT;
2957                         show_time = page.m_pts;
2958                 }
2959                 else if (!m_dvb_subtitle_pages.empty())
2960                 {
2961                         dvb_page = m_dvb_subtitle_pages.front();
2962                         type = DVB;
2963                         show_time = dvb_page.m_show_time;
2964                 }
2965                 else
2966                         return;
2967
2968                 pts_t pos = 0;
2969
2970                 if (m_decoder)
2971                         m_decoder->getPTS(0, pos);
2972
2973                 eDebug("%lld %lld", pos, show_time);
2974                 int diff = show_time - pos;
2975                 if (type == TELETEXT && !page.m_have_pts)
2976                 {
2977                         eDebug("ttx subtitle page without pts... immediate show");
2978                         diff = 0;
2979                 }
2980                 if (diff < 0)
2981                 {
2982                         eDebug("[late (%d ms)]", -diff / 90);
2983                         diff = 0;
2984                 }
2985                 if (abs(diff) > 1800000)
2986                 {
2987                         eDebug("[invalid]... immediate show!");
2988                         diff = 0;
2989                 }
2990                 if ((diff/90)<20)
2991                 {
2992                         if (type == TELETEXT)
2993                         {
2994                                 eDebug("display teletext subtitle page %lld", show_time);
2995                                 m_subtitle_widget->setPage(page);
2996                                 m_subtitle_pages.pop_front();
2997                         }
2998                         else
2999                         {
3000                                 eDebug("display dvb subtitle Page %lld", show_time);
3001                                 m_subtitle_widget->setPage(dvb_page);
3002                                 m_dvb_subtitle_pages.pop_front();
3003                         }
3004                 } else
3005                 {
3006                         eDebug("start subtitle delay %d", diff / 90);
3007                         m_subtitle_sync_timer->start(diff / 90, 1);
3008                         break;
3009                 }
3010         }
3011 }
3012
3013 void eDVBServicePlay::newDVBSubtitlePage(const eDVBSubtitlePage &p)
3014 {
3015         if (m_subtitle_widget)
3016         {
3017                 pts_t pos = 0;
3018                 if (m_decoder)
3019                         m_decoder->getPTS(0, pos);
3020                 eDebug("got new subtitle page %lld %lld", pos, p.m_show_time);
3021                 m_dvb_subtitle_pages.push_back(p);
3022                 checkSubtitleTiming();
3023         }
3024 }
3025
3026 int eDVBServicePlay::getAC3Delay()
3027 {
3028         if (m_dvb_service)
3029                 return m_dvb_service->getCacheEntry(eDVBService::cAC3DELAY);
3030         else if (m_decoder)
3031                 return m_decoder->getAC3Delay();
3032         else
3033                 return 0;
3034 }
3035
3036 int eDVBServicePlay::getPCMDelay()
3037 {
3038         if (m_dvb_service)
3039                 return m_dvb_service->getCacheEntry(eDVBService::cPCMDELAY);
3040         else if (m_decoder)
3041                 return m_decoder->getPCMDelay();
3042         else
3043                 return 0;
3044 }
3045
3046 void eDVBServicePlay::setAC3Delay(int delay)
3047 {
3048         if (m_dvb_service)
3049                 m_dvb_service->setCacheEntry(eDVBService::cAC3DELAY, delay ? delay : -1);
3050         if (m_decoder) {
3051                 std::string config_delay;
3052                 int config_delay_int = 0;
3053                 if(ePythonConfigQuery::getConfigValue("config.av.generalAC3delay", config_delay) == 0)
3054                         config_delay_int = atoi(config_delay.c_str());
3055                 m_decoder->setAC3Delay(delay + config_delay_int);
3056         }
3057 }
3058
3059 void eDVBServicePlay::setPCMDelay(int delay)
3060 {
3061         if (m_dvb_service)
3062                 m_dvb_service->setCacheEntry(eDVBService::cPCMDELAY, delay ? delay : -1);
3063         if (m_decoder) {
3064                 std::string config_delay;
3065                 int config_delay_int = 0;
3066                 if(ePythonConfigQuery::getConfigValue("config.av.generalPCMdelay", config_delay) == 0)
3067                         config_delay_int = atoi(config_delay.c_str());
3068                 else
3069                         config_delay_int = 0;
3070                 m_decoder->setPCMDelay(delay + config_delay_int);
3071         }
3072 }
3073
3074 void eDVBServicePlay::video_event(struct iTSMPEGDecoder::videoEvent event)
3075 {
3076         switch(event.type) {
3077                 case iTSMPEGDecoder::videoEvent::eventSizeChanged:
3078                         m_event((iPlayableService*)this, evVideoSizeChanged);
3079                         break;
3080                 case iTSMPEGDecoder::videoEvent::eventFrameRateChanged:
3081                         m_event((iPlayableService*)this, evVideoFramerateChanged);
3082                         break;
3083                 case iTSMPEGDecoder::videoEvent::eventProgressiveChanged:
3084                         m_event((iPlayableService*)this, evVideoProgressiveChanged);
3085                         break;
3086                 default:
3087                         break;
3088         }
3089 }
3090
3091 RESULT eDVBServicePlay::stream(ePtr<iStreamableService> &ptr)
3092 {
3093         ptr = this;
3094         return 0;
3095 }
3096
3097 PyObject *eDVBServicePlay::getStreamingData()
3098 {
3099         eDVBServicePMTHandler::program program;
3100         if (m_service_handler.getProgramInfo(program))
3101         {
3102                 Py_RETURN_NONE;
3103         }
3104
3105         ePyObject r = program.createPythonObject();
3106         ePtr<iDVBDemux> demux;
3107         if (!m_service_handler.getDataDemux(demux))
3108         {
3109                 uint8_t demux_id;
3110                 if (!demux->getCADemuxID(demux_id))
3111                         PutToDict(r, "demux", demux_id);
3112         }
3113
3114         return r;
3115 }
3116
3117
3118 DEFINE_REF(eDVBServicePlay)
3119
3120 PyObject *eDVBService::getInfoObject(const eServiceReference &ref, int w)
3121 {
3122         switch (w)
3123         {
3124         case iServiceInformation::sTransponderData:
3125                 return eStaticServiceDVBInformation().getInfoObject(ref, w);
3126         default:
3127                 break;
3128         }
3129         return iStaticServiceInformation::getInfoObject(ref, w);
3130 }
3131
3132 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");