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

   1 #include <lib/base/eerror.h>
   2 #include <lib/base/object.h>
   3 #include <string>
   4 #include <lib/service/servicedvb.h>
   5 #include <lib/service/service.h>
   6 #include <lib/base/init_num.h>
   7 #include <lib/base/init.h>
   8
   9 #include <lib/dvb/dvb.h>
  10 #include <lib/dvb/db.h>
  11 #include <lib/dvb/decoder.h>
  12
  13 #include <lib/service/servicedvbrecord.h>
  14 #include <lib/dvb/metaparser.h>
  15 #include <lib/dvb/tstools.h>
  16
  17 class eStaticServiceDVBInformation: public iStaticServiceInformation
  18 {
  19         DECLARE_REF(eStaticServiceDVBInformation);
  20 public:
  21         RESULT getName(const eServiceReference &ref, std::string &name);
  22         int getLength(const eServiceReference &ref);
  23 };
  24
  25 DEFINE_REF(eStaticServiceDVBInformation);
  26
  27 RESULT eStaticServiceDVBInformation::getName(const eServiceReference &ref, std::string &name)
  28 {
  29         eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
  30         if ( !ref.name.empty() )
  31         {
  32                 if (service.getParentTransportStreamID().get()) // linkage subservice
  33                 {
  34                         ePtr<iServiceHandler> service_center;
  35                         if (!eServiceCenter::getInstance(service_center))
  36                         {
  37                                 eServiceReferenceDVB parent = service;
  38                                 parent.setTransportStreamID( service.getParentTransportStreamID() );
  39                                 parent.setServiceID( service.getParentServiceID() );
  40                                 parent.setParentTransportStreamID(eTransportStreamID(0));
  41                                 parent.setParentServiceID(eServiceID(0));
  42                                 parent.name="";
  43                                 ePtr<iStaticServiceInformation> service_info;
  44                                 if (!service_center->info(parent, service_info))
  45                                 {
  46                                         if (!service_info->getName(parent, name))
  47                                         {
  48                                                 // just show short name
  49                                                 unsigned int pos = name.find("\xc2\x86");
  50                                                 if ( pos != std::string::npos )
  51                                                         name.erase(0, pos+2);
  52                                                 pos = name.find("\xc2\x87");
  53                                                 if ( pos != std::string::npos )
  54                                                         name.erase(pos);
  55                                                 name+=" - ";
  56                                         }
  57                                 }
  58                         }
  59                 }
  60                 else
  61                         name="";
  62                 name += ref.name;
  63                 return 0;
  64         }
  65         else
  66                 return -1;
  67 }
  68
  69 int eStaticServiceDVBInformation::getLength(const eServiceReference &ref)
  70 {
  71         return -1;
  72 }
  73
  74 class eStaticServiceDVBBouquetInformation: public iStaticServiceInformation
  75 {
  76         DECLARE_REF(eStaticServiceDVBBouquetInformation);
  77 public:
  78         RESULT getName(const eServiceReference &ref, std::string &name);
  79         int getLength(const eServiceReference &ref);
  80 };
  81
  82 DEFINE_REF(eStaticServiceDVBBouquetInformation);
  83
  84 RESULT eStaticServiceDVBBouquetInformation::getName(const eServiceReference &ref, std::string &name)
  85 {
  86         ePtr<iDVBChannelList> db;
  87         ePtr<eDVBResourceManager> res;
  88
  89         int err;
  90         if ((err = eDVBResourceManager::getInstance(res)) != 0)
  91         {
  92                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no resource manager!");
  93                 return err;
  94         }
  95         if ((err = res->getChannelList(db)) != 0)
  96         {
  97                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. no channel list!");
  98                 return err;
  99         }
 100
 101         eBouquet *bouquet=0;
 102         if ((err = db->getBouquet(ref, bouquet)) != 0)
 103         {
 104                 eDebug("eStaticServiceDVBBouquetInformation::getName failed.. getBouquet failed!");
 105                 return -1;
 106         }
 107
 108         if ( bouquet && bouquet->m_bouquet_name.length() )
 109         {
 110                 name = bouquet->m_bouquet_name;
 111                 return 0;
 112         }
 113         else
 114                 return -1;
 115 }
 116
 117 int eStaticServiceDVBBouquetInformation::getLength(const eServiceReference &ref)
 118 {
 119         return -1;
 120 }
 121
 122 class eStaticServiceDVBPVRInformation: public iStaticServiceInformation
 123 {
 124         DECLARE_REF(eStaticServiceDVBPVRInformation);
 125         eServiceReference m_ref;
 126         eDVBMetaParser m_parser;
 127 public:
 128         eStaticServiceDVBPVRInformation(const eServiceReference &ref);
 129         RESULT getName(const eServiceReference &ref, std::string &name);
 130         int getLength(const eServiceReference &ref);
 131
 132         int getInfo(const eServiceReference &ref, int w);
 133         std::string getInfoString(const eServiceReference &ref,int w);
 134 };
 135
 136 DEFINE_REF(eStaticServiceDVBPVRInformation);
 137
 138 eStaticServiceDVBPVRInformation::eStaticServiceDVBPVRInformation(const eServiceReference &ref)
 139 {
 140         m_ref = ref;
 141         m_parser.parseFile(ref.path);
 142 }
 143
 144 RESULT eStaticServiceDVBPVRInformation::getName(const eServiceReference &ref, std::string &name)
 145 {
 146         ASSERT(ref == m_ref);
 147         name = m_parser.m_name.size() ? m_parser.m_name : ref.path;
 148         return 0;
 149 }
 150
 151 int eStaticServiceDVBPVRInformation::getLength(const eServiceReference &ref)
 152 {
 153         ASSERT(ref == m_ref);
 154
 155         eDVBTSTools tstools;
 156
 157         if (tstools.openFile(ref.path.c_str()))
 158                 return 0;
 159
 160         pts_t len;
 161         if (tstools.calcLen(len))
 162                 return 0;
 163
 164         return len / 90000;
 165 }
 166
 167 int eStaticServiceDVBPVRInformation::getInfo(const eServiceReference &ref, int w)
 168 {
 169         switch (w)
 170         {
 171         case iServiceInformation::sDescription:
 172                 return iServiceInformation::resIsString;
 173         case iServiceInformation::sTimeCreate:
 174                 if (m_parser.m_time_create)
 175                         return m_parser.m_time_create;
 176                 else
 177                         return iServiceInformation::resNA;
 178         default:
 179                 return iServiceInformation::resNA;
 180         }
 181 }
 182
 183 std::string eStaticServiceDVBPVRInformation::getInfoString(const eServiceReference &ref,int w)
 184 {
 185         switch (w)
 186         {
 187         case iServiceInformation::sDescription:
 188                 return m_parser.m_description;
 189         default:
 190                 return "";
 191         }
 192 }
 193
 194 class eDVBPVRServiceOfflineOperations: public iServiceOfflineOperations
 195 {
 196         DECLARE_REF(eDVBPVRServiceOfflineOperations);
 197         eServiceReferenceDVB m_ref;
 198 public:
 199         eDVBPVRServiceOfflineOperations(const eServiceReference &ref);
 200
 201         RESULT deleteFromDisk(int simulate);
 202         RESULT getListOfFilenames(std::list<std::string> &);
 203 };
 204
 205 DEFINE_REF(eDVBPVRServiceOfflineOperations);
 206
 207 eDVBPVRServiceOfflineOperations::eDVBPVRServiceOfflineOperations(const eServiceReference &ref): m_ref((const eServiceReferenceDVB&)ref)
 208 {
 209 }
 210
 211 RESULT eDVBPVRServiceOfflineOperations::deleteFromDisk(int simulate)
 212 {
 213         if (simulate)
 214                 return 0;
 215         else
 216         {
 217                 std::list<std::string> res;
 218                 if (getListOfFilenames(res))
 219                         return -1;
 220
 221                                 /* TODO: deferred removing.. */
 222                 for (std::list<std::string>::iterator i(res.begin()); i != res.end(); ++i)
 223                 {
 224                         eDebug("Removing %s...", i->c_str());
 225                         ::unlink(i->c_str());
 226                 }
 227
 228                 return 0;
 229         }
 230 }
 231
 232 RESULT eDVBPVRServiceOfflineOperations::getListOfFilenames(std::list<std::string> &res)
 233 {
 234         res.clear();
 235         res.push_back(m_ref.path);
 236         res.push_back(m_ref.path + ".meta");
 237         return 0;
 238 }
 239
 240 DEFINE_REF(eServiceFactoryDVB)
 241
 242 eServiceFactoryDVB::eServiceFactoryDVB()
 243 {
 244         ePtr<eServiceCenter> sc;
 245
 246         eServiceCenter::getPrivInstance(sc);
 247         if (sc)
 248                 sc->addServiceFactory(eServiceFactoryDVB::id, this);
 249 }
 250
 251 eServiceFactoryDVB::~eServiceFactoryDVB()
 252 {
 253         ePtr<eServiceCenter> sc;
 254
 255         eServiceCenter::getPrivInstance(sc);
 256         if (sc)
 257                 sc->removeServiceFactory(eServiceFactoryDVB::id);
 258 }
 259
 260 DEFINE_REF(eDVBServiceList);
 261
 262 eDVBServiceList::eDVBServiceList(const eServiceReference &parent): m_parent(parent)
 263 {
 264 }
 265
 266 eDVBServiceList::~eDVBServiceList()
 267 {
 268 }
 269
 270 RESULT eDVBServiceList::startQuery()
 271 {
 272         ePtr<iDVBChannelList> db;
 273         ePtr<eDVBResourceManager> res;
 274
 275         int err;
 276         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 277         {
 278                 eDebug("no resource manager");
 279                 return err;
 280         }
 281         if ((err = res->getChannelList(db)) != 0)
 282         {
 283                 eDebug("no channel list");
 284                 return err;
 285         }
 286
 287         ePtr<eDVBChannelQuery> q;
 288
 289         if (!m_parent.path.empty())
 290         {
 291                 eDVBChannelQuery::compile(q, m_parent.path);
 292                 if (!q)
 293                 {
 294                         eDebug("compile query failed");
 295                         return err;
 296                 }
 297         }
 298
 299         if ((err = db->startQuery(m_query, q, m_parent)) != 0)
 300         {
 301                 eDebug("startQuery failed");
 302                 return err;
 303         }
 304
 305         return 0;
 306 }
 307
 308 RESULT eDVBServiceList::getContent(std::list<eServiceReference> &list)
 309 {
 310         eServiceReferenceDVB ref;
 311
 312         if (!m_query)
 313                 return -1;
 314
 315         while (!m_query->getNextResult(ref))
 316                 list.push_back(ref);
 317         return 0;
 318 }
 319
 320 RESULT eDVBServiceList::getNext(eServiceReference &ref)
 321 {
 322         if (!m_query)
 323                 return -1;
 324
 325         return m_query->getNextResult((eServiceReferenceDVB&)ref);
 326 }
 327
 328 int eDVBServiceList::compareLessEqual(const eServiceReference &a, const eServiceReference &b)
 329 {
 330         return m_query->compareLessEqual((const eServiceReferenceDVB&)a, (const eServiceReferenceDVB&)b);
 331 }
 332
 333 RESULT eDVBServiceList::startEdit(ePtr<iMutableServiceList> &res)
 334 {
 335         if (m_parent.flags & eServiceReference::flagDirectory) // bouquet
 336         {
 337                 ePtr<iDVBChannelList> db;
 338                 ePtr<eDVBResourceManager> resm;
 339
 340                 if (eDVBResourceManager::getInstance(resm) || resm->getChannelList(db))
 341                         return -1;
 342
 343                 if (db->getBouquet(m_parent, m_bouquet) != 0)
 344                         return -1;
 345
 346                 res = this;
 347
 348                 return 0;
 349         }
 350         res = 0;
 351         return -1;
 352 }
 353
 354 RESULT eDVBServiceList::addService(eServiceReference &ref)
 355 {
 356         if (!m_bouquet)
 357                 return -1;
 358         return m_bouquet->addService(ref);
 359 }
 360
 361 RESULT eDVBServiceList::removeService(eServiceReference &ref)
 362 {
 363         if (!m_bouquet)
 364                 return -1;
 365         return m_bouquet->removeService(ref);
 366 }
 367
 368 RESULT eDVBServiceList::moveService(eServiceReference &ref, int pos)
 369 {
 370         if (!m_bouquet)
 371                 return -1;
 372         return m_bouquet->moveService(ref, pos);
 373 }
 374
 375 RESULT eDVBServiceList::flushChanges()
 376 {
 377         if (!m_bouquet)
 378                 return -1;
 379         return m_bouquet->flushChanges();
 380 }
 381
 382 RESULT eServiceFactoryDVB::play(const eServiceReference &ref, ePtr<iPlayableService> &ptr)
 383 {
 384         ePtr<eDVBService> service;
 385         int r = lookupService(service, ref);
 386         if (r)
 387                 service = 0;
 388                 // check resources...
 389         ptr = new eDVBServicePlay(ref, service);
 390         return 0;
 391 }
 392
 393 RESULT eServiceFactoryDVB::record(const eServiceReference &ref, ePtr<iRecordableService> &ptr)
 394 {
 395         if (ref.path.empty())
 396         {
 397                 ptr = new eDVBServiceRecord((eServiceReferenceDVB&)ref);
 398                 return 0;
 399         } else
 400         {
 401                 ptr = 0;
 402                 return -1;
 403         }
 404 }
 405
 406 RESULT eServiceFactoryDVB::list(const eServiceReference &ref, ePtr<iListableService> &ptr)
 407 {
 408         ePtr<eDVBServiceList> list = new eDVBServiceList(ref);
 409         if (list->startQuery())
 410         {
 411                 ptr = 0;
 412                 return -1;
 413         }
 414
 415         ptr = list;
 416         return 0;
 417 }
 418
 419 RESULT eServiceFactoryDVB::info(const eServiceReference &ref, ePtr<iStaticServiceInformation> &ptr)
 420 {
 421         /* is a listable service? */
 422         if ((ref.flags & eServiceReference::flagDirectory) == eServiceReference::flagDirectory) // bouquet
 423         {
 424                 if ( !ref.name.empty() )  // satellites or providers list
 425                         ptr = new eStaticServiceDVBInformation;
 426                 else // a dvb bouquet
 427                         ptr = new eStaticServiceDVBBouquetInformation;
 428         }
 429         else if (!ref.path.empty()) /* do we have a PVR service? */
 430                 ptr = new eStaticServiceDVBPVRInformation(ref);
 431         else // normal dvb service
 432         {
 433                 ePtr<eDVBService> service;
 434                 if (lookupService(service, ref)) // no eDVBService avail for this reference ( Linkage Services... )
 435                         ptr = new eStaticServiceDVBInformation;
 436                 else
 437                         /* eDVBService has the iStaticServiceInformation interface, so we pass it here. */
 438                         ptr = service;
 439         }
 440         return 0;
 441 }
 442
 443 RESULT eServiceFactoryDVB::offlineOperations(const eServiceReference &ref, ePtr<iServiceOfflineOperations> &ptr)
 444 {
 445         if (ref.path.empty())
 446         {
 447                 ptr = 0;
 448                 return -1;
 449         } else
 450         {
 451                 ptr = new eDVBPVRServiceOfflineOperations(ref);
 452                 return 0;
 453         }
 454 }
 455
 456 RESULT eServiceFactoryDVB::lookupService(ePtr<eDVBService> &service, const eServiceReference &ref)
 457 {
 458                         // TODO: handle the listing itself
 459         // if (ref.... == -1) .. return "... bouquets ...";
 460         // could be also done in another serviceFactory (with seperate ID) to seperate actual services and lists
 461                         // TODO: cache
 462         ePtr<iDVBChannelList> db;
 463         ePtr<eDVBResourceManager> res;
 464
 465         int err;
 466         if ((err = eDVBResourceManager::getInstance(res)) != 0)
 467         {
 468                 eDebug("no resource manager");
 469                 return err;
 470         }
 471         if ((err = res->getChannelList(db)) != 0)
 472         {
 473                 eDebug("no channel list");
 474                 return err;
 475         }
 476
 477                 /* we are sure to have a ..DVB reference as the info() call was forwarded here according to it's ID. */
 478         if ((err = db->getService((eServiceReferenceDVB&)ref, service)) != 0)
 479         {
 480                 eDebug("getService failed!");
 481                 return err;
 482         }
 483
 484         return 0;
 485 }
 486
 487 eDVBServicePlay::eDVBServicePlay(const eServiceReference &ref, eDVBService *service):
 488         m_reference(ref), m_dvb_service(service), m_is_paused(0)
 489 {
 490         m_is_pvr = !ref.path.empty();
 491         m_timeshift_enabled = m_timeshift_active = 0;
 492
 493         CONNECT(m_service_handler.serviceEvent, eDVBServicePlay::serviceEvent);
 494         CONNECT(m_service_handler_timeshift.serviceEvent, eDVBServicePlay::serviceEventTimeshift);
 495         CONNECT(m_event_handler.m_eit_changed, eDVBServicePlay::gotNewEvent);
 496 }
 497
 498 eDVBServicePlay::~eDVBServicePlay()
 499 {
 500 }
 501
 502 void eDVBServicePlay::gotNewEvent()
 503 {
 504 #if 0
 505                 // debug only
 506         ePtr<eServiceEvent> m_event_now, m_event_next;
 507         getEvent(m_event_now, 0);
 508         getEvent(m_event_next, 1);
 509
 510         if (m_event_now)
 511                 eDebug("now running: %s (%d seconds :)", m_event_now->m_event_name.c_str(), m_event_now->m_duration);
 512         if (m_event_next)
 513                 eDebug("next running: %s (%d seconds :)", m_event_next->m_event_name.c_str(), m_event_next->m_duration);
 514 #endif
 515         m_event((iPlayableService*)this, evUpdatedEventInfo);
 516 }
 517
 518 void eDVBServicePlay::serviceEvent(int event)
 519 {
 520         switch (event)
 521         {
 522         case eDVBServicePMTHandler::eventTuned:
 523         {
 524                 ePtr<iDVBDemux> m_demux;
 525                 if (!m_service_handler.getDataDemux(m_demux))
 526                 {
 527                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_reference;
 528                         int sid = ref.getParentServiceID().get();
 529                         if (!sid)
 530                                 sid = ref.getServiceID().get();
 531                         if ( ref.getParentTransportStreamID().get() &&
 532                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
 533                                 m_event_handler.startOther(m_demux, sid);
 534                         else
 535                                 m_event_handler.start(m_demux, sid);
 536                 }
 537                 break;
 538         }
 539         case eDVBServicePMTHandler::eventTuneFailed:
 540         {
 541                 eDebug("DVB service failed to tune");
 542                 m_event((iPlayableService*)this, evTuneFailed);
 543                 break;
 544         }
 545         case eDVBServicePMTHandler::eventNewProgramInfo:
 546         {
 547                 eDebug("eventNewProgramInfo %d %d", m_timeshift_enabled, m_timeshift_active);
 548                 if (m_timeshift_enabled)
 549                         updateTimeshiftPids();
 550                 if (!m_timeshift_active)
 551                         updateDecoder();
 552                 m_event((iPlayableService*)this, evUpdatedInfo);
 553                 break;
 554         }
 555         case eDVBServicePMTHandler::eventEOF:
 556         {
 557                 m_event((iPlayableService*)this, evEnd);
 558                 break;
 559         }
 560         }
 561 }
 562
 563 void eDVBServicePlay::serviceEventTimeshift(int event)
 564 {
 565         switch (event)
 566         {
 567         case eDVBServicePMTHandler::eventNewProgramInfo:
 568                 if (m_timeshift_active)
 569                         updateDecoder();
 570                 break;
 571         case eDVBServicePMTHandler::eventEOF:
 572                 switchToLive();
 573                 break;
 574         }
 575 }
 576
 577 RESULT eDVBServicePlay::start()
 578 {
 579         int r;
 580                 /* in pvr mode, we only want to use one demux. in tv mode, we're using
 581                    two (one for decoding, one for data source), as we must be prepared
 582                    to start recording from the data demux. */
 583         r = m_service_handler.tune((eServiceReferenceDVB&)m_reference, m_is_pvr);
 584         m_event(this, evStart);
 585         return 0;
 586 }
 587
 588 RESULT eDVBServicePlay::stop()
 589 {
 590         return 0;
 591 }
 592
 593 RESULT eDVBServicePlay::connectEvent(const Slot2<void,iPlayableService*,int> &event, ePtr<eConnection> &connection)
 594 {
 595         connection = new eConnection((iPlayableService*)this, m_event.connect(event));
 596         return 0;
 597 }
 598
 599 RESULT eDVBServicePlay::pause(ePtr<iPauseableService> &ptr)
 600 {
 601         if ((!m_is_pvr) && (!m_timeshift_enabled))
 602         {
 603                 ptr = 0;
 604                 return -1;
 605         }
 606
 607         ptr = this;
 608         return 0;
 609 }
 610
 611 RESULT eDVBServicePlay::setSlowMotion(int ratio)
 612 {
 613         if (m_decoder)
 614                 return m_decoder->setSlowMotion(ratio);
 615         else
 616                 return -1;
 617 }
 618
 619 RESULT eDVBServicePlay::setFastForward(int ratio)
 620 {
 621         if (m_decoder)
 622                 return m_decoder->setFastForward(ratio);
 623         else
 624                 return -1;
 625 }
 626
 627 RESULT eDVBServicePlay::seek(ePtr<iSeekableService> &ptr)
 628 {
 629         if (m_is_pvr || m_timeshift_active)
 630         {
 631                 ptr = this;
 632                 return 0;
 633         }
 634
 635         ptr = 0;
 636         return -1;
 637 }
 638
 639 RESULT eDVBServicePlay::getLength(pts_t &len)
 640 {
 641         ePtr<iDVBPVRChannel> pvr_channel;
 642
 643         if (m_service_handler.getPVRChannel(pvr_channel))
 644         {
 645                 eDebug("getPVRChannel failed!");
 646                 return -1;
 647         }
 648
 649         return pvr_channel->getLength(len);
 650 }
 651
 652 RESULT eDVBServicePlay::pause()
 653 {
 654         if (!m_is_paused && m_decoder)
 655         {
 656                 m_is_paused = 1;
 657                 return m_decoder->freeze(0);
 658         } else
 659                 return -1;
 660 }
 661
 662 RESULT eDVBServicePlay::unpause()
 663 {
 664         if (m_is_paused && m_decoder)
 665         {
 666                 m_is_paused = 0;
 667                 return m_decoder->unfreeze();
 668         } else
 669                 return -1;
 670 }
 671
 672 RESULT eDVBServicePlay::seekTo(pts_t to)
 673 {
 674         eDebug("eDVBServicePlay::seekTo: jump %lld", to);
 675
 676         if (!m_decode_demux)
 677                 return -1;
 678
 679         ePtr<iDVBPVRChannel> pvr_channel;
 680
 681         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 682                 return -1;
 683
 684         return pvr_channel->seekTo(m_decode_demux, 0, to);
 685 }
 686
 687 RESULT eDVBServicePlay::seekRelative(int direction, pts_t to)
 688 {
 689         eDebug("eDVBServicePlay::seekRelative: jump %d, %lld", direction, to);
 690
 691         if (!m_decode_demux)
 692                 return -1;
 693
 694         ePtr<iDVBPVRChannel> pvr_channel;
 695
 696         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 697                 return -1;
 698
 699         to *= direction;
 700
 701         return pvr_channel->seekTo(m_decode_demux, 1, to);
 702 }
 703
 704 RESULT eDVBServicePlay::getPlayPosition(pts_t &pos)
 705 {
 706         ePtr<iDVBPVRChannel> pvr_channel;
 707
 708         if (!m_decode_demux)
 709                 return -1;
 710
 711         if ((m_timeshift_enabled ? m_service_handler_timeshift : m_service_handler).getPVRChannel(pvr_channel))
 712                 return -1;
 713
 714         return pvr_channel->getCurrentPosition(m_decode_demux, pos, 1);
 715 }
 716
 717 RESULT eDVBServicePlay::setTrickmode(int trick)
 718 {
 719         if (m_decoder)
 720                 m_decoder->setTrickmode(trick);
 721         return 0;
 722 }
 723
 724 RESULT eDVBServicePlay::frontendStatusInfo(ePtr<iFrontendStatusInformation> &ptr)
 725 {
 726         ptr = this;
 727         return 0;
 728 }
 729
 730 RESULT eDVBServicePlay::info(ePtr<iServiceInformation> &ptr)
 731 {
 732         ptr = this;
 733         return 0;
 734 }
 735
 736 RESULT eDVBServicePlay::audioTracks(ePtr<iAudioTrackSelection> &ptr)
 737 {
 738         ptr = this;
 739         return 0;
 740 }
 741
 742 RESULT eDVBServicePlay::subServices(ePtr<iSubserviceList> &ptr)
 743 {
 744         ptr = this;
 745         return 0;
 746 }
 747
 748 RESULT eDVBServicePlay::timeshift(ePtr<iTimeshiftService> &ptr)
 749 {
 750         if (m_timeshift_enabled || !m_is_pvr)
 751         {
 752                 ptr = this;
 753                 return 0;
 754         }
 755         ptr = 0;
 756         return -1;
 757 }
 758
 759 RESULT eDVBServicePlay::getName(std::string &name)
 760 {
 761         if (m_is_pvr)
 762         {
 763                 ePtr<iStaticServiceInformation> i = new eStaticServiceDVBPVRInformation(m_reference);
 764                 return i->getName(m_reference, name);
 765         }
 766         if (m_dvb_service)
 767         {
 768                 m_dvb_service->getName(m_reference, name);
 769                 if (name.empty())
 770                         name = "(...)";
 771         }
 772         else if (!m_reference.name.empty())
 773                 eStaticServiceDVBInformation().getName(m_reference, name);
 774         else
 775                 name = "DVB service";
 776         return 0;
 777 }
 778
 779 RESULT eDVBServicePlay::getEvent(ePtr<eServiceEvent> &evt, int nownext)
 780 {
 781         return m_event_handler.getEvent(evt, nownext);
 782 }
 783
 784 int eDVBServicePlay::getInfo(int w)
 785 {
 786         eDVBServicePMTHandler::program program;
 787
 788         if (m_service_handler.getProgramInfo(program))
 789                 return -1;
 790
 791         switch (w)
 792         {
 793         case sAspect:
 794                 if (!program.videoStreams.empty() && program.videoStreams[0].component_tag != -1)
 795                 {
 796                         ePtr<eServiceEvent> evt;
 797                         if (!m_event_handler.getEvent(evt, 0))
 798                         {
 799                                 ePtr<eComponentData> data;
 800                                 if (!evt->getComponentData(data, program.videoStreams[0].component_tag))
 801                                 {
 802                                         if ( data->getStreamContent() == 1 )
 803                                         {
 804                                                 switch(data->getComponentType())
 805                                                 {
 806                                                         // SD
 807                                                         case 1: // 4:3 SD PAL
 808                                                         case 2:
 809                                                         case 3: // 16:9 SD PAL
 810                                                         case 4: // > 16:9 PAL
 811                                                         case 5: // 4:3 SD NTSC
 812                                                         case 6:
 813                                                         case 7: // 16:9 SD NTSC
 814                                                         case 8: // > 16:9 NTSC
 815
 816                                                         // HD
 817                                                         case 9: // 4:3 HD PAL
 818                                                         case 0xA:
 819                                                         case 0xB: // 16:9 HD PAL
 820                                                         case 0xC: // > 16:9 HD PAL
 821                                                         case 0xD: // 4:3 HD NTSC
 822                                                         case 0xE:
 823                                                         case 0xF: // 16:9 HD NTSC
 824                                                         case 0x10: // > 16:9 HD PAL
 825                                                                 return data->getComponentType();
 826                                                 }
 827                                         }
 828                                 }
 829                         }
 830                 }
 831                 return -1;
 832         case sIsCrypted: return program.isCrypted;
 833         case sVideoPID: if (program.videoStreams.empty()) return -1; return program.videoStreams[0].pid;
 834         case sAudioPID: if (program.audioStreams.empty()) return -1; return program.audioStreams[m_current_audio_stream].pid;
 835         case sPCRPID: return program.pcrPid;
 836         case sPMTPID: return program.pmtPid;
 837         case sTXTPID: return -1;
 838         case sSID: return ((const eServiceReferenceDVB&)m_reference).getServiceID().get();
 839         case sONID: return ((const eServiceReferenceDVB&)m_reference).getOriginalNetworkID().get();
 840         case sTSID: return ((const eServiceReferenceDVB&)m_reference).getTransportStreamID().get();
 841         case sNamespace: return ((const eServiceReferenceDVB&)m_reference).getDVBNamespace().get();
 842         case sProvider: if (!m_dvb_service) return -1; return -2;
 843         default:
 844                 return -1;
 845         }
 846 }
 847
 848 std::string eDVBServicePlay::getInfoString(int w)
 849 {
 850         switch (w)
 851         {
 852         case sProvider:
 853                 if (!m_dvb_service) return "";
 854                 return m_dvb_service->m_provider_name;
 855         default:
 856                 return "";
 857         }
 858 }
 859
 860 int eDVBServicePlay::getNumberOfTracks()
 861 {
 862         eDVBServicePMTHandler::program program;
 863         if (m_service_handler.getProgramInfo(program))
 864                 return 0;
 865         return program.audioStreams.size();
 866 }
 867
 868 RESULT eDVBServicePlay::selectTrack(unsigned int i)
 869 {
 870         int ret = selectAudioStream(i);
 871
 872         if (m_decoder->start())
 873                 return -5;
 874
 875         return ret;
 876 }
 877
 878 RESULT eDVBServicePlay::getTrackInfo(struct iAudioTrackInfo &info, unsigned int i)
 879 {
 880         eDVBServicePMTHandler::program program;
 881
 882         if (m_service_handler.getProgramInfo(program))
 883                 return -1;
 884
 885         if (i >= program.audioStreams.size())
 886                 return -2;
 887
 888         if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atMPEG)
 889                 info.m_description = "MPEG";
 890         else if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atAC3)
 891                 info.m_description = "AC3";
 892         else  if (program.audioStreams[i].type == eDVBServicePMTHandler::audioStream::atDTS)
 893                 info.m_description = "DTS";
 894         else
 895                 info.m_description = "???";
 896
 897         if (program.audioStreams[i].component_tag != -1)
 898         {
 899                 ePtr<eServiceEvent> evt;
 900                 if (!m_event_handler.getEvent(evt, 0))
 901                 {
 902                         ePtr<eComponentData> data;
 903                         if (!evt->getComponentData(data, program.audioStreams[i].component_tag))
 904                                 info.m_language = data->getText();
 905                 }
 906         }
 907
 908         if (info.m_language.empty())
 909                 info.m_language = program.audioStreams[i].language_code;
 910
 911         return 0;
 912 }
 913
 914 int eDVBServicePlay::selectAudioStream(int i)
 915 {
 916         eDVBServicePMTHandler::program program;
 917
 918         if (m_service_handler.getProgramInfo(program))
 919                 return -1;
 920
 921         if ((unsigned int)i >= program.audioStreams.size())
 922                 return -2;
 923
 924         if (!m_decoder)
 925                 return -3;
 926
 927         if (m_decoder->setAudioPID(program.audioStreams[i].pid, program.audioStreams[i].type))
 928                 return -4;
 929
 930         if (m_dvb_service && !m_is_pvr)
 931         {
 932                 if (program.audioStreams[i].type == eDVBAudio::aMPEG)
 933                 {
 934                         m_dvb_service->setCachePID(eDVBService::cAPID, program.audioStreams[i].pid);
 935                         m_dvb_service->setCachePID(eDVBService::cAC3PID, -1);
 936                 }       else
 937                 {
 938                         m_dvb_service->setCachePID(eDVBService::cAPID, -1);
 939                         m_dvb_service->setCachePID(eDVBService::cAC3PID, program.audioStreams[i].pid);
 940                 }
 941         }
 942
 943         m_current_audio_stream = i;
 944
 945         return 0;
 946 }
 947
 948 int eDVBServicePlay::getFrontendInfo(int w)
 949 {
 950         if (m_is_pvr)
 951                 return 0;
 952         eUsePtr<iDVBChannel> channel;
 953         if(m_service_handler.getChannel(channel))
 954                 return 0;
 955         ePtr<iDVBFrontend> fe;
 956         if(channel->getFrontend(fe))
 957                 return 0;
 958         return fe->readFrontendData(w);
 959 }
 960
 961 int eDVBServicePlay::getNumberOfSubservices()
 962 {
 963         ePtr<eServiceEvent> evt;
 964         if (!m_event_handler.getEvent(evt, 0))
 965                 return evt->getNumOfLinkageServices();
 966         return 0;
 967 }
 968
 969 RESULT eDVBServicePlay::getSubservice(eServiceReference &sub, unsigned int n)
 970 {
 971         ePtr<eServiceEvent> evt;
 972         if (!m_event_handler.getEvent(evt, 0))
 973         {
 974                 if (!evt->getLinkageService(sub, m_reference, n))
 975                         return 0;
 976         }
 977         sub.type=eServiceReference::idInvalid;
 978         return -1;
 979 }
 980
 981 RESULT eDVBServicePlay::startTimeshift()
 982 {
 983         ePtr<iDVBDemux> demux;
 984
 985         eDebug("Start timeshift!");
 986
 987         if (m_timeshift_enabled)
 988                 return -1;
 989
 990                 /* start recording with the data demux. */
 991         if (m_service_handler.getDataDemux(demux))
 992                 return -2;
 993
 994         demux->createTSRecorder(m_record);
 995         if (!m_record)
 996                 return -3;
 997
 998         char templ[]="/media/hdd/timeshift.XXXXXX";
 999         m_timeshift_fd = mkstemp(templ);
1000         m_timeshift_file = templ;
1001
1002         eDebug("recording to %s", templ);
1003
1004         if (m_timeshift_fd < 0)
1005         {
1006                 delete m_record;
1007                 return -4;
1008         }
1009
1010         m_record->setTargetFD(m_timeshift_fd);
1011
1012         m_timeshift_enabled = 1;
1013
1014         updateTimeshiftPids();
1015         m_record->start();
1016
1017         return 0;
1018 }
1019
1020 RESULT eDVBServicePlay::stopTimeshift()
1021 {
1022         if (!m_timeshift_enabled)
1023                 return -1;
1024
1025         switchToLive();
1026
1027         m_timeshift_enabled = 0;
1028
1029         m_record->stop();
1030         delete m_record;
1031
1032         close(m_timeshift_fd);
1033         remove(m_timeshift_file.c_str());
1034
1035         eDebug("timeshift disabled");
1036         return 0;
1037 }
1038
1039 int eDVBServicePlay::isTimeshiftActive()
1040 {
1041         return m_timeshift_enabled && m_timeshift_active;
1042 }
1043
1044 RESULT eDVBServicePlay::activateTimeshift()
1045 {
1046         if (!m_timeshift_enabled)
1047                 return -1;
1048
1049         if (!m_timeshift_active)
1050         {
1051                 switchToTimeshift();
1052                 return 0;
1053         }
1054
1055         return -2;
1056 }
1057
1058 void eDVBServicePlay::updateTimeshiftPids()
1059 {
1060         if (!m_record)
1061                 return;
1062
1063         eDVBServicePMTHandler::program program;
1064         if (m_service_handler.getProgramInfo(program))
1065                 return;
1066         else
1067         {
1068                 std::set<int> pids_to_record;
1069                 pids_to_record.insert(0); // PAT
1070                 if (program.pmtPid != -1)
1071                         pids_to_record.insert(program.pmtPid); // PMT
1072
1073                 if (program.textPid != -1)
1074                         pids_to_record.insert(program.textPid); // Videotext
1075
1076                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1077                         i(program.videoStreams.begin());
1078                         i != program.videoStreams.end(); ++i)
1079                         pids_to_record.insert(i->pid);
1080
1081                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1082                         i(program.audioStreams.begin());
1083                         i != program.audioStreams.end(); ++i)
1084                                 pids_to_record.insert(i->pid);
1085
1086                 std::set<int> new_pids, obsolete_pids;
1087
1088                 std::set_difference(pids_to_record.begin(), pids_to_record.end(),
1089                                 m_pids_active.begin(), m_pids_active.end(),
1090                                 std::inserter(new_pids, new_pids.begin()));
1091
1092                 std::set_difference(
1093                                 m_pids_active.begin(), m_pids_active.end(),
1094                                 pids_to_record.begin(), pids_to_record.end(),
1095                                 std::inserter(new_pids, new_pids.begin())
1096                                 );
1097
1098                 for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
1099                         m_record->addPID(*i);
1100
1101                 for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
1102                         m_record->removePID(*i);
1103         }
1104 }
1105
1106 void eDVBServicePlay::switchToLive()
1107 {
1108         eDebug("SwitchToLive");
1109         if (!m_timeshift_active)
1110                 return;
1111
1112         m_decoder = 0;
1113         m_decode_demux = 0;
1114                 /* free the timeshift service handler, we need the resources */
1115         m_service_handler_timeshift.free();
1116         m_timeshift_active = 0;
1117
1118         m_event((iPlayableService*)this, evSeekableStatusChanged);
1119
1120         updateDecoder();
1121 }
1122
1123 void eDVBServicePlay::switchToTimeshift()
1124 {
1125         eDebug("SwitchToTimeshift");
1126         if (m_timeshift_active)
1127                 return;
1128
1129         m_decode_demux = 0;
1130         m_decoder = 0;
1131
1132         m_timeshift_active = 1;
1133
1134         m_event((iPlayableService*)this, evSeekableStatusChanged);
1135
1136         eServiceReferenceDVB r = (eServiceReferenceDVB&)m_reference;
1137         r.path = m_timeshift_file;
1138
1139         eDebug("ok, re-tuning to %s", r.toString().c_str());
1140         m_service_handler_timeshift.tune(r, 1); /* use the decoder demux for everything */
1141 }
1142
1143 void eDVBServicePlay::updateDecoder()
1144 {
1145         int vpid = -1, apid = -1, apidtype = -1, pcrpid = -1, tpid = -1;
1146         eDVBServicePMTHandler &h = m_timeshift_active ? m_service_handler_timeshift : m_service_handler;
1147
1148         eDVBServicePMTHandler::program program;
1149         if (h.getProgramInfo(program))
1150                 eDebug("getting program info failed.");
1151         else
1152         {
1153                 eDebugNoNewLine("have %d video stream(s)", program.videoStreams.size());
1154                 if (!program.videoStreams.empty())
1155                 {
1156                         eDebugNoNewLine(" (");
1157                         for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
1158                                 i(program.videoStreams.begin());
1159                                 i != program.videoStreams.end(); ++i)
1160                         {
1161                                 if (vpid == -1)
1162                                         vpid = i->pid;
1163                                 if (i != program.videoStreams.begin())
1164                                         eDebugNoNewLine(", ");
1165                                 eDebugNoNewLine("%04x", i->pid);
1166                         }
1167                         eDebugNoNewLine(")");
1168                 }
1169                 eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
1170                 if (!program.audioStreams.empty())
1171                 {
1172                         eDebugNoNewLine(" (");
1173                         for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
1174                                 i(program.audioStreams.begin());
1175                                 i != program.audioStreams.end(); ++i)
1176                         {
1177                                 if (apid == -1)
1178                                 {
1179                                         apid = i->pid;
1180                                         apidtype = i->type;
1181                                 }
1182                                 if (i != program.audioStreams.begin())
1183                                         eDebugNoNewLine(", ");
1184                                 eDebugNoNewLine("%04x", i->pid);
1185                         }
1186                         eDebugNoNewLine(")");
1187                 }
1188                 eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
1189                 pcrpid = program.pcrPid;
1190                 eDebug(", and the text pid is %04x", program.textPid);
1191                 tpid = program.textPid;
1192         }
1193
1194         if (!m_decoder)
1195         {
1196                 h.getDecodeDemux(m_decode_demux);
1197                 if (m_decode_demux)
1198                         m_decode_demux->getMPEGDecoder(m_decoder);
1199         }
1200
1201         if (m_decoder)
1202         {
1203                 m_decoder->setVideoPID(vpid);
1204                 m_current_audio_stream = 0;
1205                 m_decoder->setAudioPID(apid, apidtype);
1206                 if (!(m_is_pvr || m_timeshift_active))
1207                         m_decoder->setSyncPCR(pcrpid);
1208                 else
1209                         m_decoder->setSyncPCR(-1);
1210                 m_decoder->setTextPID(tpid);
1211                 m_decoder->start();
1212 // how we can do this better?
1213 // update cache pid when the user changed the audio track or video track
1214 // TODO handling of difference audio types.. default audio types..
1215
1216                 /* don't worry about non-existing services, nor pvr services */
1217                 if (m_dvb_service && !m_is_pvr)
1218                 {
1219                         if (apidtype == eDVBAudio::aMPEG)
1220                         {
1221                                 m_dvb_service->setCachePID(eDVBService::cAPID, apid);
1222                                 m_dvb_service->setCachePID(eDVBService::cAC3PID, -1);
1223                         }
1224                         else
1225                         {
1226                                 m_dvb_service->setCachePID(eDVBService::cAPID, -1);
1227                                 m_dvb_service->setCachePID(eDVBService::cAC3PID, apid);
1228                         }
1229                         m_dvb_service->setCachePID(eDVBService::cVPID, vpid);
1230                         m_dvb_service->setCachePID(eDVBService::cPCRPID, pcrpid);
1231                         m_dvb_service->setCachePID(eDVBService::cTPID, tpid);
1232                 }
1233         }
1234 }
1235
1236 DEFINE_REF(eDVBServicePlay)
1237
1238 eAutoInitPtr<eServiceFactoryDVB> init_eServiceFactoryDVB(eAutoInitNumbers::service+1, "eServiceFactoryDVB");