lib/service/servicedvb.cpp

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