MythTV  master
atscstreamdata.cpp
Go to the documentation of this file.
1 // -*- Mode: c++ -*-
2 // Copyright (c) 2003-2004, Daniel Thor Kristjansson
3 
4 #include <cmath>
5 
6 #include <algorithm>
7 using namespace std;
8 
9 #include "atscstreamdata.h"
10 #include "atsctables.h"
11 #include "sctetables.h"
12 #include "eithelper.h"
13 
14 #define LOC QString("ATSCStream[%1]: ").arg(m_cardId)
15 
34 ATSCStreamData::ATSCStreamData(int desiredMajorChannel,
35  int desiredMinorChannel,
36  int cardnum, bool cacheTables)
37  : MPEGStreamData(-1, cardnum, cacheTables),
38  m_desiredMajorChannel(desiredMajorChannel),
39  m_desiredMinorChannel(desiredMinorChannel)
40 {
43 }
44 
46 {
47  Reset(-1,-1);
48 
49  QMutexLocker locker(&m_listenerLock);
50  m_atscMainListeners.clear();
51  m_atscAuxListeners.clear();
52  m_atscEitListeners.clear();
53 
54  m_scteMainlisteners.clear();
55  m_atsc81EitListeners.clear();
56 }
57 
59 {
60  bool reset = true;
61  const MasterGuideTable *mgt = GetCachedMGT();
62  tvct_vec_t tvcts = GetCachedTVCTs();
63  cvct_vec_t cvcts = GetCachedCVCTs();
64 
65  if (mgt && (!tvcts.empty() || !cvcts.empty()))
66  {
67  const TerrestrialVirtualChannelTable *tvct = nullptr;
68  const CableVirtualChannelTable *cvct = nullptr;
69  int chan_idx = -1;
70  for (uint i = 0; (i < tvcts.size()) && (chan_idx < 0); i++)
71  {
72  tvct = tvcts[i];
73  chan_idx = tvcts[i]->Find(major, minor);
74  }
75  for (uint i = (chan_idx < 0) ? 0 : cvcts.size();
76  (i < cvcts.size()) && (chan_idx < 0); i++)
77  {
78  cvct = cvcts[i];
79  chan_idx = cvcts[i]->Find(major, minor);
80  }
81 
82  if (chan_idx >= 0)
83  {
84  m_desiredMajorChannel = major;
86 
87  ProcessMGT(mgt);
88 
89  if (cvct)
90  {
91  ProcessCVCT(cvct->TransportStreamID(), cvct);
92  SetDesiredProgram(cvct->ProgramNumber(chan_idx));
93  }
94  else if (tvct)
95  {
96  ProcessTVCT(tvct->TransportStreamID(), tvct);
97  SetDesiredProgram(tvct->ProgramNumber(chan_idx));
98  }
99  reset = false;
100  }
101  }
102 
103  ReturnCachedTable(mgt);
104  ReturnCachedTVCTTables(tvcts);
105  ReturnCachedCVCTTables(cvcts);
106 
107  if (reset)
108  Reset(major, minor);
109 }
110 
111 void ATSCStreamData::Reset(int desiredProgram)
112 {
113  MPEGStreamData::Reset(desiredProgram);
116 }
117 
118 void ATSCStreamData::Reset(int desiredMajorChannel, int desiredMinorChannel)
119 {
120  m_desiredMajorChannel = desiredMajorChannel;
121  m_desiredMinorChannel = desiredMinorChannel;
122 
124  m_mgtVersion = -1;
125  m_tvctVersion.clear();
126  m_cvctVersion.clear();
127  m_eitStatus.clear();
128 
129  m_sourceIdToAtscMajMin.clear();
130  m_atscEitPids.clear();
131  m_atscEttPids.clear();
132 
133  {
134  QMutexLocker locker(&m_cacheLock);
135 
137  m_cachedMgt = nullptr;
138 
139  for (const auto & cached : qAsConst(m_cachedTvcts))
140  DeleteCachedTable(cached);
141  m_cachedTvcts.clear();
142 
143  for (const auto & cached : qAsConst(m_cachedCvcts))
144  DeleteCachedTable(cached);
145  m_cachedCvcts.clear();
146  }
147 
150 }
151 
159 bool ATSCStreamData::IsRedundant(uint pid, const PSIPTable &psip) const
160 {
161  if (MPEGStreamData::IsRedundant(pid, psip))
162  return true;
163 
164  const int table_id = psip.TableID();
165  const int version = psip.Version();
166 
167  if (TableID::EIT == table_id)
168  {
169  uint key = (pid<<16) | psip.TableIDExtension();
170  return m_eitStatus.IsSectionSeen(key, version, psip.Section());
171  }
172 
173  if (TableID::ETT == table_id)
174  return false; // retransmit ETT's we've seen
175 
176  if (TableID::STT == table_id)
177  return false; // each SystemTimeTable matters
178 
179  if (TableID::STTscte == table_id)
180  return false; // each SCTESystemTimeTable matters
181 
182  if (TableID::MGT == table_id)
183  return VersionMGT() == version;
184 
185  if (TableID::TVCT == table_id)
186  {
187  return VersionTVCT(psip.TableIDExtension()) == version;
188  }
189 
190  if (TableID::CVCT == table_id)
191  {
192  return VersionCVCT(psip.TableIDExtension()) == version;
193  }
194 
195  if (TableID::RRT == table_id)
196  return VersionRRT(psip.TableIDExtension()) == version;
197 
198  if (TableID::PIM == table_id)
199  return true; // ignore these messages..
200 
201  if (TableID::PNM == table_id)
202  return true; // ignore these messages..
203 
204  return false;
205 }
206 
208 {
209  if (MPEGStreamData::HandleTables(pid, psip))
210  return true;
211 
212  if (IsRedundant(pid, psip))
213  return true;
214 
215  const int version = psip.Version();
216 
217  // Decode any table we know about
218  switch (psip.TableID())
219  {
220  case TableID::MGT:
221  {
223  if (m_cacheTables)
224  {
225  auto *mgt = new MasterGuideTable(psip);
226  CacheMGT(mgt);
227  ProcessMGT(mgt);
228  }
229  else
230  {
231  MasterGuideTable mgt(psip);
232  ProcessMGT(&mgt);
233  }
234  return true;
235  }
236  case TableID::TVCT:
237  {
238  uint tsid = psip.TableIDExtension();
239  SetVersionTVCT(tsid, version);
240  if (m_cacheTables)
241  {
242  auto *vct = new TerrestrialVirtualChannelTable(psip);
243  CacheTVCT(pid, vct);
244  ProcessTVCT(tsid, vct);
245  }
246  else
247  {
249  ProcessTVCT(tsid, &vct);
250  }
251  return true;
252  }
253  case TableID::CVCT:
254  {
255  uint tsid = psip.TableIDExtension();
256  SetVersionCVCT(tsid, version);
257  if (m_cacheTables)
258  {
259  auto *vct = new CableVirtualChannelTable(psip);
260  CacheCVCT(pid, vct);
261  ProcessCVCT(tsid, vct);
262  }
263  else
264  {
265  CableVirtualChannelTable vct(psip);
266  ProcessCVCT(tsid, &vct);
267  }
268  return true;
269  }
270  case TableID::RRT:
271  {
272  uint region = psip.TableIDExtension();
273  SetVersionRRT(region, version);
274  RatingRegionTable rrt(psip);
275  QMutexLocker locker(&m_listenerLock);
276  for (auto & listener : m_atscAuxListeners)
277  listener->HandleRRT(&rrt);
278  return true;
279  }
280  case TableID::EIT:
281  {
282  QMutexLocker locker(&m_listenerLock);
283  if (m_atscEitListeners.empty() && !m_eitHelper)
284  return true;
285 
286  uint key = (pid<<16) | psip.TableIDExtension();
287  m_eitStatus.SetSectionSeen(key, version, psip.Section(), psip.LastSection());
288 
289  EventInformationTable eit(psip);
290  for (auto & listener : m_atscEitListeners)
291  listener->HandleEIT(pid, &eit);
292 
293  const uint mm = GetATSCMajorMinor(eit.SourceID());
294  if (mm && m_eitHelper)
295  m_eitHelper->AddEIT(mm >> 16, mm & 0xffff, &eit);
296 
297  return true;
298  }
299  case TableID::ETT:
300  {
301  ExtendedTextTable ett(psip);
302 
303  QMutexLocker locker(&m_listenerLock);
304  for (auto & listener : m_atscEitListeners)
305  listener->HandleETT(pid, &ett);
306 
307  if (ett.IsEventETM() && m_eitHelper) // Guide ETTs
308  {
309  const uint mm = GetATSCMajorMinor(ett.SourceID());
310  if (mm)
311  m_eitHelper->AddETT(mm >> 16, mm & 0xffff, &ett);
312  }
313 
314  return true;
315  }
316  case TableID::STT:
317  {
318  SystemTimeTable stt(psip);
319 
320  UpdateTimeOffset(stt.UTCUnix());
321 
322  // only update internal offset if it changes
323  if (stt.GPSOffset() != m_gpsUtcOffset)
324  m_gpsUtcOffset = stt.GPSOffset();
325 
326  m_listenerLock.lock();
327  for (auto & listener : m_atscMainListeners)
328  listener->HandleSTT(&stt);
329  m_listenerLock.unlock();
330 
333 
334  return true;
335  }
336  case TableID::DCCT:
337  {
338  DirectedChannelChangeTable dcct(psip);
339 
340  QMutexLocker locker(&m_listenerLock);
341  for (auto & listener : m_atscAuxListeners)
342  listener->HandleDCCT(&dcct);
343 
344  return true;
345  }
346  case TableID::DCCSCT:
347  {
349 
350  QMutexLocker locker(&m_listenerLock);
351  for (auto & listener : m_atscAuxListeners)
352  listener->HandleDCCSCT(&dccsct);
353 
354  return true;
355  }
356 
357  // ATSC A/81 & SCTE 65 tables
358  case TableID::AEIT:
359  {
361 
362  QMutexLocker locker(&m_listenerLock);
363  for (auto & listener : m_atsc81EitListeners)
364  listener->HandleAEIT(pid, &aeit);
365 
366  return true;
367  }
368  case TableID::AETT:
369  {
370  AggregateExtendedTextTable aett(psip);
371 
372  QMutexLocker locker(&m_listenerLock);
373  for (auto & listener : m_atsc81EitListeners)
374  listener->HandleAETT(pid, &aett);
375 
376  return true;
377  }
378 
379  // SCTE 65 tables
380  case TableID::NITscte:
381  {
382  SCTENetworkInformationTable nit(psip);
383 
384  QMutexLocker locker(&m_listenerLock);
385  for (auto & listener : m_scteMainlisteners)
386  listener->HandleNIT(&nit);
387 
388  return true;
389  }
390  case TableID::NTT:
391  {
392  NetworkTextTable ntt(psip);
393 
394  QMutexLocker locker(&m_listenerLock);
395  for (auto & listener : m_scteMainlisteners)
396  listener->HandleNTT(&ntt);
397 
398  return true;
399  }
400  case TableID::SVCTscte:
401  {
402  ShortVirtualChannelTable svct(psip);
403 
404  QMutexLocker locker(&m_listenerLock);
405  for (auto & listener : m_scteMainlisteners)
406  listener->HandleSVCT(&svct);
407 
408  return true;
409  }
410  case TableID::STTscte:
411  {
412  SCTESystemTimeTable stt(psip);
413 
414  QMutexLocker locker(&m_listenerLock);
415  for (auto & listener : m_scteMainlisteners)
416  listener->HandleSTT(&stt);
417 
418  return true;
419  }
420 
421  // SCTE 57 table -- SCTE 65 standard supercedes this
422  case TableID::PIM:
423  {
425 
426  QMutexLocker locker(&m_listenerLock);
427  for (auto & listener : m_scteMainlisteners)
428  listener->HandlePIM(&pim);
429 
430  return true;
431  }
432  // SCTE 57 table -- SCTE 65 standard supercedes this
433  case TableID::PNM:
434  {
435  ProgramNameMessageTable pnm(psip);
436 
437  QMutexLocker locker(&m_listenerLock);
438  for (auto & listener : m_scteMainlisteners)
439  listener->HandlePNM(&pnm);
440 
441  return true;
442  }
443 
444  // SCTE 80
445  case TableID::ADET:
446  {
447  AggregateDataEventTable adet(psip);
448 
449  QMutexLocker locker(&m_listenerLock);
450  for (auto & listener : m_scteMainlisteners)
451  listener->HandleADET(&adet);
452 
453  return true;
454  }
455 
456  case TableID::NIT:
457  case TableID::NITo:
458  case TableID::SDT:
459  case TableID::SDTo:
460  case TableID::BAT:
461  case TableID::TDT:
462  case TableID::TOT:
463  case TableID::DVBCA_82:
464  case TableID::DVBCA_83:
465  {
466  // All DVB specific tables, not handled here
467  return false;
468  }
469 
470  default:
471  {
472  LOG(VB_RECORD, LOG_ERR, LOC +
473  QString("ATSCStreamData::HandleTables(): Unknown table 0x%1")
474  .arg(psip.TableID(),0,16));
475  break;
476  }
477  }
478  return false;
479 }
480 
481 bool ATSCStreamData::HasEITPIDChanges(const uint_vec_t &in_use_pids) const
482 {
483  QMutexLocker locker(&m_listenerLock);
484  uint eit_count = (uint) round(m_atscEitPids.size() * m_eitRate);
485  uint ett_count = (uint) round(m_atscEttPids.size() * m_eitRate);
486  return (in_use_pids.size() != (eit_count + ett_count) || m_atscEitReset);
487 }
488 
490  uint_vec_t &add_pids,
491  uint_vec_t &del_pids) const
492 {
493  QMutexLocker locker(&m_listenerLock);
494 
495  m_atscEitReset = false;
496 
497  uint eit_count = (uint) round(m_atscEitPids.size() * m_eitRate);
498  uint ett_count = (uint) round(m_atscEttPids.size() * m_eitRate);
499 
500 #if 0
501  LOG(VB_GENERAL, LOG_DEBUG, LOC + QString("eit size: %1, rate: %2, cnt: %3")
502  .arg(m_atscEitPids.size()).arg(m_eitRate).arg(eit_count));
503 #endif
504 
505  uint_vec_t add_pids_tmp;
506  atsc_eit_pid_map_t::const_iterator it = m_atscEitPids.begin();
507  for (uint i = 0; it != m_atscEitPids.end() && (i < eit_count); (++it),(i++))
508  add_pids_tmp.push_back(*it);
509 
510  atsc_ett_pid_map_t::const_iterator it2 = m_atscEttPids.begin();
511  for (uint i = 0; it2 != m_atscEttPids.end() && (i < ett_count); (++it2),(i++))
512  add_pids_tmp.push_back(*it2);
513 
514  uint_vec_t::const_iterator it3;
515  for (uint pid : cur_pids)
516  {
517  it3 = find(add_pids_tmp.begin(), add_pids_tmp.end(), pid);
518  if (it3 == add_pids_tmp.end())
519  del_pids.push_back(pid);
520  }
521 
522  for (uint pid : add_pids_tmp)
523  {
524  it3 = find(cur_pids.begin(), cur_pids.end(), pid);
525  if (it3 == cur_pids.end())
526  add_pids.push_back(pid);
527  }
528 
529  return !add_pids.empty() || !del_pids.empty();
530 }
531 
533 {
534  QMutexLocker locker(&m_listenerLock);
535 
536  m_atscEitReset = true;
537  m_atscEitPids.clear();
538  m_atscEttPids.clear();
539 
540  for (uint i = 0 ; i < mgt->TableCount(); i++)
541  {
542  const int table_class = mgt->TableClass(i);
543  const uint pid = mgt->TablePID(i);
544 
545  if (table_class == TableClass::EIT)
546  {
547  const uint num = mgt->TableType(i) - 0x100;
548  m_atscEitPids[num] = pid;
549  }
550  else if (table_class == TableClass::ETTe)
551  {
552  const uint num = mgt->TableType(i) - 0x200;
553  m_atscEttPids[num] = pid;
554  }
555  }
556 
557  for (auto & listener : m_atscMainListeners)
558  listener->HandleMGT(mgt);
559 }
560 
562 {
563  for (auto & listener : m_atscMainListeners)
564  listener->HandleVCT(tsid, vct);
565 
566  m_sourceIdToAtscMajMin.clear();
567  for (uint i = 0; i < vct->ChannelCount() ; i++)
568  {
569  if (vct->IsHidden(i) && vct->IsHiddenInGuide(i))
570  {
571  LOG(VB_EIT, LOG_INFO, LOC +
572  QString("%1 chan %2-%3 is hidden in guide")
573  .arg(vct->ModulationMode(i) == 1 ? "NTSC" : "ATSC")
574  .arg(vct->MajorChannel(i))
575  .arg(vct->MinorChannel(i)));
576  continue;
577  }
578 
579  if (1 == vct->ModulationMode(i))
580  {
581  LOG(VB_EIT, LOG_INFO, LOC + QString("Ignoring NTSC chan %1-%2")
582  .arg(vct->MajorChannel(i))
583  .arg(vct->MinorChannel(i)));
584  continue;
585  }
586 
587  LOG(VB_EIT, LOG_INFO, LOC + QString("Adding Source #%1 ATSC chan %2-%3")
588  .arg(vct->SourceID(i))
589  .arg(vct->MajorChannel(i))
590  .arg(vct->MinorChannel(i)));
591 
593  vct->MajorChannel(i) << 16 | vct->MinorChannel(i);
594  }
595 }
596 
599 {
600  QMutexLocker locker(&m_listenerLock);
601  ProcessVCT(tsid, vct);
602  for (auto & listener : m_atscAuxListeners)
603  listener->HandleTVCT(tsid, vct);
604 }
605 
607  const CableVirtualChannelTable *vct)
608 {
609  QMutexLocker locker(&m_listenerLock);
610  ProcessVCT(tsid, vct);
611  for (auto & listener : m_atscAuxListeners)
612  listener->HandleCVCT(tsid, vct);
613 }
614 
616 {
617  if (!current)
618  LOG(VB_GENERAL, LOG_WARNING, LOC +
619  "Currently we ignore \'current\' param");
620 
621  return (bool)(m_cachedMgt);
622 }
623 
625 {
626  bool hasit = false;
627 
628  {
629  tvct_vec_t tvct = GetCachedTVCTs();
630  for (size_t i = 0; i < tvct.size() && !hasit; i++)
631  {
632  if (tvct[i]->Find(major, minor) >= 0)
633  hasit |= HasProgram(tvct[i]->ProgramNumber(i));
634  }
636  }
637 
638  if (!hasit)
639  {
640  cvct_vec_t cvct = GetCachedCVCTs();
641  for (size_t i = 0; i < cvct.size() && !hasit; i++)
642  {
643  if (cvct[i]->Find(major, minor) >= 0)
644  hasit |= HasProgram(cvct[i]->ProgramNumber(i));
645  }
647  }
648 
649  return hasit;
650 }
651 
653 {
654  if (!current)
655  LOG(VB_GENERAL, LOG_WARNING, LOC +
656  "Currently we ignore \'current\' param");
657 
658  m_cacheLock.lock();
659  tvct_cache_t::const_iterator it = m_cachedTvcts.find(pid);
660  bool exists = (it != m_cachedTvcts.end());
661  m_cacheLock.unlock();
662 
663  return exists;
664 }
665 
667 {
668  if (!current)
669  LOG(VB_GENERAL, LOG_WARNING, LOC +
670  "Currently we ignore \'current\' param");
671 
672  m_cacheLock.lock();
673  cvct_cache_t::const_iterator it = m_cachedCvcts.find(pid);
674  bool exists = (it != m_cachedCvcts.end());
675  m_cacheLock.unlock();
676 
677  return exists;
678 }
679 
681 {
682  if (!current)
683  LOG(VB_GENERAL, LOG_WARNING, LOC +
684  "Currently we ignore \'current\' param");
685 
686  if (!m_cachedMgt)
687  return false;
688 
689  m_cacheLock.lock();
690  bool ret = false;
691  for (uint i = 0; (i < m_cachedMgt->TableCount()); ++i)
692  {
694  {
696  {
697  ret = true;
698  }
699  else
700  {
701  ret = false;
702  break;
703  }
704  }
705  }
706  m_cacheLock.unlock();
707 
708  return ret;
709 }
710 
712 {
713  if (!current)
714  LOG(VB_GENERAL, LOG_WARNING, LOC +
715  "Currently we ignore \'current\' param");
716 
717  if (!m_cachedMgt)
718  return false;
719 
720  m_cacheLock.lock();
721  bool ret = false;
722  for (uint i = 0; (i < m_cachedMgt->TableCount()); ++i)
723  {
725  {
727  {
728  ret = true;
729  }
730  else
731  {
732  ret = false;
733  break;
734  }
735  }
736  }
737  m_cacheLock.unlock();
738 
739  return ret;
740 }
741 
743 {
744  if (!current)
745  LOG(VB_GENERAL, LOG_WARNING, LOC +
746  "Currently we ignore \'current\' param");
747 
748  QMutexLocker locker(&m_cacheLock);
749  return !m_cachedTvcts.empty();
750 }
751 
753 {
754  if (!current)
755  LOG(VB_GENERAL, LOG_WARNING, LOC +
756  "Currently we ignore \'current\' param");
757 
758  QMutexLocker locker(&m_cacheLock);
759  return !m_cachedCvcts.empty();
760 }
761 
763 {
764  if (!current)
765  LOG(VB_GENERAL, LOG_WARNING, LOC +
766  "Currently we ignore \'current\' param");
767 
768  m_cacheLock.lock();
769  const MasterGuideTable *mgt = m_cachedMgt;
770  IncrementRefCnt(mgt);
771  m_cacheLock.unlock();
772 
773  return mgt;
774 }
775 
777 {
778  if (!current)
779  LOG(VB_GENERAL, LOG_WARNING, LOC +
780  "Currently we ignore \'current\' param");
781 
782  tvct_ptr_t tvct = nullptr;
783 
784  m_cacheLock.lock();
785  tvct_cache_t::const_iterator it = m_cachedTvcts.find(pid);
786  if (it != m_cachedTvcts.end())
787  IncrementRefCnt(tvct = *it);
788  m_cacheLock.unlock();
789 
790  return tvct;
791 }
792 
794 {
795  if (!current)
796  LOG(VB_GENERAL, LOG_WARNING, LOC +
797  "Currently we ignore \'current\' param");
798 
799  cvct_ptr_t cvct = nullptr;
800 
801  m_cacheLock.lock();
802  cvct_cache_t::const_iterator it = m_cachedCvcts.find(pid);
803  if (it != m_cachedCvcts.end())
804  IncrementRefCnt(cvct = *it);
805  m_cacheLock.unlock();
806 
807  return cvct;
808 }
809 
811 {
812  if (!current)
813  LOG(VB_GENERAL, LOG_WARNING, LOC +
814  "Currently we ignore \'current\' param");
815 
816  vector<const TerrestrialVirtualChannelTable*> tvcts;
817 
818  m_cacheLock.lock();
819  tvct_cache_t::const_iterator it = m_cachedTvcts.begin();
820  for (; it != m_cachedTvcts.end(); ++it)
821  {
822  TerrestrialVirtualChannelTable* tvct = *it;
823  IncrementRefCnt(tvct);
824  tvcts.push_back(tvct);
825  }
826  m_cacheLock.unlock();
827 
828  return tvcts;
829 }
830 
832 {
833  if (!current)
834  LOG(VB_GENERAL, LOG_WARNING, LOC +
835  "Currently we ignore \'current\' param");
836 
837  vector<const CableVirtualChannelTable*> cvcts;
838 
839  m_cacheLock.lock();
840  for (auto *cvct : qAsConst(m_cachedCvcts))
841  {
842  IncrementRefCnt(cvct);
843  cvcts.push_back(cvct);
844  }
845  m_cacheLock.unlock();
846 
847  return cvcts;
848 }
849 
851 {
852  QMutexLocker locker(&m_cacheLock);
853 
855  m_cachedMgt = mgt;
856 }
857 
859 {
860  QMutexLocker locker(&m_cacheLock);
861 
863  m_cachedTvcts[pid] = tvct;
864 }
865 
867 {
868  QMutexLocker locker(&m_cacheLock);
869 
871  m_cachedCvcts[pid] = cvct;
872 }
873 
875 {
876  if (!psip)
877  return false;
878 
879  QMutexLocker locker(&m_cacheLock);
880  if (m_cachedRefCnt[psip] > 0)
881  {
882  m_cachedSlatedForDeletion[psip] = 1;
883  return false;
884  }
885  if (TableID::MGT == psip->TableID())
886  {
887  if (psip == m_cachedMgt)
888  m_cachedMgt = nullptr;
889  delete psip;
890  }
891  else if ((TableID::TVCT == psip->TableID()) &&
892  m_cachedTvcts[psip->tsheader()->PID()])
893  {
894  m_cachedTvcts[psip->tsheader()->PID()] = nullptr;
895  delete psip;
896  }
897  else if ((TableID::CVCT == psip->TableID()) &&
898  m_cachedCvcts[psip->tsheader()->PID()])
899  {
900  m_cachedCvcts[psip->tsheader()->PID()] = nullptr;
901  delete psip;
902  }
903  else
904  {
906  }
907  psip_refcnt_map_t::iterator it;
908  it = m_cachedSlatedForDeletion.find(psip);
909  if (it != m_cachedSlatedForDeletion.end())
910  m_cachedSlatedForDeletion.erase(it);
911 
912  return true;
913 }
914 
916 {
917  for (auto & tvct : tvcts)
918  ReturnCachedTable(tvct);
919  tvcts.clear();
920 }
921 
923 {
924  for (auto & cvct : cvcts)
925  ReturnCachedTable(cvct);
926  cvcts.clear();
927 }
928 
930 {
931  QMutexLocker locker(&m_listenerLock);
932 
933  for (auto & listener : m_atscMainListeners)
934  if (((void*)val) == ((void*)listener))
935  return;
936 
937  m_atscMainListeners.push_back(val);
938 }
939 
941 {
942  QMutexLocker locker(&m_listenerLock);
943 
944  for (auto it = m_atscMainListeners.begin(); it != m_atscMainListeners.end(); ++it)
945  {
946  if (((void*)val) == ((void*)*it))
947  {
948  m_atscMainListeners.erase(it);
949  return;
950  }
951  }
952 }
953 
955 {
956  QMutexLocker locker(&m_listenerLock);
957 
958  for (auto & listener : m_scteMainlisteners)
959  if (((void*)val) == ((void*)listener))
960  return;
961 
962  m_scteMainlisteners.push_back(val);
963 }
964 
966 {
967  QMutexLocker locker(&m_listenerLock);
968 
969  for (auto it = m_scteMainlisteners.begin(); it != m_scteMainlisteners.end(); ++it)
970  {
971  if (((void*)val) == ((void*)*it))
972  {
973  m_scteMainlisteners.erase(it);
974  return;
975  }
976  }
977 }
978 
980 {
981  QMutexLocker locker(&m_listenerLock);
982 
983  for (auto & listener : m_atscAuxListeners)
984  if (((void*)val) == ((void*)listener))
985  return;
986 
987  m_atscAuxListeners.push_back(val);
988 }
989 
991 {
992  QMutexLocker locker(&m_listenerLock);
993 
994  for (auto it = m_atscAuxListeners.begin(); it != m_atscAuxListeners.end(); ++it)
995  {
996  if (((void*)val) == ((void*)*it))
997  {
998  m_atscAuxListeners.erase(it);
999  return;
1000  }
1001  }
1002 }
1003 
1005 {
1006  QMutexLocker locker(&m_listenerLock);
1007 
1008  for (auto & listener : m_atscEitListeners)
1009  if (((void*)val) == ((void*)listener))
1010  return;
1011 
1012  m_atscEitListeners.push_back(val);
1013 }
1014 
1016 {
1017  QMutexLocker locker(&m_listenerLock);
1018 
1019  for (auto it = m_atscEitListeners.begin(); it != m_atscEitListeners.end(); ++it)
1020  {
1021  if (((void*)val) == ((void*)*it))
1022  {
1023  m_atscEitListeners.erase(it);
1024  return;
1025  }
1026  }
1027 }
1028 
1030 {
1031  QMutexLocker locker(&m_listenerLock);
1032 
1033  for (auto & listener : m_atsc81EitListeners)
1034  if (((void*)val) == ((void*)listener))
1035  return;
1036 
1037  m_atsc81EitListeners.push_back(val);
1038 }
1039 
1041 {
1042  QMutexLocker locker(&m_listenerLock);
1043 
1044  for (auto it = m_atsc81EitListeners.begin(); it != m_atsc81EitListeners.end(); ++it)
1045  {
1046  if (((void*)val) == ((void*)*it))
1047  {
1048  m_atsc81EitListeners.erase(it);
1049  return;
1050  }
1051  }
1052 }
MPEGStreamData::m_cachedRefCnt
psip_refcnt_map_t m_cachedRefCnt
Definition: mpegstreamdata.h:354
MasterGuideTable::TableClass
int TableClass(uint i) const
Definition: atsctables.cpp:25
VirtualChannelTable
This table contains information about the channels transmitted on this multiplex.
Definition: atsctables.h:189
TableID::TOT
@ TOT
Definition: mpegtables.h:275
ATSCStreamData::m_atscAuxListeners
atsc_aux_listener_vec_t m_atscAuxListeners
Definition: atscstreamdata.h:138
ExtendedTextTable::SourceID
uint SourceID(void) const
Definition: atsctables.h:656
ATSCStreamData::AddATSCAuxListener
void AddATSCAuxListener(ATSCAuxStreamListener *val)
Definition: atscstreamdata.cpp:979
TableID::TVCT
@ TVCT
Definition: mpegtables.h:339
ATSCStreamData::VersionTVCT
int VersionTVCT(uint tsid) const
Definition: atscstreamdata.h:172
TableID::CVCT
@ CVCT
Definition: mpegtables.h:340
TableID::STTscte
@ STTscte
Definition: mpegtables.h:320
ATSCMainStreamListener
Definition: streamlisteners.h:112
ATSCStreamData::ProcessVCT
void ProcessVCT(uint tsid, const VirtualChannelTable *vct)
Definition: atscstreamdata.cpp:561
ATSCStreamData::RemoveSCTEMainListener
void RemoveSCTEMainListener(SCTEMainStreamListener *val)
Definition: atscstreamdata.cpp:965
ATSCStreamData::~ATSCStreamData
~ATSCStreamData() override
Definition: atscstreamdata.cpp:45
ATSCStreamData::DeleteCachedTable
bool DeleteCachedTable(const PSIPTable *psip) const override
Definition: atscstreamdata.cpp:874
EITHelper::AddETT
void AddETT(uint atsc_major, uint atsc_minor, const ExtendedTextTable *ett)
Definition: eithelper.cpp:180
MPEGStreamData::SetDesiredProgram
void SetDesiredProgram(int p)
Definition: mpegstreamdata.cpp:67
NetworkTextTable
Definition: sctetables.h:254
DirectedChannelChangeTable
No one has had time to decode this table yet...
Definition: atsctables.h:755
ATSCStreamData::AddSCTEMainListener
void AddSCTEMainListener(SCTEMainStreamListener *val)
Definition: atscstreamdata.cpp:954
TableID::DCCSCT
@ DCCSCT
Definition: mpegtables.h:352
TableStatusMap::SetSectionSeen
void SetSectionSeen(uint32_t key, int32_t version, uint32_t section, uint32_t last_section, uint32_t segment_last_section=0xffff)
Definition: tablestatus.cpp:65
ATSCStreamData::HasCachedAllCVCTs
bool HasCachedAllCVCTs(bool current=true) const
Definition: atscstreamdata.cpp:711
MPEGStreamData::DeleteCachedTable
virtual bool DeleteCachedTable(const PSIPTable *psip) const
Definition: mpegstreamdata.cpp:1507
TableID::SDT
@ SDT
Definition: mpegtables.h:260
RatingRegionTable
No one has had time to decode this table yet...
Definition: atsctables.h:739
TableID::NITo
@ NITo
Definition: mpegtables.h:265
ATSCStreamData::HasCachedMGT
bool HasCachedMGT(bool current=true) const
Definition: atscstreamdata.cpp:615
ATSCStreamData::m_cvctVersion
QMap< uint, int > m_cvctVersion
Definition: atscstreamdata.h:145
ATSCStreamData::HasChannel
bool HasChannel(uint major, uint minor) const
Definition: atscstreamdata.cpp:624
TableID::EIT
@ EIT
Definition: mpegtables.h:342
ATSCStreamData::m_mgtVersion
int m_mgtVersion
Definition: atscstreamdata.h:143
ATSCStreamData::GetCachedCVCTs
cvct_vec_t GetCachedCVCTs(bool current=true) const
Definition: atscstreamdata.cpp:831
ATSCStreamData::m_tvctVersion
QMap< uint, int > m_tvctVersion
Definition: atscstreamdata.h:144
PESPacket::tsheader
const TSHeader * tsheader() const
Definition: pespacket.h:85
TSHeader::PID
unsigned int PID(void) const
Definition: tspacket.h:71
ATSCStreamData::m_sourceIdToAtscMajMin
QMap< uint, uint > m_sourceIdToAtscMajMin
Definition: atscstreamdata.h:132
ATSCStreamData::CacheCVCT
void CacheCVCT(uint pid, CableVirtualChannelTable *cvct)
Definition: atscstreamdata.cpp:866
MPEGStreamData::IsRedundant
virtual bool IsRedundant(uint pid, const PSIPTable &psip) const
Returns true if table already seen.
Definition: mpegstreamdata.cpp:639
ATSCStreamData::m_atscEttPids
atsc_ett_pid_map_t m_atscEttPids
Definition: atscstreamdata.h:130
arg
arg(title).arg(filename).arg(doDelete))
SCTESystemTimeTable
This table contains the GPS time at the time of transmission.
Definition: sctetables.h:564
MPEGStreamData::m_cacheLock
QMutex m_cacheLock
Definition: mpegstreamdata.h:350
atscstreamdata.h
VirtualChannelTable::SourceID
uint SourceID(uint i) const
Definition: atsctables.h:299
ATSCStreamData::ProcessTVCT
void ProcessTVCT(uint tsid, const TerrestrialVirtualChannelTable *vct)
Definition: atscstreamdata.cpp:597
TableID::PIM
@ PIM
Definition: mpegtables.h:299
ProgramNameMessageTable
Definition: sctetables.h:641
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
ATSCStreamData::HasCachedAnyCVCTs
bool HasCachedAnyCVCTs(bool current=true) const
Definition: atscstreamdata.cpp:752
DirectedChannelChangeSelectionCodeTable
No one has had time to decode this table yet...
Definition: atsctables.h:772
VirtualChannelTable::ProgramNumber
uint ProgramNumber(uint i) const
Definition: atsctables.h:266
ATSCStreamData::m_gpsUtcOffset
uint m_gpsUtcOffset
Definition: atscstreamdata.h:127
MasterGuideTable::TableCount
uint TableCount() const
Definition: atsctables.h:114
VirtualChannelTable::IsHiddenInGuide
bool IsHiddenInGuide(uint i) const
Definition: atsctables.h:287
MPEGStreamData::m_eitHelper
EITHelper * m_eitHelper
Definition: mpegstreamdata.h:315
TableID::NITscte
@ NITscte
Definition: mpegtables.h:317
ATSCStreamData::m_cachedMgt
MasterGuideTable * m_cachedMgt
Definition: atscstreamdata.h:150
ATSCStreamData::HandleTables
bool HandleTables(uint pid, const PSIPTable &psip) override
Process PSIP packets.
Definition: atscstreamdata.cpp:207
ATSCStreamData::AddATSCEITListener
void AddATSCEITListener(ATSCEITStreamListener *val)
Definition: atscstreamdata.cpp:1004
ATSCStreamData::HasCachedAllTVCTs
bool HasCachedAllTVCTs(bool current=true) const
Definition: atscstreamdata.cpp:680
PSIPTable::Section
uint Section(void) const
Definition: mpegtables.h:522
MythDate::current
QDateTime current(bool stripped)
Returns current Date and Time in UTC.
Definition: mythdate.cpp:10
MPEGStreamData::UpdateTimeOffset
void UpdateTimeOffset(uint64_t si_utc_time)
Definition: mpegstreamdata.cpp:833
VirtualChannelTable::IsHidden
bool IsHidden(uint i) const
Definition: atsctables.h:281
ATSCStreamData::ProcessMGT
void ProcessMGT(const MasterGuideTable *mgt)
Definition: atscstreamdata.cpp:532
TableID::RRT
@ RRT
Definition: mpegtables.h:341
ATSCStreamData::VersionRRT
int VersionRRT(uint region) const
Definition: atscstreamdata.h:188
ATSCStreamData::Reset
void Reset(void) override
Definition: atscstreamdata.h:36
sctetables.h
EITHelper::AddEIT
void AddEIT(uint atsc_major, uint atsc_minor, const EventInformationTable *eit)
Definition: eithelper.cpp:141
ATSCStreamData::SetVersionMGT
void SetVersionMGT(int version)
Definition: atscstreamdata.h:56
PSIPTable
A PSIP table is a variant of a PES packet containing an MPEG, ATSC or DVB table.
Definition: mpegtables.h:386
ATSCStreamData::GPSOffset
uint GPSOffset(void) const
Current UTC to GPS time offset in seconds.
Definition: atscstreamdata.h:46
ATSCStreamData::ReturnCachedTVCTTables
void ReturnCachedTVCTTables(tvct_vec_t &tvcts) const
Definition: atscstreamdata.cpp:915
TableClass::EIT
@ EIT
Definition: atsctables.h:63
VirtualChannelTable::MajorChannel
uint MajorChannel(uint i) const
Definition: atsctables.h:244
SystemTimeTable::GPSOffset
uint GPSOffset() const
Definition: atsctables.h:720
ATSCStreamData::m_atscEitPids
atsc_eit_pid_map_t m_atscEitPids
Definition: atscstreamdata.h:129
MPEGStreamData::ReturnCachedTable
virtual void ReturnCachedTable(const PSIPTable *psip) const
Definition: mpegstreamdata.cpp:1439
TableClass::ETTe
@ ETTe
Definition: atsctables.h:64
MPEGStreamData::m_listenerLock
QMutex m_listenerLock
Definition: mpegstreamdata.h:333
ATSCStreamData::m_atscEitListeners
atsc_eit_listener_vec_t m_atscEitListeners
Definition: atscstreamdata.h:139
SCTE_PSIP_PID
@ SCTE_PSIP_PID
Definition: mpegtables.h:227
minor
#define minor(X)
Definition: compat.h:138
ATSCStreamData::SetDesiredChannel
void SetDesiredChannel(int major, int minor)
Definition: atscstreamdata.cpp:58
ATSCStreamData::GetCachedTVCT
tvct_const_ptr_t GetCachedTVCT(uint pid, bool current=true) const
Definition: atscstreamdata.cpp:776
VirtualChannelTable::Find
int Find(int major, int minor) const
Definition: atsctables.cpp:485
MasterGuideTable::TablePID
uint TablePID(uint i) const
Definition: atsctables.h:128
ATSCStreamData::RemoveATSC81EITListener
void RemoveATSC81EITListener(ATSC81EITStreamListener *val)
Definition: atscstreamdata.cpp:1040
ATSC81EITStreamListener
Definition: streamlisteners.h:163
AggregateExtendedTextTable
SCTE 65 & ATSC/81 0xD7.
Definition: atsctables.h:809
ShortVirtualChannelTable
Definition: sctetables.h:495
ATSCStreamData::HasEITPIDChanges
bool HasEITPIDChanges(const uint_vec_t &in_use_pid) const override
Definition: atscstreamdata.cpp:481
ATSCStreamData::m_cachedCvcts
cvct_cache_t m_cachedCvcts
Definition: atscstreamdata.h:152
eithelper.h
MPEGStreamData::HandleTables
virtual bool HandleTables(uint pid, const PSIPTable &psip)
Process PSIP packets.
Definition: mpegstreamdata.cpp:666
ATSCAuxStreamListener
Definition: streamlisteners.h:122
ATSCStreamData::VersionMGT
int VersionMGT() const
Definition: atscstreamdata.h:65
ATSCStreamData::HasCachedCVCT
bool HasCachedCVCT(uint pid, bool current=true) const
Definition: atscstreamdata.cpp:666
MPEGStreamData
Encapsulates data about MPEG stream and emits events for each table.
Definition: mpegstreamdata.h:85
ATSCStreamData::HasCachedTVCT
bool HasCachedTVCT(uint pid, bool current=true) const
Definition: atscstreamdata.cpp:652
ATSCStreamData::m_cachedTvcts
tvct_cache_t m_cachedTvcts
Definition: atscstreamdata.h:151
ATSCStreamData::ReturnCachedCVCTTables
void ReturnCachedCVCTTables(cvct_vec_t &cvcts) const
Definition: atscstreamdata.cpp:922
ProgramInformationMessageTable
Definition: sctetables.h:621
ATSCStreamData::ATSCStreamData
ATSCStreamData(int desiredMajorChannel, int desiredMinorChannel, int cardnum, bool cacheTables=false)
Initializes ATSCStreamData.
Definition: atscstreamdata.cpp:34
ATSCStreamData::m_desiredMinorChannel
int m_desiredMinorChannel
Definition: atscstreamdata.h:156
EventInformationTable
EventInformationTables contain program titles, start times, and channel information.
Definition: atsctables.h:520
uint
unsigned int uint
Definition: compat.h:140
ATSCStreamData::AddATSCMainListener
void AddATSCMainListener(ATSCMainStreamListener *val)
Definition: atscstreamdata.cpp:929
TableID::ETT
@ ETT
Definition: mpegtables.h:343
ATSCStreamData::m_desiredMajorChannel
int m_desiredMajorChannel
Definition: atscstreamdata.h:155
AggregateDataEventTable
Definition: sctetables.h:661
ATSCStreamData::RemoveATSCAuxListener
void RemoveATSCAuxListener(ATSCAuxStreamListener *val)
Definition: atscstreamdata.cpp:990
PSIPTable::LastSection
uint LastSection(void) const
Definition: mpegtables.h:525
ATSCStreamData::SetVersionRRT
void SetVersionRRT(uint region, int version)
Definition: atscstreamdata.h:62
ATSCStreamData::GetCachedTVCTs
tvct_vec_t GetCachedTVCTs(bool current=true) const
Definition: atscstreamdata.cpp:810
ATSCStreamData::m_scteMainlisteners
scte_main_listener_vec_t m_scteMainlisteners
Definition: atscstreamdata.h:137
TableClass::TVCTc
@ TVCTc
Definition: atsctables.h:57
TableID::DVBCA_82
@ DVBCA_82
Definition: mpegtables.h:286
ATSCStreamData::CacheTVCT
void CacheTVCT(uint pid, TerrestrialVirtualChannelTable *tvct)
Definition: atscstreamdata.cpp:858
MPEGStreamData::IncrementRefCnt
void IncrementRefCnt(const PSIPTable *psip) const
Definition: mpegstreamdata.cpp:1501
EITHelper::GetGPSOffset
uint GetGPSOffset(void) const
Definition: eithelper.h:102
ATSCStreamData::RemoveATSCMainListener
void RemoveATSCMainListener(ATSCMainStreamListener *val)
Definition: atscstreamdata.cpp:940
MasterGuideTable
This table tells the decoder on which PIDs to find other tables, and their sizes and each table's cur...
Definition: atsctables.h:74
ATSCStreamData::CacheMGT
void CacheMGT(MasterGuideTable *mgt)
Definition: atscstreamdata.cpp:850
TableID::SVCTscte
@ SVCTscte
Definition: mpegtables.h:319
LOC
#define LOC
Definition: atscstreamdata.cpp:14
TableID::AEIT
@ AEIT
Definition: mpegtables.h:354
ATSC_PSIP_PID
@ ATSC_PSIP_PID
Definition: mpegtables.h:225
TableID::SDTo
@ SDTo
Definition: mpegtables.h:266
AggregateEventInformationTable
SCTE 65 & ATSC/81 0xD6.
Definition: atsctables.h:789
SCTEMainStreamListener
Definition: streamlisteners.h:144
ATSCStreamData::AddATSC81EITListener
void AddATSC81EITListener(ATSC81EITStreamListener *val)
Definition: atscstreamdata.cpp:1029
TableID::STT
@ STT
Definition: mpegtables.h:344
TableID::DCCT
@ DCCT
Definition: mpegtables.h:351
TableID::AETT
@ AETT
Definition: mpegtables.h:355
ExtendedTextTable::IsEventETM
bool IsEventETM(void) const
Definition: atsctables.h:655
PSIPTable::TableID
uint TableID(void) const
Definition: mpegtables.h:489
ATSCStreamData::IsRedundant
bool IsRedundant(uint pid, const PSIPTable &psip) const override
Returns true if table already seen.
Definition: atscstreamdata.cpp:159
PSIPTable::TableIDExtension
uint TableIDExtension(void) const
Definition: mpegtables.h:506
EITHelper::SetGPSOffset
void SetGPSOffset(uint _gps_offset)
Definition: eithelper.h:105
TerrestrialVirtualChannelTable
This table contains information about the terrestrial channels transmitted on this multiplex.
Definition: atsctables.h:345
TableID::ADET
@ ADET
Definition: mpegtables.h:325
uint_vec_t
vector< uint > uint_vec_t
Definition: mpegstreamdata.h:24
cvct_vec_t
vector< const CableVirtualChannelTable * > cvct_vec_t
Definition: atscstreamdata.h:16
MPEGStreamData::Reset
virtual void Reset(void)
Definition: mpegstreamdata.h:94
TableID::PNM
@ PNM
Definition: mpegtables.h:300
MPEGStreamData::m_cachedSlatedForDeletion
psip_refcnt_map_t m_cachedSlatedForDeletion
Definition: mpegstreamdata.h:355
ATSCStreamData::m_atsc81EitListeners
atsc81_eit_listener_vec_t m_atsc81EitListeners
Definition: atscstreamdata.h:140
ATSCStreamData::GetATSCMajorMinor
uint GetATSCMajorMinor(uint eit_sourceid) const
Definition: atscstreamdata.h:160
atsctables.h
CableVirtualChannelTable
This table contains information about the cable channels transmitted on this multiplex.
Definition: atsctables.h:414
MPEGStreamData::m_cacheTables
bool m_cacheTables
Definition: mpegstreamdata.h:349
ATSCEITStreamListener
Definition: streamlisteners.h:135
tvct_vec_t
vector< const TerrestrialVirtualChannelTable * > tvct_vec_t
Definition: atscstreamdata.h:15
SystemTimeTable
This table contains the GPS time at the time of transmission.
Definition: atsctables.h:678
MPEGStreamData::AddListeningPID
virtual void AddListeningPID(uint pid, PIDPriority priority=kPIDPriorityNormal)
Definition: mpegstreamdata.h:120
ExtendedTextTable
ExtendedTextTable contain additional text not contained in EventInformationTables.
Definition: atsctables.h:620
SCTENetworkInformationTable
Definition: sctetables.h:190
ATSCStreamData::VersionCVCT
int VersionCVCT(uint tsid) const
Definition: atscstreamdata.h:180
ATSCStreamData::RemoveATSCEITListener
void RemoveATSCEITListener(ATSCEITStreamListener *val)
Definition: atscstreamdata.cpp:1015
ATSCStreamData::SetVersionCVCT
void SetVersionCVCT(uint tsid, int version)
Definition: atscstreamdata.h:60
TableStatusMap::IsSectionSeen
bool IsSectionSeen(uint32_t key, int32_t version, uint32_t section) const
Definition: tablestatus.cpp:73
ATSCStreamData::ProcessCVCT
void ProcessCVCT(uint tsid, const CableVirtualChannelTable *vct)
Definition: atscstreamdata.cpp:606
SystemTimeTable::UTCUnix
time_t UTCUnix(void) const
Definition: atsctables.h:716
ATSCStreamData::m_atscMainListeners
atsc_main_listener_vec_t m_atscMainListeners
Definition: atscstreamdata.h:136
round
#define round(x)
Definition: mythplayer.cpp:64
TableID::TDT
@ TDT
Definition: mpegtables.h:262
MPEGStreamData::m_eitRate
float m_eitRate
Definition: mpegstreamdata.h:316
TableID::BAT
@ BAT
Definition: mpegtables.h:267
VirtualChannelTable::ModulationMode
uint ModulationMode(uint i) const
Definition: atsctables.h:254
MasterGuideTable::TableType
uint TableType(uint i) const
Definition: atsctables.h:120
ATSCStreamData::m_atscEitReset
bool m_atscEitReset
Definition: atscstreamdata.h:128
VirtualChannelTable::ChannelCount
uint ChannelCount() const
Definition: atsctables.h:221
ATSCStreamData::HasCachedAnyTVCTs
bool HasCachedAnyTVCTs(bool current=true) const
Definition: atscstreamdata.cpp:742
VirtualChannelTable::TransportStreamID
uint TransportStreamID() const
Definition: atsctables.h:218
TableID::NTT
@ NTT
Definition: mpegtables.h:318
nv_python_libs.bbciplayer.bbciplayer_api.version
string version
Definition: bbciplayer_api.py:81
TableID::MGT
@ MGT
Definition: mpegtables.h:338
MPEGStreamData::HasProgram
bool HasProgram(uint progNum) const
Definition: mpegstreamdata.cpp:1173
ATSCStreamData::GetCachedMGT
const MasterGuideTable * GetCachedMGT(bool current=true) const
Definition: atscstreamdata.cpp:762
PSIPTable::Version
uint Version(void) const
Definition: mpegtables.h:513
VirtualChannelTable::MinorChannel
uint MinorChannel(uint i) const
Definition: atsctables.h:249
find
static pid_list_t::iterator find(const PIDInfoMap &map, pid_list_t &list, pid_list_t::iterator begin, pid_list_t::iterator end, bool find_open)
Definition: dvbstreamhandler.cpp:356
EventInformationTable::SourceID
uint SourceID() const
Definition: atsctables.h:549
ATSCStreamData::GetCachedCVCT
cvct_const_ptr_t GetCachedCVCT(uint pid, bool current=true) const
Definition: atscstreamdata.cpp:793
ATSCStreamData::m_eitStatus
TableStatusMap m_eitStatus
Definition: atscstreamdata.h:147
TableID::NIT
@ NIT
Definition: mpegtables.h:259
TableID::DVBCA_83
@ DVBCA_83
Definition: mpegtables.h:287
TableClass::CVCTc
@ CVCTc
Definition: atsctables.h:59
ATSCStreamData::GetEITPIDChanges
bool GetEITPIDChanges(const uint_vec_t &cur_pids, uint_vec_t &add_pids, uint_vec_t &del_pids) const override
Definition: atscstreamdata.cpp:489
ATSCStreamData::SetVersionTVCT
void SetVersionTVCT(uint tsid, int version)
Definition: atscstreamdata.h:58