fix cable and terrestrial scan
[enigma2.git] / lib / dvb / scan.cpp
1 #include <lib/dvb/idvb.h>
2 #include <dvbsi++/service_description_section.h>
3 #include <dvbsi++/network_information_section.h>
4 #include <dvbsi++/bouquet_association_section.h>
5 #include <dvbsi++/descriptor_tag.h>
6 #include <dvbsi++/service_descriptor.h>
7 #include <dvbsi++/satellite_delivery_system_descriptor.h>
8 #include <dvbsi++/terrestrial_delivery_system_descriptor.h>
9 #include <dvbsi++/cable_delivery_system_descriptor.h>
10 #include <dvbsi++/ca_identifier_descriptor.h>
11 #include <lib/dvb/specs.h>
12 #include <lib/dvb/esection.h>
13 #include <lib/dvb/scan.h>
14 #include <lib/dvb/frontend.h>
15 #include <lib/base/eerror.h>
16 #include <lib/base/estring.h>
17 #include <errno.h>
18
19 #define SCAN_eDebug(x...) eDebug(x)
20 #define SCAN_eDebugNoNewLine(x...) eDebugNoNewLine(x)
21
22 DEFINE_REF(eDVBScan);
23
24 eDVBScan::eDVBScan(iDVBChannel *channel): m_channel(channel)
25 {
26         if (m_channel->getDemux(m_demux))
27                 SCAN_eDebug("scan: failed to allocate demux!");
28         m_channel->connectStateChange(slot(*this, &eDVBScan::stateChange), m_stateChanged_connection);
29 }
30
31 eDVBScan::~eDVBScan()
32 {
33 }
34
35 int eDVBScan::isValidONIDTSID(int orbital_position, eOriginalNetworkID onid, eTransportStreamID tsid)
36 {
37         switch (onid.get())
38         {
39         case 0:
40         case 0x1111:
41                 return 0;
42         case 1:
43                 return orbital_position == 192;
44         case 0x00B1:
45                 return tsid != 0x00B0;
46         case 0x0002:
47                 return abs(orbital_position-282) < 6;
48         default:
49                 return onid.get() < 0xFF00;
50         }
51 }
52
53 eDVBNamespace eDVBScan::buildNamespace(eOriginalNetworkID onid, eTransportStreamID tsid, unsigned long hash)
54 {
55                 // on valid ONIDs, ignore frequency ("sub network") part
56         if (isValidONIDTSID((hash >> 16) & 0xFFFF, onid, tsid))
57                 hash &= ~0xFFFF;
58         return eDVBNamespace(hash);
59 }
60
61 void eDVBScan::stateChange(iDVBChannel *ch)
62 {
63         int state;
64         if (ch->getState(state))
65                 return;
66         if (m_channel_state == state)
67                 return;
68         
69         if (state == iDVBChannel::state_ok)
70         {
71                 startFilter();
72                 m_channel_state = state;
73         } else if (state == iDVBChannel::state_failed)
74         {
75                 m_ch_unavailable.push_back(m_ch_current);
76                 nextChannel();
77         }
78                         /* unavailable will timeout, anyway. */
79 }
80
81 RESULT eDVBScan::nextChannel()
82 {
83         ePtr<iDVBFrontend> fe;
84
85         m_SDT = 0; m_BAT = 0; m_NIT = 0;
86
87         m_ready = 0;
88         
89                 /* check what we need */
90         m_ready_all = readySDT;
91         
92         if (m_flags & scanNetworkSearch)
93                 m_ready_all |= readyNIT;
94         
95         if (m_flags & scanSearchBAT)
96                 m_ready_all |= readyBAT;
97         
98         if (m_ch_toScan.empty())
99         {
100                 eDebug("no channels left to scan.");
101                 eDebug("%d channels scanned, %d were unavailable.", 
102                                 m_ch_scanned.size(), m_ch_unavailable.size());
103                 eDebug("%d channels in database.", m_new_channels.size());
104                 m_event(evtFinish);
105                 return -ENOENT;
106         }
107         
108         m_ch_current = m_ch_toScan.front();
109         
110         m_ch_toScan.pop_front();
111         
112         if (m_channel->getFrontend(fe))
113         {
114                 m_event(evtFail);
115                 return -ENOTSUP;
116         }
117
118         int fetype;
119         fe->getFrontendType(fetype);
120         if ( fetype == iDVBFrontend::feSatellite)
121         {
122                 eDVBFrontendParametersSatellite p;
123                 m_ch_current->getDVBS(p);
124                 m_chid_current = eDVBChannelID(p.orbital_position << 16, -1, -1);
125         }
126         else
127                 m_chid_current = eDVBChannelID();
128
129         m_channel_state = iDVBChannel::state_idle;
130         if (fe->tune(*m_ch_current))
131         {
132                 return nextChannel();
133                 m_event(evtFail);
134                 return -EINVAL;
135         }
136                 
137         m_event(evtUpdate);
138         return 0;
139 }
140
141 RESULT eDVBScan::startFilter()
142 {
143         assert(m_demux);
144         
145                         /* only start required filters filter */
146         
147         m_SDT = 0;
148
149         if (m_ready_all & readySDT)
150         {
151                 m_SDT = new eTable<ServiceDescriptionSection>();
152                 if (m_SDT->start(m_demux, eDVBSDTSpec()))
153                         return -1;
154                 CONNECT(m_SDT->tableReady, eDVBScan::SDTready);
155         }
156
157         m_NIT = 0;
158         if (m_ready_all & readyNIT)
159         {
160                 m_NIT = new eTable<NetworkInformationSection>();
161                 if (m_NIT->start(m_demux, eDVBNITSpec()))
162                         return -1;
163                 CONNECT(m_NIT->tableReady, eDVBScan::NITready);
164         }
165
166         m_BAT = 0;
167         if (m_ready_all & readyBAT)
168         {
169                 m_BAT = new eTable<BouquetAssociationSection>();
170                 if (m_BAT->start(m_demux, eDVBBATSpec()))
171                         return -1;
172                 CONNECT(m_BAT->tableReady, eDVBScan::BATready);
173         }
174         
175         return 0;
176 }
177
178 void eDVBScan::SDTready(int err)
179 {
180         SCAN_eDebug("got sdt");
181         m_ready |= readySDT;
182         if (!err)
183                 m_ready |= validSDT;
184         channelDone();
185 }
186
187 void eDVBScan::NITready(int err)
188 {
189         SCAN_eDebug("got nit, err %d", err);
190         m_ready |= readyNIT;
191         if (!err)
192                 m_ready |= validNIT;
193         channelDone();
194 }
195
196 void eDVBScan::BATready(int err)
197 {
198         SCAN_eDebug("got bat");
199         m_ready |= readyBAT;
200         if (!err)
201                 m_ready |= validBAT;
202         channelDone();
203 }
204
205 void eDVBScan::addKnownGoodChannel(const eDVBChannelID &chid, iDVBFrontendParameters *feparm)
206 {
207                 /* add it to the list of known channels. */
208         if (chid)
209                 m_new_channels.insert(std::pair<eDVBChannelID,ePtr<iDVBFrontendParameters> >(chid, feparm));
210 }
211
212 void eDVBScan::addChannelToScan(const eDVBChannelID &chid, iDVBFrontendParameters *feparm)
213 {
214                 /* check if we don't already have that channel ... */
215                 
216                 /* ... in the list of channels to scan */
217         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_toScan.begin()); i != m_ch_toScan.end(); ++i)
218                 if (sameChannel(*i, feparm))
219                         return;
220
221                 /* ... in the list of successfully scanned channels */
222         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_scanned.begin()); i != m_ch_scanned.end(); ++i)
223                 if (sameChannel(*i, feparm))
224                         return;
225                 
226                 /* ... in the list of unavailable channels */
227         for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator i(m_ch_unavailable.begin()); i != m_ch_unavailable.end(); ++i)
228                 if (sameChannel(*i, feparm))
229                         return;
230
231                 /* ... on the current channel */
232         if (sameChannel(m_ch_current, feparm))
233                 return;
234
235                 /* otherwise, add it to the todo list. */
236         m_ch_toScan.push_front(feparm); // better.. then the rotor not turning wild from east to west :)
237 }
238
239 int eDVBScan::sameChannel(iDVBFrontendParameters *ch1, iDVBFrontendParameters *ch2) const
240 {
241         int diff;
242         if (ch1->calculateDifference(ch2, diff))
243                 return 0;
244         if (diff < 4000) // more than 4mhz difference?
245                 return 1;
246         return 0;
247 }
248
249 void eDVBScan::channelDone()
250 {
251         if (m_ready & validSDT)
252         {
253                 unsigned long hash = 0;
254                 m_ch_current->getHash(hash);
255                 
256                 eDVBNamespace dvbnamespace = buildNamespace(
257                         (**m_SDT->getSections().begin()).getOriginalNetworkId(),
258                         (**m_SDT->getSections().begin()).getTransportStreamId(),
259                         hash);
260                 
261                 SCAN_eDebug("SDT: ");
262                 std::vector<ServiceDescriptionSection*>::const_iterator i;
263                 for (i = m_SDT->getSections().begin(); i != m_SDT->getSections().end(); ++i)
264                         processSDT(dvbnamespace, **i);
265                 m_ready &= ~validSDT;
266         }
267         
268         if (m_ready & validNIT)
269         {
270                 SCAN_eDebug("dumping NIT");
271                 std::vector<NetworkInformationSection*>::const_iterator i;
272                 for (i = m_NIT->getSections().begin(); i != m_NIT->getSections().end(); ++i)
273                 {
274                         const TransportStreamInfoList &tsinfovec = *(*i)->getTsInfo();
275                         
276                         for (TransportStreamInfoConstIterator tsinfo(tsinfovec.begin()); 
277                                 tsinfo != tsinfovec.end(); ++tsinfo)
278                         {
279                                 SCAN_eDebug("TSID: %04x ONID: %04x", (*tsinfo)->getTransportStreamId(),
280                                         (*tsinfo)->getOriginalNetworkId());
281                                 
282                                 eOriginalNetworkID onid = (*tsinfo)->getOriginalNetworkId();
283                                 eTransportStreamID tsid = (*tsinfo)->getTransportStreamId();
284                                 
285                                 for (DescriptorConstIterator desc = (*tsinfo)->getDescriptors()->begin();
286                                                 desc != (*tsinfo)->getDescriptors()->end(); ++desc)
287                                 {
288                                         switch ((*desc)->getTag())
289                                         {
290                                         case CABLE_DELIVERY_SYSTEM_DESCRIPTOR:
291                                         {
292                                                 CableDeliverySystemDescriptor &d = (CableDeliverySystemDescriptor&)**desc;
293                                                 ePtr<eDVBFrontendParameters> feparm = new eDVBFrontendParameters;
294                                                 eDVBFrontendParametersCable cable;
295                                                 cable.set(d);
296                                                 feparm->setDVBC(cable);
297
298                                                 unsigned long hash=0;
299                                                 feparm->getHash(hash);
300                                                 eDVBNamespace ns = buildNamespace(onid, tsid, hash);
301
302                                                 addChannelToScan(
303                                                         eDVBChannelID(ns, tsid, onid),
304                                                         feparm);
305                                                 break;
306                                         }
307                                         case TERRESTRIAL_DELIVERY_SYSTEM_DESCRIPTOR:
308                                         {
309                                                 TerrestrialDeliverySystemDescriptor &d = (TerrestrialDeliverySystemDescriptor&)**desc;
310                                                 ePtr<eDVBFrontendParameters> feparm = new eDVBFrontendParameters;
311                                                 eDVBFrontendParametersTerrestrial terr;
312                                                 terr.set(d);
313                                                 feparm->setDVBT(terr);
314
315                                                 unsigned long hash=0;
316                                                 feparm->getHash(hash);
317                                                 eDVBNamespace ns = buildNamespace(onid, tsid, hash);
318
319                                                 addChannelToScan(
320                                                         eDVBChannelID(ns, tsid, onid),
321                                                         feparm);
322                                                 break;
323                                         }
324                                         case SATELLITE_DELIVERY_SYSTEM_DESCRIPTOR:
325                                         {
326                                                 SatelliteDeliverySystemDescriptor &d = (SatelliteDeliverySystemDescriptor&)**desc;
327                                                 if (d.getFrequency() < 10000)
328                                                         break;
329                                                 
330                                                 ePtr<eDVBFrontendParameters> feparm = new eDVBFrontendParameters;
331                                                 eDVBFrontendParametersSatellite sat;
332                                                 sat.set(d);
333                                                 feparm->setDVBS(sat);
334                                                 unsigned long hash=0;
335                                                 feparm->getHash(hash);
336                                                 
337                                                 eDVBNamespace ns = buildNamespace(onid, tsid, hash);
338                                                 
339                                                 if ( m_chid_current.dvbnamespace.get() != -1 &&
340                                                         ((ns.get() ^ m_chid_current.dvbnamespace.get()) & 0xFFFF0000))
341                                                         eDebug("dropping this transponder, it's on another satellite.");
342                                                 else
343                                                 {
344                                                         addChannelToScan(
345                                                                         eDVBChannelID(ns, tsid, onid),
346                                                                         feparm);
347                                                 }
348                                                 break;
349                                         }
350                                         default:
351                                                 SCAN_eDebug("descr<%x>", (*desc)->getTag());
352                                                 break;
353                                         }
354                                 }
355                                 
356                         }
357                 }
358                 m_ready &= ~validNIT;
359         }
360         
361         if ((m_ready  & m_ready_all) != m_ready_all)
362                 return;
363         SCAN_eDebug("channel done!");
364         
365                 /* if we had services on this channel, we declare
366                    this channels as "known good". add it.
367                    
368                    (TODO: not yet implemented)
369                    a NIT entry could have possible overridden
370                    our frontend data with more exact data.
371                    
372                    (TODO: not yet implemented)
373                    the tuning process could have lead to more
374                    exact data than the user entered.
375                    
376                    The channel id was probably corrected
377                    by the data written in the SDT. this is
378                    important, as "initial transponder lists"
379                    usually don't have valid CHIDs (and that's
380                    good).
381                    
382                    These are the reasons for adding the transponder
383                    here, and not before.
384                 */
385         
386         if (!m_chid_current)
387                 eWarning("SCAN: the current channel's ID was not corrected - not adding channel.");
388         else
389                 addKnownGoodChannel(m_chid_current, m_ch_current);
390         
391         m_ch_scanned.push_back(m_ch_current);
392         nextChannel();
393 }
394
395 void eDVBScan::start(const eSmartPtrList<iDVBFrontendParameters> &known_transponders, int flags)
396 {
397         m_flags = flags;
398         m_ch_toScan.clear();
399         m_ch_scanned.clear();
400         m_ch_unavailable.clear();
401         m_new_channels.clear();
402         m_new_services.clear();
403         m_last_service = m_new_services.end();
404
405         for (eSmartPtrList<iDVBFrontendParameters>::const_iterator i(known_transponders.begin()); i != known_transponders.end(); ++i)
406         {
407                 bool exist=false;
408                 for (std::list<ePtr<iDVBFrontendParameters> >::const_iterator ii(m_ch_toScan.begin()); ii != m_ch_toScan.end(); ++ii)
409                 {
410                         if (sameChannel(*i, *ii))
411                         {
412                                 exist=true;
413                                 break;
414                         }
415                 }
416                 if (!exist)
417                         m_ch_toScan.push_back(*i);
418         }
419
420         nextChannel();
421 }
422
423 void eDVBScan::insertInto(iDVBChannelList *db)
424 {
425         for (std::map<eDVBChannelID, ePtr<iDVBFrontendParameters> >::const_iterator 
426                         ch(m_new_channels.begin()); ch != m_new_channels.end(); ++ch)
427                 db->addChannelToList(ch->first, ch->second);
428         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::const_iterator
429                 service(m_new_services.begin()); service != m_new_services.end(); ++service)
430         {
431                 ePtr<eDVBService> dvb_service;
432                 if (!db->getService(service->first, dvb_service))
433                         *dvb_service = *service->second;
434                 else
435                         db->addService(service->first, service->second);
436         }
437 }
438
439 RESULT eDVBScan::processSDT(eDVBNamespace dvbnamespace, const ServiceDescriptionSection &sdt)
440 {
441         const ServiceDescriptionList &services = *sdt.getDescriptions();
442         SCAN_eDebug("ONID: %04x", sdt.getOriginalNetworkId());
443         eDVBChannelID chid(dvbnamespace, sdt.getTransportStreamId(), sdt.getOriginalNetworkId());
444         
445                 /* save correct CHID for this channel if this is an ACTUAL_SDT */
446         if (sdt.getTableId() == TID_SDT_ACTUAL)
447                 m_chid_current = chid;
448         
449         for (ServiceDescriptionConstIterator s(services.begin()); s != services.end(); ++s)
450         {
451                 SCAN_eDebugNoNewLine("SID %04x: ", (*s)->getServiceId());
452
453                 eServiceReferenceDVB ref;
454                 ePtr<eDVBService> service = new eDVBService;
455                 
456                 ref.set(chid);
457                 ref.setServiceID((*s)->getServiceId());
458
459                 for (DescriptorConstIterator desc = (*s)->getDescriptors()->begin();
460                                 desc != (*s)->getDescriptors()->end(); ++desc)
461                         if ((*desc)->getTag() == SERVICE_DESCRIPTOR)
462                                 ref.setServiceType(((ServiceDescriptor&)**desc).getServiceType());
463                 
464                 for (DescriptorConstIterator desc = (*s)->getDescriptors()->begin();
465                                 desc != (*s)->getDescriptors()->end(); ++desc)
466                 {
467                         switch ((*desc)->getTag())
468                         {
469                         case SERVICE_DESCRIPTOR:
470                         {
471                                 ServiceDescriptor &d = (ServiceDescriptor&)**desc;
472                                 service->m_service_name = convertDVBUTF8(d.getServiceName());
473                                 service->genSortName();
474
475                                 service->m_provider_name = convertDVBUTF8(d.getServiceProviderName());
476                                 SCAN_eDebug("name '%s', provider_name '%s'", service->m_service_name.c_str(), service->m_provider_name.c_str());
477                                 break;
478                         }
479                         case CA_IDENTIFIER_DESCRIPTOR:
480                         {
481                                 CaIdentifierDescriptor &d = (CaIdentifierDescriptor&)**desc;
482                                 const CaSystemIdList &caids = *d.getCaSystemIds();
483                                 SCAN_eDebugNoNewLine("CA ");
484                                 for (CaSystemIdList::const_iterator i(caids.begin()); i != caids.end(); ++i)
485                                 {
486                                         SCAN_eDebugNoNewLine("%04x ", *i);
487                                         service->m_ca.insert(*i);
488                                 }
489                                 SCAN_eDebug("");
490                                 break;
491                         }
492                         default:
493                                 SCAN_eDebug("descr<%x>", (*desc)->getTag());
494                                 break;
495                         }
496                 }
497                 
498                 std::pair<std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator, bool> i = m_new_services.insert(std::pair<eServiceReferenceDVB, ePtr<eDVBService> >(ref, service));
499                 
500                 if (i.second)
501                 {
502                         m_last_service = i.first;
503                         m_event(evtNewService);
504                 }
505         }
506         return 0;
507 }
508
509 RESULT eDVBScan::connectEvent(const Slot1<void,int> &event, ePtr<eConnection> &connection)
510 {
511         connection = new eConnection(this, m_event.connect(event));
512         return 0;
513 }
514
515 void eDVBScan::getStats(int &transponders_done, int &transponders_total, int &services)
516 {
517         transponders_done = m_ch_scanned.size() + m_ch_unavailable.size();
518         transponders_total = m_ch_toScan.size() + transponders_done;
519         services = m_new_services.size();
520 }
521
522 void eDVBScan::getLastServiceName(std::string &last_service_name)
523 {
524         if (m_last_service == m_new_services.end())
525                 last_service_name = "";
526         else
527                 last_service_name = m_last_service->second->m_service_name;
528 }