lib/dvb/scan.cpp

   1 #include <lib/dvb/idvb.h>
   2 #include <lib/dvb_si/sdt.h>
   3 #include <lib/dvb_si/nit.h>
   4 #include <lib/dvb_si/bat.h>
   5 #include <lib/dvb_si/descriptor_tag.h>
   6 #include <lib/dvb_si/service_descriptor.h>
   7 #include <lib/dvb_si/satellite_delivery_system_descriptor.h>
   8 #include <lib/dvb_si/ca_identifier_descriptor.h>
   9 #include <lib/dvb/specs.h>
  10 #include <lib/dvb/esection.h>
  11 #include <lib/dvb/scan.h>
  12 #include <lib/dvb/frontend.h>
  13 #include <lib/base/eerror.h>
  14 #include <errno.h>
  15
  16 #define SCAN_eDebug(x...) eDebug(x)
  17 #define SCAN_eDebugNoNewLine(x...) eDebugNoNewLine(x)
  18
  19 DEFINE_REF(eDVBScan);
  20
  21 eDVBScan::eDVBScan(iDVBChannel *channel): m_channel(channel)
  22 {
  23         if (m_channel->getDemux(m_demux))
  24                 SCAN_eDebug("scan: failed to allocate demux!");
  25         m_channel->connectStateChange(slot(*this, &eDVBScan::stateChange), m_stateChanged_connection);
  26 }
  27
  28 eDVBScan::~eDVBScan()
  29 {
  30 }
  31
  32 int eDVBScan::isValidONIDTSID(eOriginalNetworkID onid, eTransportStreamID tsid)
  33 {
  34         switch (onid.get())
  35         {
  36         case 0:
  37         case 0xFFFF:
  38         case 0x1111:
  39                 return 0;
  40         case 1:
  41                 return tsid>1;
  42         case 0x00B1:
  43                 return tsid != 0x00B0;
  44         case 0x0002:
  45                 return tsid != 0x07E8;
  46         default:
  47                 return 1;
  48         }
  49 }
  50
  51 eDVBNamespace eDVBScan::buildNamespace(eOriginalNetworkID onid, eTransportStreamID tsid, unsigned long hash)
  52 {
  53                 // on valid ONIDs, ignore frequency ("sub network") part
  54         if (isValidONIDTSID(onid, tsid))
  55                 hash &= ~0xFFFF;
  56         return eDVBNamespace(hash);
  57 }
  58
  59 void eDVBScan::stateChange(iDVBChannel *ch)
  60 {
  61         int state;
  62         if (ch->getState(state))
  63                 return;
  64         if (m_channel_state == state)
  65                 return;
  66
  67         if (state == iDVBChannel::state_ok)
  68         {
  69                 startFilter();
  70                 m_channel_state = state;
  71         } else if (state == iDVBChannel::state_unavailable)
  72         {
  73                 m_ch_unavailable.push_back(m_ch_current);
  74                 nextChannel();
  75         }
  76 }
  77
  78 RESULT eDVBScan::nextChannel()
  79 {
  80         ePtr<iDVBFrontend> fe;
  81
  82         m_SDT = 0; m_BAT = 0; m_NIT = 0;
  83
  84         m_ready = readyBAT;
  85         if (m_ch_toScan.empty())
  86         {
  87                 eDebug("no channels left to scan.");
  88                 eDebug("%d channels scanned, %d were unavailable.",
  89                                 m_ch_scanned.size(), m_ch_unavailable.size());
  90                 eDebug("%d channels in database.", m_new_channels.size());
  91                 m_event(evtFinish);
  92                 return -ENOENT;
  93         }
  94
  95         m_ch_current = m_ch_toScan.front();
  96         m_ch_toScan.pop_front();
  97
  98         if (m_channel->getFrontend(fe))
  99         {
 100                 m_event(evtFail);
 101                 return -ENOTSUP;
 102         }
 103
 104         m_channel_state = iDVBChannel::state_idle;
 105         if (fe->tune(*m_ch_current))
 106         {
 107                 return nextChannel();
 108                 m_event(evtFail);
 109                 return -EINVAL;
 110         }
 111
 112         m_event(evtUpdate);
 113         return 0;
 114 }
 115
 116 RESULT eDVBScan::startFilter()
 117 {
 118         assert(m_demux);
 119
 120         m_SDT = new eTable<ServiceDescriptionTable>();
 121         if (m_SDT->start(m_demux, eDVBSDTSpec()))
 122                 return -1;
 123         CONNECT(m_SDT->tableReady, eDVBScan::SDTready);
 124
 125         m_NIT = 0;
 126         m_NIT = new eTable<NetworkInformationTable>();
 127         if (m_NIT->start(m_demux, eDVBNITSpec()))
 128                 return -1;
 129         CONNECT(m_NIT->tableReady, eDVBScan::NITready);
 130
 131         m_BAT = new eTable<BouquetAssociationTable>();
 132         if (m_BAT->start(m_demux, eDVBBATSpec()))
 133                 return -1;
 134         CONNECT(m_BAT->tableReady, eDVBScan::BATready);
 135
 136         return 0;
 137 }
 138
 139 void eDVBScan::SDTready(int err)
 140 {
 141         SCAN_eDebug("got sdt");
 142         m_ready |= readySDT;
 143         if (!err)
 144                 m_ready |= validSDT;
 145         channelDone();
 146 }
 147
 148 void eDVBScan::NITready(int err)
 149 {
 150         SCAN_eDebug("got nit, err %d", err);
 151         m_ready |= readyNIT;
 152         if (!err)
 153                 m_ready |= validNIT;
 154         channelDone();
 155 }
 156
 157 void eDVBScan::BATready(int err)
 158 {
 159         SCAN_eDebug("got bat");
 160         m_ready |= readyBAT;
 161         if (!err)
 162                 m_ready |= validBAT;
 163         channelDone();
 164 }
 165
 166 void eDVBScan::addChannel(const eDVBChannelID &chid, iDVBFrontendParameters *feparm)
 167 {
 168                 /* add it to the list of known channels. */
 169         if (chid)
 170                 m_new_channels.insert(std::pair<eDVBChannelID,ePtr<iDVBFrontendParameters> >(chid, feparm));
 171
 172                 /* check if we don't already have that channel ... */
 173
 174                 /* ... in the list of channels to scan */
 175         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_toScan.begin()); i != m_ch_toScan.end(); ++i)
 176                 if (sameChannel(*i, feparm))
 177                         return;
 178
 179                 /* ... in the list of successfully scanned channels */
 180         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_scanned.begin()); i != m_ch_scanned.end(); ++i)
 181                 if (sameChannel(*i, feparm))
 182                         return;
 183
 184                 /* ... in the list of unavailable channels */
 185         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_unavailable.begin()); i != m_ch_unavailable.end(); ++i)
 186                 if (sameChannel(*i, feparm))
 187                         return;
 188
 189                 /* ... on the current channel */
 190         if (sameChannel(m_ch_current, feparm))
 191                 return;
 192
 193                 /* otherwise, add it to the todo list. */
 194         m_ch_toScan.push_back(feparm);
 195 }
 196
 197 int eDVBScan::sameChannel(iDVBFrontendParameters *ch1, iDVBFrontendParameters *ch2) const
 198 {
 199         int diff;
 200         if (ch1->calculateDifference(ch2, diff))
 201                 return 0;
 202         if (diff < 4000) // more than 4mhz difference?
 203                 return 1;
 204         return 0;
 205 }
 206
 207 void eDVBScan::channelDone()
 208 {
 209         if (m_ready & validSDT)
 210         {
 211                 unsigned long hash = 0;
 212                 m_ch_current->getHash(hash);
 213
 214                 eDVBNamespace dvbnamespace = buildNamespace(
 215                         (**m_SDT->getSections().begin()).getOriginalNetworkId(),
 216                         (**m_SDT->getSections().begin()).getTransportStreamId(),
 217                         hash);
 218
 219                 SCAN_eDebug("SDT: ");
 220                 ServiceDescriptionTableConstIterator i;
 221                 for (i = m_SDT->getSections().begin(); i != m_SDT->getSections().end(); ++i)
 222                         processSDT(dvbnamespace, **i);
 223                 m_ready &= ~validSDT;
 224         }
 225
 226         if (m_ready & validNIT)
 227         {
 228                 SCAN_eDebug("dumping NIT");
 229                 NetworkInformationTableConstIterator i;
 230                 for (i = m_NIT->getSections().begin(); i != m_NIT->getSections().end(); ++i)
 231                 {
 232                         const TransportStreamInfoVector &tsinfovec = *(*i)->getTsInfo();
 233
 234                         for (TransportStreamInfoConstIterator tsinfo(tsinfovec.begin());
 235                                 tsinfo != tsinfovec.end(); ++tsinfo)
 236                         {
 237                                 SCAN_eDebug("TSID: %04x ONID: %04x", (*tsinfo)->getTransportStreamId(),
 238                                         (*tsinfo)->getOriginalNetworkId());
 239
 240                                 eOriginalNetworkID onid = (*tsinfo)->getOriginalNetworkId();
 241                                 eTransportStreamID tsid = (*tsinfo)->getTransportStreamId();
 242
 243                                 for (DescriptorConstIterator desc = (*tsinfo)->getDescriptors()->begin();
 244                                                 desc != (*tsinfo)->getDescriptors()->end(); ++desc)
 245                                 {
 246                                         switch ((*desc)->getTag())
 247                                         {
 248 //                                      case SERVICE_LIST_DESCRIPTOR:
 249                                         case SATELLITE_DELIVERY_SYSTEM_DESCRIPTOR:
 250                                         {
 251                                                 SatelliteDeliverySystemDescriptor &d = (SatelliteDeliverySystemDescriptor&)**desc;
 252                                                 SCAN_eDebug("%d kHz, %d%d%d.%d%c %s MOD:%d %d symb/s, fec %d",
 253                                                                 d.getFrequency(),
 254                                                                 (d.getOrbitalPosition()>>12)&0xF,
 255                                                                 (d.getOrbitalPosition()>>8)&0xF,
 256                                                                 (d.getOrbitalPosition()>>4)&0xF,
 257                                                                 d.getOrbitalPosition()&0xF, d.getWestEastFlag()?'E':'W',
 258                                                                 d.getPolarization() ? "hor" : "vert",
 259                                                                 d.getModulation(), d.getSymbolRate(), d.getFecInner());
 260
 261                                                         /* some sanity checking: below 100MHz is invalid */
 262                                                 if (d.getFrequency() < 10000)
 263                                                         break;
 264
 265                                                 ePtr<eDVBFrontendParameters> feparm = new eDVBFrontendParameters;
 266                                                 eDVBFrontendParametersSatellite sat;
 267                                                 sat.set(d);
 268                                                 feparm->setDVBS(sat);
 269                                                 unsigned long hash=0;
 270                                                 feparm->getHash(hash);
 271
 272                                                 eDVBNamespace ns = buildNamespace(onid, tsid, hash);
 273
 274                                                 addChannel(
 275                                                                 eDVBChannelID(ns, tsid, onid),
 276                                                                 feparm);
 277                                                 break;
 278                                         }
 279                                         default:
 280                                                 SCAN_eDebug("descr<%x>", (*desc)->getTag());
 281                                                 break;
 282                                         }
 283                                 }
 284
 285                         }
 286                 }
 287                 m_ready &= ~validNIT;
 288         }
 289
 290         if ((m_ready  & readyAll) != readyAll)
 291                 return;
 292         SCAN_eDebug("channel done!");
 293         m_ch_scanned.push_back(m_ch_current);
 294         nextChannel();
 295 }
 296
 297 void eDVBScan::start(const std::list<ePtr<iDVBFrontendParameters> > &known_transponders)
 298 {
 299         m_ch_toScan.clear();
 300         m_ch_scanned.clear();
 301         m_ch_unavailable.clear();
 302         m_new_channels.clear();
 303         m_new_services.clear();
 304         m_ch_toScan.insert(m_ch_toScan.end(), known_transponders.begin(), known_transponders.end());
 305         nextChannel();
 306 }
 307
 308 void eDVBScan::insertInto(iDVBChannelList *db)
 309 {
 310         for (std::map<eDVBChannelID, ePtr<iDVBFrontendParameters> >::const_iterator
 311                         ch(m_new_channels.begin()); ch != m_new_channels.end(); ++ch)
 312                 db->addChannelToList(ch->first, ch->second);
 313         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::const_iterator
 314                 service(m_new_services.begin()); service != m_new_services.end(); ++service)
 315         {
 316                 ePtr<eDVBService> dvb_service;
 317                 if (!db->getService(service->first, dvb_service))
 318                         *dvb_service = *service->second;
 319                 else
 320                         db->addService(service->first, service->second);
 321         }
 322 }
 323
 324 RESULT eDVBScan::processSDT(eDVBNamespace dvbnamespace, const ServiceDescriptionTable &sdt)
 325 {
 326         const ServiceDescriptionVector &services = *sdt.getDescriptions();
 327         SCAN_eDebug("ONID: %04x", sdt.getOriginalNetworkId());
 328         eDVBChannelID chid(dvbnamespace, sdt.getTransportStreamId(), sdt.getOriginalNetworkId());
 329
 330         for (ServiceDescriptionConstIterator s(services.begin()); s != services.end(); ++s)
 331         {
 332                 SCAN_eDebugNoNewLine("SID %04x: ", (*s)->getServiceId());
 333
 334                 eServiceReferenceDVB ref;
 335                 ePtr<eDVBService> service = new eDVBService;
 336
 337                 ref.set(chid);
 338                 ref.setServiceID((*s)->getServiceId());
 339
 340                 for (DescriptorConstIterator desc = (*s)->getDescriptors()->begin();
 341                                 desc != (*s)->getDescriptors()->end(); ++desc)
 342                         if ((*desc)->getTag() == SERVICE_DESCRIPTOR)
 343                                 ref.setServiceType(((ServiceDescriptor&)**desc).getServiceType());
 344
 345                 for (DescriptorConstIterator desc = (*s)->getDescriptors()->begin();
 346                                 desc != (*s)->getDescriptors()->end(); ++desc)
 347                 {
 348                         switch ((*desc)->getTag())
 349                         {
 350                         case SERVICE_DESCRIPTOR:
 351                         {
 352                                 ServiceDescriptor &d = (ServiceDescriptor&)**desc;
 353                                 SCAN_eDebug("name '%s', provider_name '%s'", d.getServiceName().c_str(), d.getServiceProviderName().c_str());
 354                                 service->m_service_name = d.getServiceName();
 355                                 service->m_provider_name = d.getServiceProviderName();
 356                                 break;
 357                         }
 358                         case CA_IDENTIFIER_DESCRIPTOR:
 359                         {
 360                                 CaIdentifierDescriptor &d = (CaIdentifierDescriptor&)**desc;
 361                                 const CaSystemIdVector &caids = *d.getCaSystemIds();
 362                                 SCAN_eDebugNoNewLine("CA ");
 363                                 for (CaSystemIdVector::const_iterator i(caids.begin()); i != caids.end(); ++i)
 364                                 {
 365                                         SCAN_eDebugNoNewLine("%04x ", *i);
 366                                         service->m_ca.insert(*i);
 367                                 }
 368                                 SCAN_eDebug("");
 369                                 break;
 370                         }
 371                         default:
 372                                 SCAN_eDebug("descr<%x>", (*desc)->getTag());
 373                                 break;
 374                         }
 375                 }
 376
 377                 m_new_services.insert(std::pair<eServiceReferenceDVB, ePtr<eDVBService> >(ref, service));
 378         }
 379         return 0;
 380 }
 381
 382 RESULT eDVBScan::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &connection)
 383 {
 384         connection = new eConnection(this, m_event.connect(event));
 385         return 0;
 386 }
 387
 388 void eDVBScan::getStats(int &transponders_done, int &transponders_total, int &services)
 389 {
 390         transponders_done = m_ch_scanned.size() + m_ch_unavailable.size();
 391         transponders_total = m_ch_toScan.size() + transponders_done;
 392         services = m_new_services.size();
 393 }