lib/dvb/dvb.cpp

   1 #include <lib/base/eerror.h>
   2 #include <lib/base/filepush.h>
   3 #include <lib/dvb/idvb.h>
   4 #include <lib/dvb/dvb.h>
   5 #include <lib/dvb/sec.h>
   6
   7 #include <errno.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11 #include <fcntl.h>
  12 #include <sys/ioctl.h>
  13
  14 DEFINE_REF(eDVBRegisteredFrontend);
  15 DEFINE_REF(eDVBRegisteredDemux);
  16
  17 DEFINE_REF(eDVBAllocatedFrontend);
  18
  19 eDVBAllocatedFrontend::eDVBAllocatedFrontend(eDVBRegisteredFrontend *fe): m_fe(fe)
  20 {
  21         m_fe->inc_use();
  22 }
  23
  24 eDVBAllocatedFrontend::~eDVBAllocatedFrontend()
  25 {
  26         m_fe->dec_use();
  27 }
  28
  29 DEFINE_REF(eDVBAllocatedDemux);
  30
  31 eDVBAllocatedDemux::eDVBAllocatedDemux(eDVBRegisteredDemux *demux): m_demux(demux)
  32 {
  33         m_demux->m_inuse++;
  34 }
  35
  36 eDVBAllocatedDemux::~eDVBAllocatedDemux()
  37 {
  38         --m_demux->m_inuse;
  39 }
  40
  41 DEFINE_REF(eDVBResourceManager);
  42
  43 eDVBResourceManager *eDVBResourceManager::instance;
  44
  45 eDVBResourceManager::eDVBResourceManager()
  46 {
  47         avail = 1;
  48         busy = 0;
  49         m_sec = new eDVBSatelliteEquipmentControl(m_frontend);
  50         if (!instance)
  51                 instance = this;
  52
  53                 /* search available adapters... */
  54
  55                 // add linux devices
  56
  57         int num_adapter = 0;
  58         while (eDVBAdapterLinux::exist(num_adapter))
  59         {
  60                 addAdapter(new eDVBAdapterLinux(num_adapter));
  61                 num_adapter++;
  62         }
  63
  64         eDebug("found %d adapter, %d frontends and %d demux",
  65                 m_adapter.size(), m_frontend.size(), m_demux.size());
  66 }
  67
  68
  69 DEFINE_REF(eDVBAdapterLinux);
  70 eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr)
  71 {
  72                 // scan frontends
  73         int num_fe = 0;
  74
  75         eDebug("scanning for frontends..");
  76         while (1)
  77         {
  78                 struct stat s;
  79                 char filename[128];
  80 #if HAVE_DVB_API_VERSION < 3
  81                 sprintf(filename, "/dev/dvb/card%d/frontend%d", m_nr, num_fe);
  82 #else
  83                 sprintf(filename, "/dev/dvb/adapter%d/frontend%d", m_nr, num_fe);
  84 #endif
  85                 if (stat(filename, &s))
  86                         break;
  87                 ePtr<eDVBFrontend> fe;
  88
  89                 int ok = 0;
  90                 fe = new eDVBFrontend(m_nr, num_fe, ok);
  91                 if (ok)
  92                         m_frontend.push_back(fe);
  93                 ++num_fe;
  94         }
  95
  96                 // scan demux
  97         int num_demux = 0;
  98         while (1)
  99         {
 100                 struct stat s;
 101                 char filename[128];
 102 #if HAVE_DVB_API_VERSION < 3
 103                 sprintf(filename, "/dev/dvb/card%d/demux%d", m_nr, num_demux);
 104 #else
 105                 sprintf(filename, "/dev/dvb/adapter%d/demux%d", m_nr, num_demux);
 106 #endif
 107                 if (stat(filename, &s))
 108                         break;
 109                 ePtr<eDVBDemux> demux;
 110
 111                 demux = new eDVBDemux(m_nr, num_demux);
 112                 m_demux.push_back(demux);
 113
 114                 ++num_demux;
 115         }
 116 }
 117
 118 int eDVBAdapterLinux::getNumDemux()
 119 {
 120         return m_demux.size();
 121 }
 122
 123 RESULT eDVBAdapterLinux::getDemux(ePtr<eDVBDemux> &demux, int nr)
 124 {
 125         eSmartPtrList<eDVBDemux>::iterator i(m_demux.begin());
 126         while (nr && (i != m_demux.end()))
 127         {
 128                 --nr;
 129                 ++i;
 130         }
 131
 132         if (i != m_demux.end())
 133                 demux = *i;
 134         else
 135                 return -1;
 136
 137         return 0;
 138 }
 139
 140 int eDVBAdapterLinux::getNumFrontends()
 141 {
 142         return m_frontend.size();
 143 }
 144
 145 RESULT eDVBAdapterLinux::getFrontend(ePtr<eDVBFrontend> &fe, int nr)
 146 {
 147         eSmartPtrList<eDVBFrontend>::iterator i(m_frontend.begin());
 148         while (nr && (i != m_frontend.end()))
 149         {
 150                 --nr;
 151                 ++i;
 152         }
 153
 154         if (i != m_frontend.end())
 155                 fe = *i;
 156         else
 157                 return -1;
 158
 159         return 0;
 160 }
 161
 162 int eDVBAdapterLinux::exist(int nr)
 163 {
 164         struct stat s;
 165         char filename[128];
 166 #if HAVE_DVB_API_VERSION < 3
 167         sprintf(filename, "/dev/dvb/card%d", nr);
 168 #else
 169         sprintf(filename, "/dev/dvb/adapter%d", nr);
 170 #endif
 171         if (!stat(filename, &s))
 172                 return 1;
 173         return 0;
 174 }
 175
 176 eDVBResourceManager::~eDVBResourceManager()
 177 {
 178         if (instance == this)
 179                 instance = 0;
 180 }
 181
 182 void eDVBResourceManager::addAdapter(iDVBAdapter *adapter)
 183 {
 184         int num_fe = adapter->getNumFrontends();
 185         int num_demux = adapter->getNumDemux();
 186
 187         m_adapter.push_back(adapter);
 188
 189         int i;
 190         for (i=0; i<num_demux; ++i)
 191         {
 192                 ePtr<eDVBDemux> demux;
 193                 if (!adapter->getDemux(demux, i))
 194                         m_demux.push_back(new eDVBRegisteredDemux(demux, adapter));
 195         }
 196
 197         for (i=0; i<num_fe; ++i)
 198         {
 199                 ePtr<eDVBFrontend> frontend;
 200
 201                 if (!adapter->getFrontend(frontend, i))
 202                 {
 203                         frontend->setSEC(m_sec);
 204                         m_frontend.push_back(new eDVBRegisteredFrontend(frontend, adapter));
 205                 }
 206         }
 207 }
 208
 209 RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm)
 210 {
 211         ePtr<eDVBRegisteredFrontend> best;
 212         int bestval = 0;
 213
 214         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
 215                 if (!i->m_inuse)
 216                 {
 217                         int c = i->m_frontend->isCompatibleWith(feparm);
 218                         if (c > bestval)
 219                         {
 220                                 bestval = c;
 221                                 best = i;
 222                         }
 223                 }
 224
 225         if (best)
 226         {
 227                 fe = new eDVBAllocatedFrontend(best);
 228                 return 0;
 229         }
 230
 231         fe = 0;
 232
 233         return -1;
 234 }
 235
 236 RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend> &fe, int nr)
 237 {
 238         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i, --nr)
 239                 if ((!nr) && !i->m_inuse)
 240                 {
 241                         fe = new eDVBAllocatedFrontend(i);
 242                         return 0;
 243                 }
 244
 245         fe = 0;
 246         return -1;
 247 }
 248
 249 RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
 250 {
 251                 /* find first unused demux which is on same adapter as frontend (or any, if PVR)
 252                    never use the first one unless we need a decoding demux. */
 253
 254         eDebug("allocate demux");
 255         eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());
 256
 257         if (i == m_demux.end())
 258                 return -1;
 259
 260         int n=0;
 261                 /* FIXME: hardware demux policy */
 262         if (!(cap & iDVBChannel::capDecode))
 263                 ++i, ++n;
 264
 265         for (; i != m_demux.end(); ++i, ++n)
 266                 if ((!i->m_inuse) && ((!fe) || (i->m_adapter == fe->m_adapter)))
 267                 {
 268                         if ((cap & iDVBChannel::capDecode) && n)
 269                                 continue;
 270
 271                         demux = new eDVBAllocatedDemux(i);
 272                         if (fe)
 273                                 demux->get().setSourceFrontend(fe->m_frontend->getID());
 274                         else
 275                                 demux->get().setSourcePVR(0);
 276                         return 0;
 277                 }
 278         eDebug("demux not found");
 279         return -1;
 280 }
 281
 282 RESULT eDVBResourceManager::setChannelList(iDVBChannelList *list)
 283 {
 284         m_list = list;
 285         return 0;
 286 }
 287
 288 RESULT eDVBResourceManager::getChannelList(ePtr<iDVBChannelList> &list)
 289 {
 290         list = m_list;
 291         if (list)
 292                 return 0;
 293         else
 294                 return -ENOENT;
 295 }
 296
 297 RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUsePtr<iDVBChannel> &channel)
 298 {
 299                 /* first, check if a channel is already existing. */
 300
 301         if (m_cached_channel)
 302         {
 303                 eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
 304                 if(channelid==cache_chan->getChannelID())
 305                 {
 306                         eDebug("use cached_channel");
 307                         channel=m_cached_channel;
 308                         return 0;
 309                 }
 310                 m_cached_channel=0;
 311         }
 312
 313 //      eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
 314         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
 315         {
 316 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
 317                 if (i->m_channel_id == channelid)
 318                 {
 319 //                      eDebug("found shared channel..");
 320                         channel = i->m_channel;
 321                         return 0;
 322                 }
 323         }
 324
 325         /* no currently available channel is tuned to this channelid. create a new one, if possible. */
 326
 327         if (!m_list)
 328         {
 329                 eDebug("no channel list set!");
 330                 return -ENOENT;
 331         }
 332
 333         ePtr<iDVBFrontendParameters> feparm;
 334         if (m_list->getChannelFrontendData(channelid, feparm))
 335         {
 336                 eDebug("channel not found!");
 337                 return -ENOENT;
 338         }
 339
 340         /* allocate a frontend. */
 341
 342         ePtr<eDVBAllocatedFrontend> fe;
 343
 344         if (allocateFrontend(fe, feparm))
 345                 return errNoFrontend;
 346
 347         RESULT res;
 348         ePtr<eDVBChannel> ch;
 349         ch = new eDVBChannel(this, fe);
 350
 351         res = ch->setChannel(channelid, feparm);
 352         if (res)
 353         {
 354                 channel = 0;
 355                 return errChidNotFound;
 356         }
 357         m_cached_channel = channel = ch;
 358
 359         return 0;
 360 }
 361
 362 RESULT eDVBResourceManager::allocateRawChannel(eUsePtr<iDVBChannel> &channel, int frontend_index)
 363 {
 364         ePtr<eDVBAllocatedFrontend> fe;
 365
 366         if (allocateFrontendByIndex(fe, frontend_index))
 367                 return errNoFrontend;
 368
 369         eDVBChannel *ch;
 370         ch = new eDVBChannel(this, fe);
 371
 372         channel = ch;
 373         return 0;
 374 }
 375
 376
 377 RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
 378 {
 379         ePtr<eDVBAllocatedDemux> demux;
 380
 381         eDVBChannel *ch;
 382         ch = new eDVBChannel(this, 0);
 383
 384         channel = ch;
 385         return 0;
 386 }
 387
 388 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
 389 {
 390         m_active_channels.push_back(active_channel(chid, ch));
 391         /* emit */ m_channelAdded(ch);
 392         return 0;
 393 }
 394
 395 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
 396 {
 397         int cnt = 0;
 398         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end();)
 399         {
 400                 if (i->m_channel == ch)
 401                 {
 402                         i = m_active_channels.erase(i);
 403                         ++cnt;
 404                 } else
 405                         ++i;
 406         }
 407         ASSERT(cnt == 1);
 408         if (cnt == 1)
 409                 return 0;
 410         return -ENOENT;
 411 }
 412
 413 RESULT eDVBResourceManager::connectChannelAdded(const Slot1<void,eDVBChannel*> &channelAdded, ePtr<eConnection> &connection)
 414 {
 415         connection = new eConnection((eDVBResourceManager*)this, m_channelAdded.connect(channelAdded));
 416         return 0;
 417 }
 418
 419 bool eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm)
 420 {
 421         ePtr<eDVBRegisteredFrontend> best;
 422         int bestval = 0;
 423
 424         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
 425                 if (!i->m_inuse)
 426                 {
 427                         int c = i->m_frontend->isCompatibleWith(feparm);
 428                         if (c > bestval)
 429                                 bestval = c;
 430                 }
 431
 432         return bestval>0;
 433 }
 434
 435 bool eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore)
 436 {
 437                 /* first, check if a channel is already existing. */
 438 //      eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
 439         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
 440         {
 441 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
 442                 if (i->m_channel_id == channelid)
 443                 {
 444 //                      eDebug("found shared channel..");
 445                         return true;
 446                 }
 447         }
 448
 449         int *decremented_fe_usecount=NULL;
 450
 451         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
 452         {
 453 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
 454                 if (i->m_channel_id == ignore)
 455                 {
 456                         eDVBChannel *channel = (eDVBChannel*) &(*i->m_channel);
 457                         if (channel == &(*m_cached_channel) ? channel->getUseCount() == 2 : channel->getUseCount() == 1)  // channel only used once..
 458                         {
 459                                 ePtr<iDVBFrontend> fe;
 460                                 if (!i->m_channel->getFrontend(fe))
 461                                 {
 462                                         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
 463                                         {
 464                                                 if ( &(*fe) == &(*ii->m_frontend) )
 465                                                 {
 466                                                         --ii->m_inuse;
 467                                                         decremented_fe_usecount = &ii->m_inuse;
 468                                                         break;
 469                                                 }
 470                                         }
 471                                 }
 472                         }
 473                         break;
 474                 }
 475         }
 476
 477         if (!m_list)
 478         {
 479                 eDebug("no channel list set!");
 480                 return false;
 481         }
 482
 483         ePtr<iDVBFrontendParameters> feparm;
 484         if (m_list->getChannelFrontendData(channelid, feparm))
 485         {
 486                 eDebug("channel not found!");
 487                 return false;
 488         }
 489
 490         bool ret = canAllocateFrontend(feparm);
 491
 492         if (decremented_fe_usecount)
 493                 ++(*decremented_fe_usecount);
 494
 495         return ret;
 496 }
 497
 498 DEFINE_REF(eDVBChannel);
 499
 500 eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend): m_state(state_idle), m_mgr(mgr)
 501 {
 502         m_frontend = frontend;
 503
 504         m_pvr_thread = 0;
 505
 506         if (m_frontend)
 507                 m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
 508 }
 509
 510 eDVBChannel::~eDVBChannel()
 511 {
 512         if (m_channel_id)
 513                 m_mgr->removeChannel(this);
 514
 515         if (m_pvr_thread)
 516         {
 517                 m_pvr_thread->stop();
 518                 ::close(m_pvr_fd_src);
 519                 ::close(m_pvr_fd_dst);
 520                 delete m_pvr_thread;
 521         }
 522 }
 523
 524 void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
 525 {
 526         int state, ourstate = 0;
 527
 528                 /* if we are already in shutdown, don't change state. */
 529         if (m_state == state_release)
 530                 return;
 531
 532         if (fe->getState(state))
 533                 return;
 534
 535         if (state == iDVBFrontend::stateLock)
 536         {
 537                 eDebug("OURSTATE: ok");
 538                 ourstate = state_ok;
 539         } else if (state == iDVBFrontend::stateTuning)
 540         {
 541                 eDebug("OURSTATE: tuning");
 542                 ourstate = state_tuning;
 543         } else if (state == iDVBFrontend::stateLostLock)
 544         {
 545                 eDebug("OURSTATE: lost lock");
 546                 ourstate = state_unavailable;
 547         } else if (state == iDVBFrontend::stateFailed)
 548         {
 549                 eDebug("OURSTATE: failed");
 550                 ourstate = state_failed;
 551         } else
 552                 eFatal("state unknown");
 553
 554         if (ourstate != m_state)
 555         {
 556                 m_state = ourstate;
 557                 m_stateChanged(this);
 558         }
 559 }
 560
 561 void eDVBChannel::AddUse()
 562 {
 563         ++m_use_count;
 564 }
 565
 566 void eDVBChannel::ReleaseUse()
 567 {
 568         if (!--m_use_count)
 569         {
 570                 m_state = state_release;
 571                 m_stateChanged(this);
 572         }
 573 }
 574
 575 RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid, ePtr<iDVBFrontendParameters> &feparm)
 576 {
 577         if (m_channel_id)
 578                 m_mgr->removeChannel(this);
 579
 580         if (!channelid)
 581                 return 0;
 582
 583         if (!m_frontend)
 584         {
 585                 eDebug("no frontend to tune!");
 586                 return -ENODEV;
 587         }
 588
 589         m_channel_id = channelid;
 590         m_mgr->addChannel(channelid, this);
 591         m_state = state_tuning;
 592                         /* if tuning fails, shutdown the channel immediately. */
 593         int res;
 594         res = m_frontend->get().tune(*feparm);
 595
 596         if (res)
 597         {
 598                 m_state = state_release;
 599                 m_stateChanged(this);
 600                 return res;
 601         }
 602
 603         return 0;
 604 }
 605
 606 RESULT eDVBChannel::connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)
 607 {
 608         connection = new eConnection((iDVBChannel*)this, m_stateChanged.connect(stateChange));
 609         return 0;
 610 }
 611
 612 RESULT eDVBChannel::getState(int &state)
 613 {
 614         state = m_state;
 615         return 0;
 616 }
 617
 618 RESULT eDVBChannel::setCIRouting(const eDVBCIRouting &routing)
 619 {
 620         return -1;
 621 }
 622
 623 RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
 624 {
 625         eDebug("get %d demux", cap);
 626         ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
 627
 628         if (!our_demux)
 629         {
 630                 demux = 0;
 631
 632                 if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
 633                         return -1;
 634
 635         }
 636
 637         demux = *our_demux;
 638         if (cap & capDecode)
 639         {
 640                 our_demux = 0;
 641         }
 642         return 0;
 643 }
 644
 645 RESULT eDVBChannel::getFrontend(ePtr<iDVBFrontend> &frontend)
 646 {
 647         frontend = &m_frontend->get();
 648         if (frontend)
 649                 return 0;
 650         else
 651                 return -ENODEV;
 652 }
 653
 654 RESULT eDVBChannel::playFile(const char *file)
 655 {
 656         ASSERT(!m_frontend);
 657         if (m_pvr_thread)
 658         {
 659                 m_pvr_thread->stop();
 660                 delete m_pvr_thread;
 661                 m_pvr_thread = 0;
 662         }
 663
 664         m_tstools.openFile(file);
 665
 666                 /* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
 667                    THEN DO A REAL FIX HERE! */
 668
 669                 /* (this codepath needs to be improved anyway.) */
 670         m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
 671         if (m_pvr_fd_dst < 0)
 672         {
 673                 eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
 674                 return -ENODEV;
 675         }
 676
 677         m_pvr_fd_src = open(file, O_RDONLY);
 678         if (m_pvr_fd_src < 0)
 679         {
 680                 eDebug("can't open PVR m_pvr_fd_src file %s (%m)", file);
 681                 close(m_pvr_fd_dst);
 682                 return -ENOENT;
 683         }
 684
 685         m_state = state_ok;
 686         m_stateChanged(this);
 687
 688         m_pvr_thread = new eFilePushThread();
 689         m_pvr_thread->start(m_pvr_fd_src, m_pvr_fd_dst);
 690
 691         return 0;
 692 }
 693
 694 RESULT eDVBChannel::getLength(pts_t &len)
 695 {
 696         return m_tstools.calcLen(len);
 697 }
 698
 699 RESULT eDVBChannel::getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos)
 700 {
 701         if (!decoding_demux)
 702                 return -1;
 703
 704         off_t begin = 0;
 705                 /* getPTS for offset 0 is cached, so it doesn't harm. */
 706         int r = m_tstools.getPTS(begin, pos);
 707         if (r)
 708         {
 709                 eDebug("tstools getpts(0) failed!");
 710                 return r;
 711         }
 712
 713         pts_t now;
 714
 715         r = decoding_demux->getSTC(now);
 716
 717         if (r)
 718         {
 719                 eDebug("demux getSTC failed");
 720                 return -1;
 721         }
 722
 723 //      eDebug("STC: %08llx PTS: %08llx, diff %lld", now, pos, now - pos);
 724                 /* when we are less than 10 seconds before the start, return 0. */
 725                 /* (we're just waiting for the timespam to start) */
 726         if ((now < pos) && ((pos - now) < 90000 * 10))
 727         {
 728                 pos = 0;
 729                 return 0;
 730         }
 731
 732         if (now < pos) /* wrap around */
 733                 pos = now + ((pts_t)1)<<33 - pos;
 734         else
 735                 pos = now - pos;
 736
 737         return 0;
 738 }
 739
 740 RESULT eDVBChannel::seekTo(iDVBDemux *decoding_demux, int relative, pts_t &pts)
 741 {
 742         int bitrate = m_tstools.calcBitrate(); /* in bits/s */
 743
 744         if (bitrate == -1)
 745                 return -1;
 746
 747         if (relative)
 748         {
 749                 pts_t now;
 750                 if (getCurrentPosition(decoding_demux, now))
 751                 {
 752                         eDebug("seekTo: getCurrentPosition failed!");
 753                         return -1;
 754                 }
 755                 pts += now;
 756         }
 757
 758         if (pts < 0)
 759                 pts = 0;
 760
 761         off_t offset = (pts * (pts_t)bitrate) / 8ULL / 90000ULL;
 762
 763         seekToPosition(decoding_demux, offset);
 764         return 0;
 765 }
 766
 767 RESULT eDVBChannel::seekToPosition(iDVBDemux *decoding_demux, const off_t &r)
 768 {
 769                         /* when seeking, we have to ensure that all buffers are flushed.
 770                            there are basically 3 buffers:
 771                            a.) the filepush's internal buffer
 772                            b.) the PVR buffer (before demux)
 773                            c.) the ratebuffer (after demux)
 774
 775                            it's important to clear them in the correct order, otherwise
 776                            the ratebuffer (for example) would immediately refill from
 777                            the not-yet-flushed PVR buffer.
 778                         */
 779         eDebug("eDVBChannel: seekToPosition .. %llx", r);
 780         m_pvr_thread->pause();
 781
 782                 /* flush internal filepush buffer */
 783         m_pvr_thread->flush();
 784
 785                 /* HACK: flush PVR buffer */
 786         ::ioctl(m_pvr_fd_dst, 0);
 787
 788                 /* flush ratebuffers (video, audio) */
 789         if (decoding_demux)
 790                 decoding_demux->flush();
 791
 792                 /* demux will also flush all decoder.. */
 793         m_pvr_thread->seek(SEEK_SET, r);
 794         m_pvr_thread->resume();
 795         return 0;
 796 }