MythTV master
sctetables.h
Go to the documentation of this file.
1// -*- Mode: c++ -*-
22#ifndef SCTE_TABLES_H
23#define SCTE_TABLES_H
24
25#include <cassert>
26#include <cstdint>
27#include <ctime>
28
29using uint = unsigned int;
30
31#include <QDateTime>
32#include <QString>
33
34// MythTV
35#include "libmythbase/iso639.h"
36#include "libmythtv/mythtvexp.h"
37
38#include "mpegtables.h"
39
40// NOTE: MasterGuideTable defined in atsctables.h
41// NOTE: VirtualChannelTable defined in atsctables.h
42
43// NOTE: Section 4.4.1 specifies that we should not attempt to
44// use tables carrying a protocol_version greater than
45// the one we are familiar with, as of the SCTE65-2002
46// standard 0 is the only recognized version.
47
49{
50 public:
52 const unsigned char *beg, const unsigned char *end) :
53 m_beg(beg), m_end(end) { }
54
55 // number_of_carriers 8 0.0+m_beg
56 uint NumberOfCarriers(void) const { return m_beg[0]; }
57 // spacing_unit 1 1.0+m_beg
58 enum : std::uint8_t // Table 5.4 Spacing Unit & Table 5.5 frequency unit
59 {
60 k10000Hz = 0x0,
61 k125000Hz = 0x1,
62 };
63 uint SpacingUnit(void) const { return m_beg[1]>>7; }
64 uint SpacingUnitHz(void) const { return SpacingUnit() ? 125000 : 1000; }
65 // zero 1 1.1+m_beg
66 // frequency_spacing 14 1.2+m_beg
68 { return ((m_beg[1] & 0x3) << 8) | m_beg[2]; }
70 { return FrequencySpacing() * SpacingUnitHz(); }
71 // frequency_unit 1 3.0+m_beg
72 uint FrequencyUnit(void) const { return m_beg[3]>>7; }
73 uint FrequencyUnitHz(void) const { return FrequencyUnit() ? 125000 : 1000; }
74 // first_carrier_frequency 15 3.1+m_beg
76 { return ((m_beg[3] & 0x3) << 8) | m_beg[4]; }
77 uint64_t FirstCarrierFrequencyHz(void) const
78 { return (uint64_t)FirstCarrierFrequency() * FrequencyUnitHz(); }
79
80 // descriptors_count 8 5.0+m_beg
81 uint DescriptorsCount(void) const { return m_beg[5]; }
82 // for (i=0; i<descriptors_count; i++) {
83 // descriptor() ? ?.0
84 // }
85 uint DescriptorsLength(void) const { return m_end - m_beg - 6; }
86 const unsigned char *Descriptors(void) const { return m_beg + 6; }
87
88 QString toString(void) const;
89 QString toStringXML(uint indent_level) const;
90
91 private:
92 const unsigned char *m_beg;
93 const unsigned char *m_end;
94};
95
97{
98 public:
99 ModulationModeSubtable(const unsigned char *beg, const unsigned char *end) :
100 m_beg(beg), m_end(end) { }
101 // transmission_system 4 0.0+m_beg
102 enum : std::uint8_t // Table 5.7 TransmissionSystem
103 {
110 // all other values are reserved
111 // ITU Rec. J.83 Annex A is the 8Mhz global standard,
112 // Annex B is the 6Mhz North American standard and
113 // Annex C is the 6Mhz Japanese standard. (QAM)
114 };
115 uint TransmissionSystem(void) const { return m_beg[0] >> 4; }
116 QString TransmissionSystemString(void) const;
117 // inner_coding_mode 4 0.4+m_beg
118 enum : std::uint8_t // Table 5.8
119 {
122 // reserved = 2,
124 // reserved = 4,
126 // reserved = 6,
130 // reserved = 10,
132 // reserved = 12,
133 // reserved = 13,
134 // reserved = 14,
135 kNone = 15,
136 // all other values are reserved
137 };
138 uint InnerCodingMode(void) const { return m_beg[0] & 0xf; }
139 QString InnerCodingModeString(void) const;
140 // split_bitstream_mode 1 1.0+m_beg
141 bool SplitBitstreamMode(void) const { return ( m_beg[1] & 0x80 ) != 0; }
142 // zero 2 1.1+m_beg
143 // modulation_format 5 1.3+m_beg
144 enum : std::uint8_t // Table 5.9
145 {
147 kQPSK = 1,
148 kBPSK = 2,
150 kVSB8 = 4,
155 kQAM80 = 9, // last modulation format that 65 & 57 agree on
156 kQAM96 = 10,
171 // all other values are reserved
172 };
173 uint ModulationFormat(void) const { return m_beg[1] & 0x1f; }
174 QString ModulationFormatString(void) const;
175 // zero 4 2.0+m_beg
176 // symbol_rate 28 2.4+m_beg
177 uint SymbolRate(void) const
178 {
179 return (((m_beg[2]&0xf)<<24) | (m_beg[3]<<16) |
180 (m_beg[4]<<8) | (m_beg[5]));
181 }
182 // descriptors_count 8 6.0+m_beg
183 uint DescriptorsCount(void) const { return m_beg[6]; }
184 // for (i=0; i<descriptors_count; i++) {
185 // descriptor() ? ?.0
186 // }
187 uint DescriptorsLength(void) const { return m_end - m_beg - 7; }
188 const unsigned char *Descriptors(void) const { return m_beg + 7; }
189
190 static QString toString(void);
191 QString toStringXML(uint indent_level) const;
192
193 private:
194 const unsigned char *m_beg;
195 const unsigned char *m_end;
196};
197
199{
200 public:
202 PSIPTable(table)
203 {
205 Parse();
206 }
207 explicit SCTENetworkInformationTable(const PSIPTable &table) : PSIPTable(table)
208 {
210 Parse();
211 }
213 // SCTE65-2002, page 15, Table 5.1
214 // Name bits loc expected value
215 // table_id 8 0.0 0xC2
216 // zero 2 1.0 0
217 // reserved 2 1.2 3
218 // section_length 12 1.4
219 // ^^^ All above this line provided by PSIPTable
220 // zero 3 3.0 0
221 // protocol_version 5 3.3 0
222 // first_index 8 4.0 (value of 0 is illegal)
223 uint FirstIndex(void) const { return pesdata()[4]; }
224 // number_of_records 8 5.0
225 uint NumberOfRecords(void) const { return pesdata()[5]; }
226 // transmission_medium 4 6.0 0
227 uint TransmissionMedium(void) const { return pesdata()[6] >> 4; }
228 // table_subtype 4 6.4
229 enum : std::uint8_t // Table 5.2 NIT Subtype
230 {
231 kInvalid = 0x0,
232 kCarrierDefinitionSubtable = 0x1,
233 kModulationModeSubtable = 0x2,
234 // all other values are reserved
235 };
236 uint TableSubtype(void) const { return pesdata()[6] & 0xf; }
237 // for (i = 0; i < number_of_records; i++) {
238 // if (kCarrierDefinitionSubtable == table_subtype) {
240 { return {m_ptrs[i], m_ptrs[i+1]}; }
241 // if (kModulationModeSubtable == table_subtype) {
243 { return {m_ptrs[i], m_ptrs[i+1]}; }
244
245 // }
246 // for (i=0; i<N; i++)
247 // descriptor() ? ?.0 optional (determined by looking
248 // at section_length)
250 { return SectionLength() - (m_ptrs.back() - pesdata()) - 4/*CRC*/; }
251 const unsigned char * Descriptors(void) const { return m_ptrs.back(); }
252 // CRC_32 32
253
254 bool Parse(void);
255 QString toString(void) const override; // PSIPTable
256 QString toStringXML(uint indent_level) const override; // PSIPTable
257
258 private:
259 std::vector<const unsigned char*> m_ptrs;
260};
261
263{
264 public:
266 PSIPTable(table)
267 {
269 Parse();
270 }
271 explicit NetworkTextTable(const PSIPTable &table) : PSIPTable(table)
272 {
274 Parse();
275 }
276 ~NetworkTextTable() override { ; }
277 // SCTE65-2002, page 20, Table 5.10
278 // Name bits loc expected value
279 // table_id 8 0.0 0xC3
280 // zero 2 1.0 0
281 // reserved 2 1.2 3
282 // section_length 12 1.4
283 // ^^^ All above this line provided by PSIPTable
284 // zero 3 3.0 0
285 // protocol_version 5 3.3 0
286 // iso_639_language_code 24 4.0 see ISO 639.2/B
287 // * the value 0xFFFFFFFF shall match any language when text
288 // is only available in one language
289 int LanguageKey(void) const
290 { return iso639_str3_to_key(pesdata() + 4); }
291 QString LanguageString(void) const
292 { return iso639_key_to_str3(LanguageKey()); }
293 int CanonicalLanguageKey(void) const
294 { return iso639_key_to_canonical_key(LanguageKey()); }
295 QString CanonicalLanguageString(void) const
296 { return iso639_key_to_str3(CanonicalLanguageKey()); }
297 // transmission_medium 4 7.0 0
298 uint TransmissionMedium(void) const { return pesdata()[7] >> 4; }
299 // table_subtype 4 7.4 see Table 5.11
300 enum : std::uint8_t
301 {
302 kInvalid = 0x0,
303 kSourceNameSubtable = 0x6,
304 // all other values are reserved
305 };
306 uint TableSubtype(void) const { return pesdata()[7] & 0xf; }
307 // if (kSourceNameSubtable == table_subtype) {
308 // number_of_SNS_records 8 8.0
309 // for (i=0; i<number_of_SNS_records; i++) {
310 // application_type 1 0.0+_ptrs[i]
311 // zero 7 0.1+_ptrs[i] 0
312 // if (application_type)
313 // application_id 16 1.0+_ptrs[i]
314 // else
315 // source_id 16 1.0+_ptrs[i]
316 // name_length 8 3.0+_ptrs[i]
317 // source_name() name_length*8 4.0+_ptrs[i]
318 // sns_descriptors_count 8 4.0+ptrs[i]+name_length
319 // for (i = 0; i < sns_descriptors_count; i++)
320 // descriptor ? ?.0
321 // }
322 // }
323 // for (i=0; i<N; i++)
324 // descriptor() ? ?.0 optional (determined by looking
325 // at section_length)
326 // CRC_32 32
327
328 void Parse(void) const;
329 QString toString(void) const override; // PSIPTable
330 QString toStringXML(uint indent_level) const override; // PSIPTable
331};
332
334{
335 public:
336 explicit DefinedChannelsMapSubtable(const unsigned char *data) : m_data(data) {}
337 // zero 4 7.0 0
338 // first_virtual_channel 12 7.4
340 { return ((m_data[7]<<8) | m_data[8]) & 0xfff; }
341 // zero 1 9.0
342 // DCM_data_length 7 9.1
343 uint DCMDataLength(void) const { return m_data[9] & 0x7f; }
344 // for (i=0; i<DCM_data_length; i++) {
345 // range_defined 1 10.0+i
346 bool RangeDefined(uint i) const { return ( m_data[10+i] & 0x80 ) != 0; }
347 // channels_count 7 10.1+i
348 uint ChannelsCount(uint i) const { return m_data[10+i] & 0x7f; }
349 // }
350
351 QString toStringXML(uint indent_level) const;
352 uint Size(void) const { return DCMDataLength() + 3; }
353
354 private:
355 const unsigned char *m_data;
356};
357
359{
360 public:
362 const unsigned char *data, const std::vector<const unsigned char*> &ptrs) :
363 m_data(data), _ptrs(ptrs) {}
364
365 // zero 2 7.0
366 // descriptors_included 1 7.2
367 bool DescriptorsIncluded(void) const { return ( m_data[7] & 0x20 ) != 0; }
368 // zero 5 7.3
369 // splice 1 8.0
370 bool Splice(void) const { return ( m_data[8] & 0x80 ) != 0; }
371 // zero 7 8.1
372 // activation_time 32 9.0
374 {
375 return ((m_data[9] << 24) | (m_data[10] << 24) |
376 (m_data[11] << 24) | m_data[12]);
377 }
381 QDateTime ActivationTimeUTC(uint offset = 0) const
382 {
383 QDateTime dt;
384 dt.setSecsSinceEpoch(GPS_EPOCH + offset + ActivationTimeRaw());
385 return dt;
386 }
387 // number_of_VC_records 8 13.0
388 uint NumberOfVCRecords(void) const { return m_data[13]; }
389
390 // for (i = 0; i < number_of_VC_records; i++) {
391 // zero 4 0.0+_ptrs[i]
392 // virtual_channel_number 12 0.4+_ptrs[i]
394 { return ((_ptrs[i][0]<<8) | _ptrs[i][1]) & 0xfff; }
395 // application_virtual_channel 1 2.0+_ptrs[i]
396 bool ApplicationVirtualChannel(uint i) const { return ( _ptrs[i][1] & 0x80 ) != 0; }
397 // zero 1 2.1+_ptrs[i]
398 // path_select 1 2.2+_ptrs[i]
399 enum : std::uint8_t // Table 5.18 path select
400 {
401 kPath1 = 0x0,
402 kPath2 = 0x1,
403 };
404 uint PathSelect(uint i) const { return (_ptrs[i][2]>>5) & 0x1; }
405 QString PathSelectString(uint i) const
406 { return PathSelect(i) ? "Path 2" : "Path 1"; }
407 // transport_type 1 2.3+_ptrs[i]
408 enum : std::uint8_t // Table 5.19 transport type
409 {
412 };
413 uint TransportType(uint i) const { return (_ptrs[i][2]>>4) & 0x1; }
414 QString TransportTypeString(uint i) const
415 { return TransportType(i) ? "Non-MPEG-2" : "MPEG-2"; }
416 // channel_type 4 2.4+_ptrs[i]
417 enum : std::uint8_t // Table 5.20 channel type
418 {
421 // all other values are reserved
422 };
423 uint ChannelType(uint i) const { return _ptrs[i][2] & 0xf; }
424 QString ChannelTypeString(uint i) const
425 { return ChannelType(i) ? "Hidden" : "Normal"; }
426 // if (application_virtual_channel) {
427 // application_id 16 3.0+_ptrs[i]
428 uint ApplicationID(uint i) const { return (_ptrs[i][3]<<8) | _ptrs[i][4]; }
429 // } else {
430 // source_id 16 3.0+_ptrs[i]
431 uint SourceID(uint i) const { return (_ptrs[i][3]<<8) | _ptrs[i][4]; }
432 // }
433 // if (transport_type==MPEG_2) {
434 // CDS_reference 8 5.0+_ptrs[i]
435 uint CDSReference(uint i) const { return _ptrs[i][5]; }
436 // program_number 16 6.0+_ptrs[i]
437 uint ProgramNumber(uint i) const { return (_ptrs[i][6]<<8) | _ptrs[i][7]; }
438 // MMS_reference 8 8.0+_ptrs[i]
439 uint MMSReference(uint i) const { return _ptrs[i][8]; }
440 // } else {
441 // CDS_reference 8 5.0+_ptrs[i]
442 // scrambled 1 6.0+_ptrs[i]
443 bool Scrambled(uint i) const { return ( _ptrs[i][6] & 0x80 ) != 0; }
444 // zero 3 6.1+_ptrs[i]
445 // video_standard 4 6.4+_ptrs[i]
446 enum : std::uint8_t // Table 5.21 video standard
447 {
448 kNTSC = 0x0,
449 kPAL625 = 0x1,
450 kPAL525 = 0x2,
451 kSECAM = 0x3,
452 kMAC = 0x4,
453 // all other values are reserved
454 };
455 uint VideoStandard(uint i) const { return _ptrs[i][6] & 0xf; }
456 QString VideoStandardString(uint i) const;
457 // zero 16 7.0+_ptrs[i] 0
458 // }
459 // if (descriptors_included) {
460 // descriptors_count 8 9.0+_ptrs[i]
461 uint DescriptorsCount(uint i) const { return _ptrs[i][9]; }
462 // for (i = 0; i < descriptors_count; i++)
463 // descriptor()
464 uint DescriptorsLength(uint i) const { return _ptrs[i+1] - _ptrs[i] - 10; }
465 const unsigned char *Descriptors(uint i) const { return _ptrs[i] + 10; }
466 // }
467 // }
468
469 QString toStringXML(uint indent_level) const;
470 uint Size(void) const { return _ptrs.back() - m_data; }
471
472 const unsigned char *m_data;
473 const std::vector<const unsigned char*> &_ptrs;
474};
475
477{
478 public:
479 explicit InverseChannelMapSubtable(const unsigned char *data) : m_data(data) {}
480 // zero 4 7.0
481 // first_map_index 12 7.4
482 uint FirstMapIndex(void) const { return ((m_data[7]<<8)|m_data[8]) & 0xfff; }
483 // zero 1 9.0
484 // record_count 7 9.1
485 uint RecordCount(void) const { return m_data[9] & 0x7f; }
486 // for (i=0; i<record_count; i++) {
487 // source_id 16 10.0+i*4
488 uint SourceID(uint i) const { return (m_data[10+(i*4)]<<8) | m_data[11+(i*4)]; }
489 // zero 4 12.0+i*4
490 // virtual_channel_number 12 12.4+i*4
492 { return ((m_data[12+(i*4)]<<8) | m_data[13+(i*4)]) & 0xfff; }
493 // }
494
495 QString toStringXML(uint indent_level) const;
496 uint Size(void) const { return (RecordCount() * 4) + 3; }
497
498 private:
499 const unsigned char *m_data;
500};
501
502// AKA Short-form Virtual Channel Table
504{
505 public:
507 PSIPTable(table)
508 {
510 Parse();
511 }
512 explicit ShortVirtualChannelTable(const PSIPTable &table) : PSIPTable(table)
513 {
515 Parse();
516 }
518 // Name bits loc expected value
519 // table_id 8 0.0 0xC4
520 // zero 2 1.0 0
521 // reserved 2 1.2 3
522 // section_length 12 1.4
523 // ^^^ All above this line provided by PSIPTable
524 // zero 3 3.0 0
525 // protocol_version 5 3.3 0
526 // transmission_medium 4 4.0 0
527 uint TransmissionMedium(void) const { return pesdata()[4] >> 4; }
528 // table_subtype 4 4.4
529 enum : std::uint8_t // Table 5.14 Table Subtype
530 {
531 kVirtualChannelMap = 0x0,
532 kDefinedChannelsMap = 0x1,
533 kInverseChannelMap = 0x2,
534 // all other values are reserved
535 };
536 uint TableSubtype(void) const { return pesdata()[4] & 0xf; }
537 QString TableSubtypeString(void) const;
538 // vct_id 16 5.0
539 uint ID(void) const { return (pesdata()[5]<<8) | pesdata()[6]; }
540 // if (table_subtype==kDefinedChannelsMap) {
542 { return DefinedChannelsMapSubtable(pesdata()); }
543 // }
544 // if (table_subtype==kVirtualChannelMap) {
546 { return { pesdata(), m_ptrs}; }
547 // }
548 // if (table_subtype==kInverseChannelMap) {
550 { return InverseChannelMapSubtable(pesdata()); }
551 // }
552 // for (i=0; i<N; i++)
553 // descriptor() ? ?.0 optional (determined by looking
554 // at section_length)
556 { return SectionLength() - (m_ptrs.back() - pesdata()) - 4/*CRC*/; }
557 const unsigned char * Descriptors(void) const { return m_ptrs.back(); }
558 // }
559 // CRC_32 32
560
561 bool Parse(void);
562 QString toString(void) const override; // PSIPTable
563 QString toStringXML(uint indent_level) const override; // PSIPTable
564
565 private:
566 std::vector<const unsigned char*> m_ptrs;
567};
568
573{
574 public:
576 {
578 }
579 explicit SCTESystemTimeTable(const PSIPTable &table) : PSIPTable(table)
580 {
582 }
583
584 // Name bits loc expected value
585 // table_id 8 0.0 0xC5
586 // zero 2 1.0 0
587 // reserved 2 1.2 3
588 // section_length 12 1.4
589 // ^^^ All above this line provided by PSIPTable
590 // zero 3 3.0 0
591 // protocol_version 5 3.3 0
592 // zero 8 4.0 0
593 // system_time 32 5.0
594 uint32_t SystemTimeRaw(void) const
595 {
596 return ((pesdata()[5] <<24) | (pesdata()[6]<<16) |
597 (pesdata()[7]<< 8) | pesdata()[8]);
598 }
599 QDateTime SystemTimeGPS(void) const
600 {
601 QDateTime dt;
602 dt.setSecsSinceEpoch(GPSUnix());
603 return dt;
604 }
605 QDateTime SystemTimeUTC(void) const
606 {
607 QDateTime dt;
608 dt.setSecsSinceEpoch(UTCUnix());
609 return dt;
610 }
611 time_t GPSUnix(void) const
612 { return GPS_EPOCH + SystemTimeRaw(); }
613 time_t UTCUnix(void) const
614 { return GPSUnix() - GPSUTCOffset(); }
615 // GPS_UTC_offset 8 9.0 (leap seconds since 1980)
616 uint GPSUTCOffset(void) const { return pesdata()[9]; }
617 // for (I = 0;I< N;I++) { descriptor() }
619 { return SectionLength() - 10/*bytes before desc*/ - 4/*CRC*/; }
620 const unsigned char * Descriptors(void) const { return pesdata() + 10; }
621
622 // CRC_32 32
623
624 QString toString(void) const override; // PSIPTable
625 QString toStringXML(uint indent_level) const override; // PSIPTable
626};
627
628// PIM = 0xC0 -- Program Information Message (57 2003) PMT PID
630{
631 public:
633 const ProgramInformationMessageTable &table) : PSIPTable(table)
634 {
636 }
637 explicit ProgramInformationMessageTable(const PSIPTable &table) : PSIPTable(table)
638 {
640 }
641
642 QString toString(void) const override // PSIPTable
643 { return "Program Information Message\n"; }
644 QString toStringXML(uint /*indent_level*/) const override // PSIPTable
645 { return "<ProgramInformationMessage />"; }
646};
647
648// PNM = 0xC1 -- Program Name Message (57 2003) PMT PID
650{
651 public:
653 const ProgramNameMessageTable &table) : PSIPTable(table)
654 {
656 }
657 explicit ProgramNameMessageTable(const PSIPTable &table) : PSIPTable(table)
658 {
660 }
661
662 QString toString(void) const override // PSIPTable
663 { return "Program Name Message\n"; }
664 QString toStringXML(uint /*indent_level*/) const override // PSIPTable
665 { return "<ProgramNameMessage />"; }
666};
667
668// ADET = 0xD9 -- Aggregate Data Event Table (80 2002)
670{
671 public:
673 const AggregateDataEventTable &table) : PSIPTable(table)
674 {
676 }
677 explicit AggregateDataEventTable(const PSIPTable &table) : PSIPTable(table)
678 {
680 }
681
682 QString toString(void) const override; // PSIPTable
683 QString toStringXML(uint indent_level) const override; // PSIPTable
684};
685
686
687#endif // SCTE_TABLES_H
#define assert(x)
AggregateDataEventTable(const AggregateDataEventTable &table)
Definition: sctetables.h:672
AggregateDataEventTable(const PSIPTable &table)
Definition: sctetables.h:677
uint FrequencySpacing(void) const
Definition: sctetables.h:67
uint DescriptorsCount(void) const
Definition: sctetables.h:81
const unsigned char * Descriptors(void) const
Definition: sctetables.h:86
uint SpacingUnitHz(void) const
Definition: sctetables.h:64
uint DescriptorsLength(void) const
Definition: sctetables.h:85
uint FrequencySpacingHz(void) const
Definition: sctetables.h:69
uint64_t FirstCarrierFrequencyHz(void) const
Definition: sctetables.h:77
const unsigned char * m_end
Definition: sctetables.h:93
uint NumberOfCarriers(void) const
Definition: sctetables.h:56
const unsigned char * m_beg
Definition: sctetables.h:92
uint FrequencyUnitHz(void) const
Definition: sctetables.h:73
uint SpacingUnit(void) const
Definition: sctetables.h:63
uint FirstCarrierFrequency(void) const
Definition: sctetables.h:75
uint FrequencyUnit(void) const
Definition: sctetables.h:72
CarrierDefinitionSubtable(const unsigned char *beg, const unsigned char *end)
Definition: sctetables.h:51
uint FirstVirtualChannel(void) const
Definition: sctetables.h:339
const unsigned char * m_data
Definition: sctetables.h:355
uint Size(void) const
Definition: sctetables.h:352
DefinedChannelsMapSubtable(const unsigned char *data)
Definition: sctetables.h:336
bool RangeDefined(uint i) const
Definition: sctetables.h:346
uint ChannelsCount(uint i) const
Definition: sctetables.h:348
uint DCMDataLength(void) const
Definition: sctetables.h:343
uint Size(void) const
Definition: sctetables.h:496
uint SourceID(uint i) const
Definition: sctetables.h:488
uint RecordCount(void) const
Definition: sctetables.h:485
uint FirstMapIndex(void) const
Definition: sctetables.h:482
uint VirtualChannelNumber(uint i) const
Definition: sctetables.h:491
const unsigned char * m_data
Definition: sctetables.h:499
InverseChannelMapSubtable(const unsigned char *data)
Definition: sctetables.h:479
uint TransmissionSystem(void) const
Definition: sctetables.h:115
ModulationModeSubtable(const unsigned char *beg, const unsigned char *end)
Definition: sctetables.h:99
uint InnerCodingMode(void) const
Definition: sctetables.h:138
uint DescriptorsCount(void) const
Definition: sctetables.h:183
static QString toString(void)
Definition: sctetables.cpp:129
@ kTSITUAnnexB
Specified in Annex B of ITU Rec. J.83.
Definition: sctetables.h:106
@ kTSITUQPSK
ITU-R Rec. BO.1211:1995 (QPSK)
Definition: sctetables.h:107
@ kTSDigiCipher
from SCTE 57 – DigiCipher II
Definition: sctetables.h:109
@ kTSITUAnnexA
Specified in Annex A of ITU Rec. J.83.
Definition: sctetables.h:105
QString InnerCodingModeString(void) const
Definition: sctetables.cpp:79
const unsigned char * m_beg
Definition: sctetables.h:194
const unsigned char * Descriptors(void) const
Definition: sctetables.h:188
uint ModulationFormat(void) const
Definition: sctetables.h:173
uint DescriptorsLength(void) const
Definition: sctetables.h:187
uint SymbolRate(void) const
Definition: sctetables.h:177
bool SplitBitstreamMode(void) const
Definition: sctetables.h:141
QString ModulationFormatString(void) const
Definition: sctetables.cpp:96
QString TransmissionSystemString(void) const
Definition: sctetables.cpp:65
QString toStringXML(uint indent_level) const
Definition: sctetables.cpp:134
const unsigned char * m_end
Definition: sctetables.h:195
NetworkTextTable(const NetworkTextTable &table)
Definition: sctetables.h:265
int CanonicalLanguageKey(void) const
Definition: sctetables.h:293
QString LanguageString(void) const
Definition: sctetables.h:291
uint TableSubtype(void) const
Definition: sctetables.h:306
int LanguageKey(void) const
Definition: sctetables.h:289
QString CanonicalLanguageString(void) const
Definition: sctetables.h:295
~NetworkTextTable() override
Definition: sctetables.h:276
NetworkTextTable(const PSIPTable &table)
Definition: sctetables.h:271
uint TransmissionMedium(void) const
Definition: sctetables.h:298
A PSIP table is a variant of a PES packet containing an MPEG, ATSC or DVB table.
Definition: mpegtables.h:410
QString toStringXML(uint) const override
Definition: sctetables.h:644
ProgramInformationMessageTable(const PSIPTable &table)
Definition: sctetables.h:637
QString toString(void) const override
Definition: sctetables.h:642
ProgramInformationMessageTable(const ProgramInformationMessageTable &table)
Definition: sctetables.h:632
QString toStringXML(uint) const override
Definition: sctetables.h:664
QString toString(void) const override
Definition: sctetables.h:662
ProgramNameMessageTable(const PSIPTable &table)
Definition: sctetables.h:657
ProgramNameMessageTable(const ProgramNameMessageTable &table)
Definition: sctetables.h:652
std::vector< const unsigned char * > m_ptrs
Definition: sctetables.h:259
CarrierDefinitionSubtable CarrierDefinition(uint i) const
Definition: sctetables.h:239
SCTENetworkInformationTable(const SCTENetworkInformationTable &table)
Definition: sctetables.h:201
uint FirstIndex(void) const
Definition: sctetables.h:223
uint DescriptorsLength(void) const
Definition: sctetables.h:249
uint TableSubtype(void) const
Definition: sctetables.h:236
uint NumberOfRecords(void) const
Definition: sctetables.h:225
ModulationModeSubtable ModulationMode(uint i) const
Definition: sctetables.h:242
~SCTENetworkInformationTable() override
Definition: sctetables.h:212
uint TransmissionMedium(void) const
Definition: sctetables.h:227
const unsigned char * Descriptors(void) const
Definition: sctetables.h:251
SCTENetworkInformationTable(const PSIPTable &table)
Definition: sctetables.h:207
This table contains the GPS time at the time of transmission.
Definition: sctetables.h:573
uint32_t SystemTimeRaw(void) const
Definition: sctetables.h:594
time_t GPSUnix(void) const
Definition: sctetables.h:611
uint GPSUTCOffset(void) const
Definition: sctetables.h:616
QDateTime SystemTimeUTC(void) const
Definition: sctetables.h:605
SCTESystemTimeTable(const PSIPTable &table)
Definition: sctetables.h:579
const unsigned char * Descriptors(void) const
Definition: sctetables.h:620
QDateTime SystemTimeGPS(void) const
Definition: sctetables.h:599
SCTESystemTimeTable(const SCTESystemTimeTable &table)
Definition: sctetables.h:575
uint DescriptorsLength(void) const
Definition: sctetables.h:618
time_t UTCUnix(void) const
Definition: sctetables.h:613
ShortVirtualChannelTable(const PSIPTable &table)
Definition: sctetables.h:512
uint ID(void) const
Definition: sctetables.h:539
DefinedChannelsMapSubtable DefinedChannelsMap(void) const
Definition: sctetables.h:541
uint TableSubtype(void) const
Definition: sctetables.h:536
VirtualChannelMapSubtable VirtualChannelMap(void) const
Definition: sctetables.h:545
ShortVirtualChannelTable(const ShortVirtualChannelTable &table)
Definition: sctetables.h:506
InverseChannelMapSubtable InverseChannelMap(void) const
Definition: sctetables.h:549
const unsigned char * Descriptors(void) const
Definition: sctetables.h:557
uint DescriptorsLength(void) const
Definition: sctetables.h:555
~ShortVirtualChannelTable() override
Definition: sctetables.h:517
uint TransmissionMedium(void) const
Definition: sctetables.h:527
std::vector< const unsigned char * > m_ptrs
Definition: sctetables.h:566
Contains listing of Table ID's for various tables (PAT=0,PMT=2,etc).
Definition: mpegtables.h:260
@ SVCTscte
Definition: mpegtables.h:342
QDateTime ActivationTimeUTC(uint offset=0) const
Definition: sctetables.h:381
uint MMSReference(uint i) const
Definition: sctetables.h:439
uint NumberOfVCRecords(void) const
Definition: sctetables.h:388
uint ProgramNumber(uint i) const
Definition: sctetables.h:437
uint VirtualChannelNumber(uint i) const
Definition: sctetables.h:393
uint VideoStandard(uint i) const
Definition: sctetables.h:455
uint CDSReference(uint i) const
Definition: sctetables.h:435
QString VideoStandardString(uint i) const
Definition: sctetables.cpp:390
uint ApplicationID(uint i) const
Definition: sctetables.h:428
bool Scrambled(uint i) const
Definition: sctetables.h:443
QString TransportTypeString(uint i) const
Definition: sctetables.h:414
uint DescriptorsLength(uint i) const
Definition: sctetables.h:464
uint TransportType(uint i) const
Definition: sctetables.h:413
VirtualChannelMapSubtable(const unsigned char *data, const std::vector< const unsigned char * > &ptrs)
Definition: sctetables.h:361
uint DescriptorsCount(uint i) const
Definition: sctetables.h:461
QString PathSelectString(uint i) const
Definition: sctetables.h:405
QString ChannelTypeString(uint i) const
Definition: sctetables.h:424
uint PathSelect(uint i) const
Definition: sctetables.h:404
const std::vector< const unsigned char * > & _ptrs
Definition: sctetables.h:473
uint SourceID(uint i) const
Definition: sctetables.h:431
uint ChannelType(uint i) const
Definition: sctetables.h:423
uint Size(void) const
Definition: sctetables.h:470
bool ApplicationVirtualChannel(uint i) const
Definition: sctetables.h:396
const unsigned char * m_data
Definition: sctetables.h:472
bool Splice(void) const
Definition: sctetables.h:370
uint ActivationTimeRaw(void) const
Definition: sctetables.h:373
const unsigned char * Descriptors(uint i) const
Definition: sctetables.h:465
QString toStringXML(uint indent_level) const
Definition: sctetables.cpp:403
bool DescriptorsIncluded(void) const
Definition: sctetables.h:367
unsigned int uint
Definition: freesurround.h:24
int iso639_key_to_canonical_key(int iso639_2)
Definition: iso639.cpp:118
ISO 639-1 and ISO 639-2 support functions.
static QString iso639_key_to_str3(int code)
Definition: iso639.h:45
static int iso639_str3_to_key(const unsigned char *iso639_2)
Definition: iso639.h:60
static constexpr qint64 GPS_EPOCH
Seconds between start of GPS time and the start of UNIX time.
Definition: mpegtables.h:31
#define MTV_PUBLIC
Definition: mythtvexp.h:15
QString toString(const QDateTime &raw_dt, uint format)
Returns formatted string representing the time.
Definition: mythdate.cpp:93