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>
12 #include <sys/ioctl.h>
14 DEFINE_REF(eDVBRegisteredFrontend);
15 DEFINE_REF(eDVBRegisteredDemux);
17 DEFINE_REF(eDVBAllocatedFrontend);
19 eDVBAllocatedFrontend::eDVBAllocatedFrontend(eDVBRegisteredFrontend *fe): m_fe(fe)
24 eDVBAllocatedFrontend::~eDVBAllocatedFrontend()
29 DEFINE_REF(eDVBAllocatedDemux);
31 eDVBAllocatedDemux::eDVBAllocatedDemux(eDVBRegisteredDemux *demux): m_demux(demux)
36 eDVBAllocatedDemux::~eDVBAllocatedDemux()
41 DEFINE_REF(eDVBResourceManager);
43 eDVBResourceManager *eDVBResourceManager::instance;
45 eDVBResourceManager::eDVBResourceManager()
49 m_sec = new eDVBSatelliteEquipmentControl(m_frontend);
53 /* search available adapters... */
58 while (eDVBAdapterLinux::exist(num_adapter))
60 addAdapter(new eDVBAdapterLinux(num_adapter));
64 eDebug("found %d adapter, %d frontends and %d demux",
65 m_adapter.size(), m_frontend.size(), m_demux.size());
69 DEFINE_REF(eDVBAdapterLinux);
70 eDVBAdapterLinux::eDVBAdapterLinux(int nr): m_nr(nr)
75 eDebug("scanning for frontends..");
80 #if HAVE_DVB_API_VERSION < 3
81 sprintf(filename, "/dev/dvb/card%d/frontend%d", m_nr, num_fe);
83 sprintf(filename, "/dev/dvb/adapter%d/frontend%d", m_nr, num_fe);
85 if (stat(filename, &s))
87 ePtr<eDVBFrontend> fe;
90 fe = new eDVBFrontend(m_nr, num_fe, ok);
92 m_frontend.push_back(fe);
102 #if HAVE_DVB_API_VERSION < 3
103 sprintf(filename, "/dev/dvb/card%d/demux%d", m_nr, num_demux);
105 sprintf(filename, "/dev/dvb/adapter%d/demux%d", m_nr, num_demux);
107 if (stat(filename, &s))
109 ePtr<eDVBDemux> demux;
111 demux = new eDVBDemux(m_nr, num_demux);
112 m_demux.push_back(demux);
118 int eDVBAdapterLinux::getNumDemux()
120 return m_demux.size();
123 RESULT eDVBAdapterLinux::getDemux(ePtr<eDVBDemux> &demux, int nr)
125 eSmartPtrList<eDVBDemux>::iterator i(m_demux.begin());
126 while (nr && (i != m_demux.end()))
132 if (i != m_demux.end())
140 int eDVBAdapterLinux::getNumFrontends()
142 return m_frontend.size();
145 RESULT eDVBAdapterLinux::getFrontend(ePtr<eDVBFrontend> &fe, int nr)
147 eSmartPtrList<eDVBFrontend>::iterator i(m_frontend.begin());
148 while (nr && (i != m_frontend.end()))
154 if (i != m_frontend.end())
162 int eDVBAdapterLinux::exist(int nr)
166 #if HAVE_DVB_API_VERSION < 3
167 sprintf(filename, "/dev/dvb/card%d", nr);
169 sprintf(filename, "/dev/dvb/adapter%d", nr);
171 if (!stat(filename, &s))
176 eDVBResourceManager::~eDVBResourceManager()
178 if (instance == this)
182 void eDVBResourceManager::addAdapter(iDVBAdapter *adapter)
184 int num_fe = adapter->getNumFrontends();
185 int num_demux = adapter->getNumDemux();
187 m_adapter.push_back(adapter);
190 for (i=0; i<num_demux; ++i)
192 ePtr<eDVBDemux> demux;
193 if (!adapter->getDemux(demux, i))
194 m_demux.push_back(new eDVBRegisteredDemux(demux, adapter));
197 for (i=0; i<num_fe; ++i)
199 ePtr<eDVBFrontend> frontend;
201 if (!adapter->getFrontend(frontend, i))
203 frontend->setSEC(m_sec);
204 m_frontend.push_back(new eDVBRegisteredFrontend(frontend, adapter));
209 RESULT eDVBResourceManager::allocateFrontend(ePtr<eDVBAllocatedFrontend> &fe, ePtr<iDVBFrontendParameters> &feparm)
211 ePtr<eDVBRegisteredFrontend> best;
214 for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
217 int c = i->m_frontend->isCompatibleWith(feparm);
227 fe = new eDVBAllocatedFrontend(best);
236 RESULT eDVBResourceManager::allocateFrontendByIndex(ePtr<eDVBAllocatedFrontend> &fe, int nr)
238 for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i, --nr)
239 if ((!nr) && !i->m_inuse)
241 fe = new eDVBAllocatedFrontend(i);
249 RESULT eDVBResourceManager::allocateDemux(eDVBRegisteredFrontend *fe, ePtr<eDVBAllocatedDemux> &demux, int cap)
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. */
254 eDebug("allocate demux");
255 eSmartPtrList<eDVBRegisteredDemux>::iterator i(m_demux.begin());
257 if (i == m_demux.end())
261 /* FIXME: hardware demux policy */
262 if (!(cap & iDVBChannel::capDecode))
265 for (; i != m_demux.end(); ++i, ++n)
266 if ((!i->m_inuse) && ((!fe) || (i->m_adapter == fe->m_adapter)))
268 if ((cap & iDVBChannel::capDecode) && n)
271 demux = new eDVBAllocatedDemux(i);
273 demux->get().setSourceFrontend(fe->m_frontend->getID());
275 demux->get().setSourcePVR(0);
278 eDebug("demux not found");
282 RESULT eDVBResourceManager::setChannelList(iDVBChannelList *list)
288 RESULT eDVBResourceManager::getChannelList(ePtr<iDVBChannelList> &list)
297 RESULT eDVBResourceManager::allocateChannel(const eDVBChannelID &channelid, eUsePtr<iDVBChannel> &channel)
299 /* first, check if a channel is already existing. */
301 if (m_cached_channel)
303 eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
304 if(channelid==cache_chan->getChannelID())
306 eDebug("use cached_channel");
307 channel = m_cached_channel;
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)
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)
319 // eDebug("found shared channel..");
320 channel = i->m_channel;
325 /* no currently available channel is tuned to this channelid. create a new one, if possible. */
329 eDebug("no channel list set!");
333 ePtr<iDVBFrontendParameters> feparm;
334 if (m_list->getChannelFrontendData(channelid, feparm))
336 eDebug("channel not found!");
340 /* allocate a frontend. */
342 ePtr<eDVBAllocatedFrontend> fe;
344 if (allocateFrontend(fe, feparm))
345 return errNoFrontend;
348 ePtr<eDVBChannel> ch;
349 ch = new eDVBChannel(this, fe);
351 res = ch->setChannel(channelid, feparm);
355 return errChidNotFound;
357 m_cached_channel = channel = ch;
362 RESULT eDVBResourceManager::allocateRawChannel(eUsePtr<iDVBChannel> &channel, int frontend_index)
364 ePtr<eDVBAllocatedFrontend> fe;
366 if (m_cached_channel)
369 if (allocateFrontendByIndex(fe, frontend_index))
370 return errNoFrontend;
373 ch = new eDVBChannel(this, fe);
380 RESULT eDVBResourceManager::allocatePVRChannel(eUsePtr<iDVBPVRChannel> &channel)
382 ePtr<eDVBAllocatedDemux> demux;
384 if (m_cached_channel)
388 ch = new eDVBChannel(this, 0);
394 RESULT eDVBResourceManager::addChannel(const eDVBChannelID &chid, eDVBChannel *ch)
396 m_active_channels.push_back(active_channel(chid, ch));
397 /* emit */ m_channelAdded(ch);
401 RESULT eDVBResourceManager::removeChannel(eDVBChannel *ch)
404 for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end();)
406 if (i->m_channel == ch)
408 i = m_active_channels.erase(i);
419 RESULT eDVBResourceManager::connectChannelAdded(const Slot1<void,eDVBChannel*> &channelAdded, ePtr<eConnection> &connection)
421 connection = new eConnection((eDVBResourceManager*)this, m_channelAdded.connect(channelAdded));
425 bool eDVBResourceManager::canAllocateFrontend(ePtr<iDVBFrontendParameters> &feparm)
427 ePtr<eDVBRegisteredFrontend> best;
430 for (eSmartPtrList<eDVBRegisteredFrontend>::iterator i(m_frontend.begin()); i != m_frontend.end(); ++i)
433 int c = i->m_frontend->isCompatibleWith(feparm);
441 bool eDVBResourceManager::canAllocateChannel(const eDVBChannelID &channelid, const eDVBChannelID& ignore)
444 if (m_cached_channel)
446 eDVBChannel *cache_chan = (eDVBChannel*)&(*m_cached_channel);
447 if(channelid==cache_chan->getChannelID())
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)
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)
458 // eDebug("found shared channel..");
463 int *decremented_cached_channel_fe_usecount=NULL,
464 *decremented_fe_usecount=NULL;
466 for (std::list<active_channel>::iterator i(m_active_channels.begin()); i != m_active_channels.end(); ++i)
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)
471 eDVBChannel *channel = (eDVBChannel*) &(*i->m_channel);
472 if (channel == &(*m_cached_channel) ? channel->getUseCount() == 2 : channel->getUseCount() == 1) // channel only used once..
474 ePtr<iDVBFrontend> fe;
475 if (!i->m_channel->getFrontend(fe))
477 for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
479 if ( &(*fe) == &(*ii->m_frontend) )
482 decremented_fe_usecount = &ii->m_inuse;
483 if (channel == &(*m_cached_channel))
484 decremented_cached_channel_fe_usecount = decremented_fe_usecount;
494 if (!decremented_cached_channel_fe_usecount)
496 if (m_cached_channel)
498 eDVBChannel *channel = (eDVBChannel*) &(*m_cached_channel);
499 if (channel->getUseCount() == 1)
501 ePtr<iDVBFrontend> fe;
502 if (!channel->getFrontend(fe))
504 for (eSmartPtrList<eDVBRegisteredFrontend>::iterator ii(m_frontend.begin()); ii != m_frontend.end(); ++ii)
506 if ( &(*fe) == &(*ii->m_frontend) )
509 decremented_cached_channel_fe_usecount = &ii->m_inuse;
518 decremented_cached_channel_fe_usecount=NULL;
520 ePtr<iDVBFrontendParameters> feparm;
524 eDebug("no channel list set!");
529 if (m_list->getChannelFrontendData(channelid, feparm))
531 eDebug("channel not found!");
536 ret = canAllocateFrontend(feparm);
539 if (decremented_fe_usecount)
540 ++(*decremented_fe_usecount);
541 if (decremented_cached_channel_fe_usecount)
542 ++(*decremented_cached_channel_fe_usecount);
547 DEFINE_REF(eDVBChannel);
549 eDVBChannel::eDVBChannel(eDVBResourceManager *mgr, eDVBAllocatedFrontend *frontend): m_state(state_idle), m_mgr(mgr)
551 m_frontend = frontend;
555 m_skipmode_n = m_skipmode_m = 0;
558 m_frontend->get().connectStateChange(slot(*this, &eDVBChannel::frontendStateChanged), m_conn_frontendStateChanged);
561 eDVBChannel::~eDVBChannel()
564 m_mgr->removeChannel(this);
569 void eDVBChannel::frontendStateChanged(iDVBFrontend*fe)
571 int state, ourstate = 0;
573 /* if we are already in shutdown, don't change state. */
574 if (m_state == state_release)
577 if (fe->getState(state))
580 if (state == iDVBFrontend::stateLock)
582 eDebug("OURSTATE: ok");
584 } else if (state == iDVBFrontend::stateTuning)
586 eDebug("OURSTATE: tuning");
587 ourstate = state_tuning;
588 } else if (state == iDVBFrontend::stateLostLock)
590 /* on managed channels, we try to retune in order to re-acquire lock. */
593 eDebug("OURSTATE: lost lock, trying to retune");
594 ourstate = state_tuning;
595 m_frontend->get().tune(*m_feparm);
597 /* on unmanaged channels, we don't do this. the client will do this. */
599 eDebug("OURSTATE: lost lock, unavailable now.");
600 ourstate = state_unavailable;
602 } else if (state == iDVBFrontend::stateFailed)
604 eDebug("OURSTATE: failed");
605 ourstate = state_failed;
607 eFatal("state unknown");
609 if (ourstate != m_state)
612 m_stateChanged(this);
616 void eDVBChannel::pvrEvent(int event)
620 case eFilePushThread::evtEOF:
621 eDebug("eDVBChannel: End of file!");
622 m_event(this, evtEOF);
624 case eFilePushThread::evtUser: /* start */
626 m_event(this, evtSOF);
631 void eDVBChannel::cueSheetEvent(int event)
635 case eCueSheet::evtSeek:
637 flushPVR(m_cue->m_decoding_demux);
639 case eCueSheet::evtSkipmode:
642 eSingleLocker l(m_cue->m_lock);
643 m_cue->m_seek_requests.push_back(std::pair<int, pts_t>(1, 0)); /* resync */
644 if (m_cue->m_skipmode_ratio)
646 int bitrate = m_tstools.calcBitrate(); /* in bits/s */
647 eDebug("skipmode ratio is %lld:90000, bitrate is %d bit/s", m_cue->m_skipmode_ratio, bitrate);
648 /* i agree that this might look a bit like black magic. */
649 m_skipmode_n = 512*1024; /* must be 1 iframe at least. */
650 m_skipmode_m = bitrate / 8 / 90000 * m_cue->m_skipmode_ratio;
652 eDebug("resolved to: %d %d", m_skipmode_m, m_skipmode_n);
654 if (abs(m_skipmode_m) < abs(m_skipmode_n))
656 eFatal("damn, something is wrong with this calculation");
657 m_skipmode_n = m_skipmode_m = 0;
662 eDebug("skipmode ratio is 0, normal play");
663 m_skipmode_n = m_skipmode_m = 0;
666 flushPVR(m_cue->m_decoding_demux);
669 case eCueSheet::evtSpanChanged:
670 eDebug("source span translation not yet supported");
671 // recheckCuesheetSpans();
676 /* remember, this gets called from another thread. */
677 void eDVBChannel::getNextSourceSpan(off_t current_offset, size_t bytes_read, off_t &start, size_t &size)
679 unsigned int max = 10*1024*1024;
683 eDebug("no cue sheet. forcing normal play");
684 start = current_offset;
689 eSingleLocker l(m_cue->m_lock);
691 if (!m_cue->m_decoding_demux)
693 start = current_offset;
695 eDebug("getNextSourceSpan, no decoding demux. forcing normal play");
701 eDebug("skipmode %d:%d", m_skipmode_m, m_skipmode_n);
705 eDebug("getNextSourceSpan, current offset is %08llx!", current_offset);
707 if ((current_offset < -m_skipmode_m) && (m_skipmode_m < 0))
709 eDebug("reached SOF");
711 m_pvr_thread->sendEvent(eFilePushThread::evtUser);
714 current_offset += m_skipmode_m;
716 while (!m_cue->m_seek_requests.empty())
718 std::pair<int, pts_t> seek = m_cue->m_seek_requests.front();
719 m_cue->m_seek_requests.pop_front();
720 int relative = seek.first;
721 pts_t pts = seek.second;
723 int bitrate = m_tstools.calcBitrate(); /* in bits/s */
731 /* we're using the decoder's timestamp here. this
732 won't work for radio (ouch). */
733 if (getCurrentPosition(m_cue->m_decoding_demux, now, 1))
735 eDebug("seekTo: getCurrentPosition failed!");
744 off_t offset = (pts * (pts_t)bitrate) / 8ULL / 90000ULL;
746 eDebug("ok, resolved skip (rel: %d, diff %lld), now at %08llx", relative, pts, offset);
747 current_offset = offset;
750 for (std::list<std::pair<off_t, off_t> >::const_iterator i(m_source_span.begin()); i != m_source_span.end(); ++i)
752 if ((current_offset >= i->first) && (current_offset < i->second))
754 start = current_offset;
755 size = i->second - current_offset;
758 eDebug("HIT, %lld < %lld < %lld", i->first, current_offset, i->second);
761 if (current_offset < i->first)
764 size = i->second - i->first;
772 start = current_offset;
774 eDebug("END OF CUESHEET. (%08llx, %d)", start, size);
781 void eDVBChannel::AddUse()
786 void eDVBChannel::ReleaseUse()
790 m_state = state_release;
791 m_stateChanged(this);
795 RESULT eDVBChannel::setChannel(const eDVBChannelID &channelid, ePtr<iDVBFrontendParameters> &feparm)
798 m_mgr->removeChannel(this);
805 eDebug("no frontend to tune!");
809 m_channel_id = channelid;
810 m_mgr->addChannel(channelid, this);
811 m_state = state_tuning;
812 /* if tuning fails, shutdown the channel immediately. */
814 res = m_frontend->get().tune(*feparm);
819 m_state = state_release;
820 m_stateChanged(this);
827 RESULT eDVBChannel::connectStateChange(const Slot1<void,iDVBChannel*> &stateChange, ePtr<eConnection> &connection)
829 connection = new eConnection((iDVBChannel*)this, m_stateChanged.connect(stateChange));
833 RESULT eDVBChannel::connectEvent(const Slot2<void,iDVBChannel*,int> &event, ePtr<eConnection> &connection)
835 connection = new eConnection((iDVBChannel*)this, m_event.connect(event));
839 RESULT eDVBChannel::getState(int &state)
845 RESULT eDVBChannel::setCIRouting(const eDVBCIRouting &routing)
850 RESULT eDVBChannel::getDemux(ePtr<iDVBDemux> &demux, int cap)
852 ePtr<eDVBAllocatedDemux> &our_demux = (cap & capDecode) ? m_decoder_demux : m_demux;
858 if (m_mgr->allocateDemux(m_frontend ? (eDVBRegisteredFrontend*)*m_frontend : (eDVBRegisteredFrontend*)0, our_demux, cap))
863 /* don't hold a reference to the decoding demux, we don't need it. */
869 RESULT eDVBChannel::getFrontend(ePtr<iDVBFrontend> &frontend)
871 frontend = &m_frontend->get();
878 RESULT eDVBChannel::playFile(const char *file)
883 m_pvr_thread->stop();
888 m_tstools.openFile(file);
890 /* DON'T EVEN THINK ABOUT FIXING THIS. FIX THE ATI SOURCES FIRST,
891 THEN DO A REAL FIX HERE! */
893 /* (this codepath needs to be improved anyway.) */
894 m_pvr_fd_dst = open("/dev/misc/pvr", O_WRONLY);
895 if (m_pvr_fd_dst < 0)
897 eDebug("can't open /dev/misc/pvr - you need to buy the new(!) $$$ box! (%m)"); // or wait for the driver to be improved.
901 m_pvr_fd_src = open(file, O_RDONLY|O_LARGEFILE);
902 if (m_pvr_fd_src < 0)
904 eDebug("can't open PVR m_pvr_fd_src file %s (%m)", file);
910 m_stateChanged(this);
912 m_pvr_thread = new eFilePushThread();
913 m_pvr_thread->enablePVRCommit(1);
914 m_pvr_thread->setScatterGather(this);
916 m_pvr_thread->start(m_pvr_fd_src, m_pvr_fd_dst);
917 CONNECT(m_pvr_thread->m_event, eDVBChannel::pvrEvent);
922 void eDVBChannel::stopFile()
926 m_pvr_thread->stop();
927 ::close(m_pvr_fd_src);
928 ::close(m_pvr_fd_dst);
934 void eDVBChannel::setCueSheet(eCueSheet *cuesheet)
936 m_conn_cueSheetEvent = 0;
939 m_cue->connectEvent(slot(*this, &eDVBChannel::cueSheetEvent), m_conn_cueSheetEvent);
942 RESULT eDVBChannel::getLength(pts_t &len)
944 return m_tstools.calcLen(len);
947 RESULT eDVBChannel::getCurrentPosition(iDVBDemux *decoding_demux, pts_t &pos, int mode)
953 /* getPTS for offset 0 is cached, so it doesn't harm. */
954 int r = m_tstools.getPTS(begin, pos);
957 eDebug("tstools getpts(0) failed!");
963 /* TODO: this is a gross hack. */
964 r = decoding_demux->getSTC(now, mode ? 128 : 0);
968 eDebug("demux getSTC failed");
972 // eDebug("STC: %08llx PTS: %08llx, diff %lld", now, pos, now - pos);
973 /* when we are less than 10 seconds before the start, return 0. */
974 /* (we're just waiting for the timespam to start) */
975 if ((now < pos) && ((pos - now) < 90000 * 10))
981 if (now < pos) /* wrap around */
982 pos = now + ((pts_t)1)<<33 - pos;
989 void eDVBChannel::flushPVR(iDVBDemux *decoding_demux)
991 /* when seeking, we have to ensure that all buffers are flushed.
992 there are basically 3 buffers:
993 a.) the filepush's internal buffer
994 b.) the PVR buffer (before demux)
995 c.) the ratebuffer (after demux)
997 it's important to clear them in the correct order, otherwise
998 the ratebuffer (for example) would immediately refill from
999 the not-yet-flushed PVR buffer.
1002 m_pvr_thread->pause();
1003 /* flush internal filepush buffer */
1004 m_pvr_thread->flush();
1005 /* HACK: flush PVR buffer */
1006 ::ioctl(m_pvr_fd_dst, 0);
1008 /* flush ratebuffers (video, audio) */
1010 decoding_demux->flush();
1012 /* demux will also flush all decoder.. */
1013 /* resume will re-query the SG */
1014 m_pvr_thread->resume();
1017 DEFINE_REF(eCueSheet);
1019 eCueSheet::eCueSheet()
1021 m_skipmode_ratio = 0;
1024 void eCueSheet::seekTo(int relative, const pts_t &pts)
1027 eSingleLock l(m_lock);
1028 m_seek_requests.push_back(std::pair<int, pts_t>(relative, pts));
1033 void eCueSheet::clear()
1035 eSingleLock l(m_lock);
1039 void eCueSheet::addSourceSpan(const pts_t &begin, const pts_t &end)
1042 eSingleLock l(m_lock);
1043 m_spans.push_back(std::pair<pts_t, pts_t>(begin, end));
1045 m_event(evtSpanChanged);
1048 void eCueSheet::setSkipmode(const pts_t &ratio)
1051 eSingleLock l(m_lock);
1052 m_skipmode_ratio = ratio;
1054 m_event(evtSkipmode);
1057 void eCueSheet::setDecodingDemux(iDVBDemux *demux)
1059 m_decoding_demux = demux;
1062 RESULT eCueSheet::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &connection)
1064 connection = new eConnection(this, m_event.connect(event));