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 (m_cached_channel)
 367                 m_cached_channel=0;
 368
 369         if (allocateFrontendByIndex(fe, frontend_index))
 370                 return errNoFrontend;
 371
 372         eDVBChannel *ch;
 373         ch = new eDVBChannel(this, fe);
 374
 375         channel = ch;
 376         return 0;
 377 }
 378
 379
 380 RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
 381 {
 382         ePtr<eDVBAllocatedDemux> demux;
 383
 384         if (m_cached_channel)
 385                 m_cached_channel=0;
 386
 387         eDVBChannel *ch;
 388         ch = new eDVBChannel(this, 0);
 389
 390         channel = ch;
 391         return 0;
 392 }
 393
 394 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
 395 {
 396         m_active_channels.push_back(active_channel(chid, ch));
 397         /* emit */ m_channelAdded(ch);
 398         return 0;
 399 }
 400
 401 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
 402 {
 403         int cnt = 0;
 404         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end();)
 405         {
 406                 if (i->m_channel == ch)
 407                 {
 408                         i = m_active_channels.erase(i);
 409                         ++cnt;
 410                 } else
 411                         ++i;
 412         }
 413         ASSERT(cnt == 1);
 414         if (cnt == 1)
 415                 return 0;
 416         return -ENOENT;
 417 }
 418
 419 RESULT eDVBResourceManager::connectChannelAdded(const Slot1<void,eDVBChannel*> &channelAdded, ePtr<eConnection> &connection)
 420 {
 421         connection = new eConnection((eDVBResourceManager*)this, m_channelAdded.connect(channelAdded));
 422         return 0;
 423 }
 424
 425 bool eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm)
 426 {
 427         ePtr<eDVBRegisteredFrontend> best;
 428         int bestval = 0;
 429
 430         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
 431                 if (!i->m_inuse)
 432                 {
 433                         int c = i->m_frontend->isCompatibleWith(feparm);
 434                         if (c > bestval)
 435                                 bestval = c;
 436                 }
 437
 438         return bestval>0;
 439 }
 440
 441 bool eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore)
 442 {
 443         bool ret=true;
 444         if (m_cached_channel)
 445         {
 446                 eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
 447                 if(channelid==cache_chan->getChannelID())
 448                         return ret;
 449         }
 450
 451                 /* first, check if a channel is already existing. */
 452 //      eDebug("allocate channel.. %04x:%04x", channelid.transport_stream_id.get(), channelid.original_network_id.get());
 453         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
 454         {
 455 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
 456                 if (i->m_channel_id == channelid)
 457                 {
 458 //                      eDebug("found shared channel..");
 459                         return ret;
 460                 }
 461         }
 462
 463         int *decremented_cached_channel_fe_usecount=NULL,
 464                 *decremented_fe_usecount=NULL;
 465
 466         for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
 467         {
 468 //              eDebug("available channel.. %04x:%04x", i->m_channel_id.transport_stream_id.get(), i->m_channel_id.original_network_id.get());
 469                 if (i->m_channel_id == ignore)
 470                 {
 471                         eDVBChannel *channel = (eDVBChannel*) &(*i->m_channel);
 472                         if (channel == &(*m_cached_channel) ? channel->getUseCount() == 2 : channel->getUseCount() == 1)  // channel only used once..
 473                         {
 474                                 ePtr<iDVBFrontend> fe;
 475                                 if (!i->m_channel->getFrontend(fe))
 476                                 {
 477                                         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
 478                                         {
 479                                                 if ( &(*fe) == &(*ii->m_frontend) )
 480                                                 {
 481                                                         --ii->m_inuse;
 482                                                         decremented_fe_usecount = &ii->m_inuse;
 483                                                         if (channel == &(*m_cached_channel))
 484                                                                 decremented_cached_channel_fe_usecount = decremented_fe_usecount;
 485                                                         break;
 486                                                 }
 487                                         }
 488                                 }
 489                         }
 490                         break;
 491                 }
 492         }
 493
 494         if (!decremented_cached_channel_fe_usecount)
 495         {
 496                 if (m_cached_channel)
 497                 {
 498                         eDVBChannel *channel = (eDVBChannel*) &(*m_cached_channel);
 499                         if (channel->getUseCount() == 1)
 500                         {
 501                                 ePtr<iDVBFrontend> fe;
 502                                 if (!channel->getFrontend(fe))
 503                                 {
 504                                         for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
 505                                         {
 506                                                 if ( &(*fe) == &(*ii->m_frontend) )
 507                                                 {
 508                                                         --ii->m_inuse;
 509                                                         decremented_cached_channel_fe_usecount = &ii->m_inuse;
 510                                                         break;
 511                                                 }
 512                                         }
 513                                 }
 514                         }
 515                 }
 516         }
 517         else
 518                 decremented_cached_channel_fe_usecount=NULL;
 519
 520         ePtr<iDVBFrontendParameters> feparm;
 521
 522         if (!m_list)
 523         {
 524                 eDebug("no channel list set!");
 525                 ret = false;
 526                 goto error;
 527         }
 528
 529         if (m_list->getChannelFrontendData(channelid, feparm))
 530         {
 531                 eDebug("channel not found!");
 532                 ret = false;
 533                 goto error;
 534         }
 535
 536         ret = canAllocateFrontend(feparm);
 537
 538 error:
 539         if (decremented_fe_usecount)
 540                 ++(*decremented_fe_usecount);
 541         if (decremented_cached_channel_fe_usecount)
 542                 ++(*decremented_cached_channel_fe_usecount);
 543
 544         return ret;
 545 }
 546
 547 DEFINE_REF(eDVBChannel);
 548
 549 eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend): m_state(state_idle), m_mgr(mgr)
 550 {
 551         m_frontend = frontend;
 552
 553         m_pvr_thread = 0;
 554
 555         if (m_frontend)
 556                 m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
 557 }
 558
 559 eDVBChannel::~eDVBChannel()
 560 {
 561         if (m_channel_id)
 562                 m_mgr->removeChannel(this);
 563
 564         if (m_pvr_thread)
 565         {
 566                 m_pvr_thread->stop();
 567                 ::close(m_pvr_fd_src);
 568                 ::close(m_pvr_fd_dst);
 569                 delete m_pvr_thread;
 570         }
 571 }
 572
 573 void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
 574 {
 575         int state, ourstate = 0;
 576
 577                 /* if we are already in shutdown, don't change state. */
 578         if (m_state == state_release)
 579                 return;
 580
 581         if (fe->getState(state))
 582                 return;
 583
 584         if (state == iDVBFrontend::stateLock)
 585         {
 586                 eDebug("OURSTATE: ok");
 587                 ourstate = state_ok;
 588         } else if (state == iDVBFrontend::stateTuning)
 589         {
 590                 eDebug("OURSTATE: tuning");
 591                 ourstate = state_tuning;
 592         } else if (state == iDVBFrontend::stateLostLock)
 593         {
 594                 eDebug("OURSTATE: lost lock");
 595                 ourstate = state_unavailable;
 596         } else if (state == iDVBFrontend::stateFailed)
 597         {
 598                 eDebug("OURSTATE: failed");
 599                 ourstate = state_failed;
 600         } else
 601                 eFatal("state unknown");
 602
 603         if (ourstate != m_state)
 604         {
 605                 m_state = ourstate;
 606                 m_stateChanged(this);
 607         }
 608 }
 609
 610 void eDVBChannel::pvrEvent(int event)
 611 {
 612         switch (event)
 613         {
 614         case eFilePushThread::evtEOF:
 615                 eDebug("eDVBChannel: End of file!");
 616                 m_event(this, evtEOF);
 617                 break;
 618         }
 619 }
 620
 621 void eDVBChannel::AddUse()
 622 {
 623         ++m_use_count;
 624 }
 625
 626 void eDVBChannel::ReleaseUse()
 627 {
 628         if (!--m_use_count)
 629         {
 630                 m_state = state_release;
 631                 m_stateChanged(this);
 632         }
 633 }
 634
 635 RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid, ePtr<iDVBFrontendParameters> &feparm)
 636 {
 637         if (m_channel_id)
 638                 m_mgr->removeChannel(this);
 639
 640         if (!channelid)
 641                 return 0;
 642
 643         if (!m_frontend)
 644         {
 645                 eDebug("no frontend to tune!");
 646                 return -ENODEV;
 647         }
 648
 649         m_channel_id = channelid;
 650         m_mgr->addChannel(channelid, this);
 651         m_state = state_tuning;
 652                         /* if tuning fails, shutdown the channel immediately. */
 653         int res;
 654         res = m_frontend->get().tune(*feparm);
 655
 656         if (res)
 657         {
 658                 m_state = state_release;
 659                 m_stateChanged(this);
 660                 return res;
 661         }
 662
 663         return 0;
 664 }
 665
 666 RESULT eDVBChannel::connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)
 667 {
 668         connection = new eConnection((iDVBChannel*)this, m_stateChanged.connect(stateChange));
 669         return 0;
 670 }
 671
 672 RESULT eDVBChannel::connectEvent(const Slot2<void,iDVBChannel*,int> &event, ePtr<eConnection> &connection)
 673 {
 674         connection = new eConnection((iDVBChannel*)this, m_event.connect(event));
 675         return 0;
 676 }
 677
 678 RESULT eDVBChannel::getState(int &state)
 679 {
 680         state = m_state;
 681         return 0;
 682 }
 683
 684 RESULT eDVBChannel::setCIRouting(const eDVBCIRouting &routing)
 685 {
 686         return -1;
 687 }
 688
 689 RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
 690 {
 691         ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
 692
 693         if (!our_demux)
 694         {
 695                 demux = 0;
 696
 697                 if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
 698                         return -1;
 699         }
 700
 701         demux = *our_demux;
 702                 /* don't hold a reference to the decoding demux, we don't need it. */
 703         if (cap & capDecode)
 704                 our_demux = 0;
 705         return 0;
 706 }
 707
 708 RESULT eDVBChannel::getFrontend(ePtr<iDVBFrontend> &frontend)
 709 {
 710         frontend = &m_frontend->get();
 711         if (frontend)
 712                 return 0;
 713         else
 714                 return -ENODEV;
 715 }
 716
 717 RESULT eDVBChannel::playFile(const char *file)
 718 {
 719         ASSERT(!m_frontend);
 720         if (m_pvr_thread)
 721         {
 722                 m_pvr_thread->stop();
 723                 delete m_pvr_thread;
 724                 m_pvr_thread = 0;
 725         }
 726
 727         m_tstools.openFile(file);
 728
 729                 /* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
 730                    THEN DO A REAL FIX HERE! */
 731
 732                 /* (this codepath needs to be improved anyway.) */
 733         m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
 734         if (m_pvr_fd_dst < 0)
 735         {
 736                 eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
 737                 return -ENODEV;
 738         }
 739
 740         m_pvr_fd_src = open(file, O_RDONLY|O_LARGEFILE);
 741         if (m_pvr_fd_src < 0)
 742         {
 743                 eDebug("can't open PVR m_pvr_fd_src file %s (%m)", file);
 744                 close(m_pvr_fd_dst);
 745                 return -ENOENT;
 746         }
 747
 748         m_state = state_ok;
 749         m_stateChanged(this);
 750
 751         m_pvr_thread = new eFilePushThread();
 752         m_pvr_thread->enablePVRCommit(1);
 753         m_pvr_thread->start(m_pvr_fd_src, m_pvr_fd_dst);
 754         CONNECT(m_pvr_thread->m_event, eDVBChannel::pvrEvent);
 755
 756         return 0;
 757 }
 758
 759 RESULT eDVBChannel::getLength(pts_t &len)
 760 {
 761         return m_tstools.calcLen(len);
 762 }
 763
 764 RESULT eDVBChannel::getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode)
 765 {
 766         if (!decoding_demux)
 767                 return -1;
 768
 769         off_t begin = 0;
 770                 /* getPTS for offset 0 is cached, so it doesn't harm. */
 771         int r = m_tstools.getPTS(begin, pos);
 772         if (r)
 773         {
 774                 eDebug("tstools getpts(0) failed!");
 775                 return r;
 776         }
 777
 778         pts_t now;
 779
 780                         /* TODO: this is a gross hack. */
 781         r = decoding_demux->getSTC(now, mode ? 128 : 0);
 782
 783         if (r)
 784         {
 785                 eDebug("demux getSTC failed");
 786                 return -1;
 787         }
 788
 789 //      eDebug("STC: %08llx PTS: %08llx, diff %lld", now, pos, now - pos);
 790                 /* when we are less than 10 seconds before the start, return 0. */
 791                 /* (we're just waiting for the timespam to start) */
 792         if ((now < pos) && ((pos - now) < 90000 * 10))
 793         {
 794                 pos = 0;
 795                 return 0;
 796         }
 797
 798         if (now < pos) /* wrap around */
 799                 pos = now + ((pts_t)1)<<33 - pos;
 800         else
 801                 pos = now - pos;
 802
 803         return 0;
 804 }
 805
 806 RESULT eDVBChannel::seekTo(iDVBDemux *decoding_demux, int relative, pts_t &pts)
 807 {
 808         int bitrate = m_tstools.calcBitrate(); /* in bits/s */
 809
 810         if (bitrate == -1)
 811                 return -1;
 812
 813         if (relative)
 814         {
 815                 pts_t now;
 816                 if (getCurrentPosition(decoding_demux, now, 0))
 817                 {
 818                         eDebug("seekTo: getCurrentPosition failed!");
 819                         return -1;
 820                 }
 821                 pts += now;
 822         }
 823
 824         if (pts < 0)
 825                 pts = 0;
 826
 827         off_t offset = (pts * (pts_t)bitrate) / 8ULL / 90000ULL;
 828
 829         seekToPosition(decoding_demux, offset);
 830         return 0;
 831 }
 832
 833 RESULT eDVBChannel::seekToPosition(iDVBDemux *decoding_demux, const off_t &r)
 834 {
 835                         /* when seeking, we have to ensure that all buffers are flushed.
 836                            there are basically 3 buffers:
 837                            a.) the filepush's internal buffer
 838                            b.) the PVR buffer (before demux)
 839                            c.) the ratebuffer (after demux)
 840
 841                            it's important to clear them in the correct order, otherwise
 842                            the ratebuffer (for example) would immediately refill from
 843                            the not-yet-flushed PVR buffer.
 844                         */
 845         eDebug("eDVBChannel: seekToPosition .. %llx", r);
 846         m_pvr_thread->pause();
 847
 848                 /* flush internal filepush buffer */
 849         m_pvr_thread->flush();
 850
 851                 /* HACK: flush PVR buffer */
 852         ::ioctl(m_pvr_fd_dst, 0);
 853
 854                 /* flush ratebuffers (video, audio) */
 855         if (decoding_demux)
 856                 decoding_demux->flush();
 857
 858                 /* demux will also flush all decoder.. */
 859         m_pvr_thread->seek(SEEK_SET, r);
 860         m_pvr_thread->resume();
 861         return 0;
 862 }