00001
00002
00003 #ifndef _DVB_DESCRIPTORS_H_
00004 #define _DVB_DESCRIPTORS_H_
00005
00006 #include <QMutex>
00007 #include <QString>
00008
00009 #include "mythtvexp.h"
00010 #include "mpegdescriptors.h"
00011 #include "programinfo.h"
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 static QString coderate_inner(uint coderate);
00037
00038 extern QString dvb_decode_text(const unsigned char *src, uint length,
00039 const unsigned char *encoding_override,
00040 uint encoding_override_length);
00041
00042 inline QString dvb_decode_text(const unsigned char *src, uint length)
00043 {
00044 return dvb_decode_text(src, length, NULL, 0);
00045 }
00046
00047 QString dvb_decode_short_name(const unsigned char *src, uint raw_length);
00048
00049 #define byteBCDH2int(i) (i >> 4)
00050 #define byteBCDL2int(i) (i & 0x0f)
00051 #define byteBCD2int(i) (byteBCDH2int(i) * 10 + byteBCDL2int(i))
00052 #define byte2BCD2int(i, j) \
00053 (byteBCDH2int(i) * 1000 + byteBCDL2int(i) * 100 + \
00054 byteBCDH2int(j) * 10 + byteBCDL2int(j))
00055 #define byte3BCD2int(i, j, k) \
00056 (byteBCDH2int(i) * 100000 + byteBCDL2int(i) * 10000 + \
00057 byteBCDH2int(j) * 1000 + byteBCDL2int(j) * 100 + \
00058 byteBCDH2int(k) * 10 + byteBCDL2int(k))
00059 #define byte4BCD2int(i, j, k, l) \
00060 (byteBCDH2int(i) * 10000000LL + byteBCDL2int(i) * 1000000 + \
00061 byteBCDH2int(j) * 100000 + byteBCDL2int(j) * 10000 + \
00062 byteBCDH2int(k) * 1000 + byteBCDL2int(k) * 100 + \
00063 byteBCDH2int(l) * 10 + byteBCDL2int(l))
00064
00065
00066 class NetworkNameDescriptor : public MPEGDescriptor
00067 {
00068 public:
00069 NetworkNameDescriptor(const unsigned char *data, int len = 300) :
00070 MPEGDescriptor(data, len, DescriptorID::network_name) { }
00071
00072
00073
00074
00075 QString Name(void) const
00076 { return dvb_decode_text(_data+2, DescriptorLength()); }
00077 QString ShortName(void) const
00078 { return dvb_decode_short_name(_data+2, DescriptorLength()); }
00079 QString toString(void) const
00080 { return QString("NetworkNameDescriptor: ")+Name(); }
00081 };
00082
00083
00084 class LinkageDescriptor : public MPEGDescriptor
00085 {
00086 public:
00087 LinkageDescriptor(const unsigned char *data, int len = 300) :
00088 MPEGDescriptor(data, len, DescriptorID::linkage)
00089 {
00090 if (!_data)
00091 return;
00092 if (DescriptorLength() < 7)
00093 {
00094 _data = NULL;
00095 }
00096 else if (kMobileHandOver == LinkageType())
00097 {
00098 uint end = 8;
00099 if (DescriptorLength() < end)
00100 {
00101 _data = NULL;
00102 return;
00103 }
00104 end += (HasMobileNetworkID()) ? 2 : 0;
00105 end += (HasMobileInitialServiceID()) ? 2 : 0;
00106 if (DescriptorLength() < end)
00107 _data = NULL;
00108 m_offset = end + 2;
00109 }
00110 else if (kEventLinkage == LinkageType())
00111 {
00112 if (DescriptorLength() < 10)
00113 _data = NULL;
00114 m_offset = 12;
00115 }
00116 }
00117
00118
00119
00120
00121 uint TSID(void) const { return (_data[2]<<8) | _data[3]; }
00122
00123 uint OriginalNetworkID() const { return (_data[4]<<8) | _data[5]; }
00124
00125 uint ServiceID(void) const { return (_data[6]<<8) | _data[7]; }
00126
00127 enum
00128 {
00129 kInformationService = 0x01,
00130 kEPGService = 0x02,
00131 kCAReplacementService = 0x03,
00132 kTSContainingCompleteNetworkBouquetSI = 0x04,
00133 kServiceReplacementService = 0x05,
00134 kDataBroadcastService = 0x06,
00135 kRCSMap = 0x07,
00136 kMobileHandOver = 0x08,
00137 kSystemSoftwareUpdateService = 0x09,
00138 kTSContaining_SSU_BAT_NIT = 0x0A,
00139 kIP_MACNotificationService = 0x0B,
00140 kTSContaining_INT_BAT_NIT = 0x0C,
00141 kEventLinkage = 0x0D,
00142 };
00143 uint LinkageType(void) const { return _data[8]; }
00144 QString LinkageTypeString(void) const;
00145
00146
00147
00148
00149 enum
00150 {
00151 kHandOverIdentical = 0x01,
00152 kHandOverLocalVariation = 0x02,
00153 kHandOverAssociatedService = 0x03,
00154 };
00155 uint MobileHandOverType(void) const { return _data[9]>>4; }
00156 QString MobileHandOverTypeString(void) const;
00157
00158
00159 enum
00160 {
00161 kOriginNIT = 0x0,
00162 kOriginSDT = 0x1,
00163 };
00164 uint MobileOriginType(void) const { return _data[9]&0x1; }
00165 QString MobileOriginTypeString(void) const;
00166
00167
00168
00169 bool HasMobileNetworkID(void) const
00170 { return bool(MobileHandOverType() & 0x3); }
00171 uint MobileNetworkID(void) const { return (_data[10]<<8) | _data[11]; }
00172
00173
00174 bool HasMobileInitialServiceID(void) const
00175 { return kOriginNIT == MobileOriginType(); }
00176 uint MobileInitialServiceID(void) const
00177 {
00178 return HasMobileNetworkID() ?
00179 ((_data[12]<<8) | _data[13]) : ((_data[10]<<8) | _data[11]);
00180 }
00181
00182
00183
00184
00185 uint TargetEventID(void) const { return (_data[9]<<8) | _data[10]; }
00186
00187 bool IsTargetListed(void) const { return _data[11]&0x80; }
00188
00189 bool IsEventSimulcast(void) const { return _data[11]&0x40; }
00190
00191
00192
00193
00194 const unsigned char *PrivateData(void) const
00195 { return _data + m_offset; }
00196 uint PrivateDataLength(void) const
00197 { return DescriptorLength() + 2 - m_offset; }
00198
00199 private:
00200 uint m_offset;
00201 };
00202
00203
00204 class AdaptationFieldDataDescriptor : public MPEGDescriptor
00205 {
00206 public:
00207 AdaptationFieldDataDescriptor(const unsigned char *data, int len = 300) :
00208 MPEGDescriptor(data, len, DescriptorID::adaptation_field_data, 1) { }
00209
00210
00211
00212
00213 uint AdaptationFieldDataID(void) const { return _data[2]; }
00214 QString toString(void) const
00215 {
00216 return QString("AdaptationFieldDataDescriptor "
00217 "adaptation_field_data_identifier(%1)")
00218 .arg(AdaptationFieldDataID());
00219 }
00220 };
00221
00222
00223 class AncillaryDataDescriptor : public MPEGDescriptor
00224 {
00225 public:
00226 AncillaryDataDescriptor(const unsigned char *data, int len = 300) :
00227 MPEGDescriptor(data, len, DescriptorID::ancillary_data, 1) { }
00228
00229
00230
00231
00232 uint AncillaryDataID(void) const { return _data[2]; }
00233 QString toString(void) const
00234 {
00235 return QString("AncillaryDataDescriptor "
00236 "ancillary_data_identifier(%1)")
00237 .arg(AncillaryDataID());
00238 }
00239 };
00240
00241
00242 class AnnouncementSupportDescriptor : public MPEGDescriptor
00243 {
00244 public:
00245 AnnouncementSupportDescriptor(const unsigned char *data, int len = 300) :
00246 MPEGDescriptor(data, len, DescriptorID::announcement_support) { }
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264 };
00265
00266
00267 class BouquetNameDescriptor : public MPEGDescriptor
00268 {
00269 public:
00270 BouquetNameDescriptor(const unsigned char *data, int len = 300) :
00271 MPEGDescriptor(data, len, DescriptorID::bouquet_name) { }
00272
00273
00274
00275
00276 QString BouquetName(void) const
00277 { return dvb_decode_text(_data+2, _data[1]); }
00278 QString BouquetShortName(void) const
00279 { return dvb_decode_short_name(_data+2, _data[1]); }
00280
00281 QString toString(void) const
00282 {
00283 return QString("BouquetNameDescriptor: Bouquet Name(%1)")
00284 .arg(BouquetName());
00285 }
00286 };
00287
00288
00289 class CAIdentifierDescriptor : public MPEGDescriptor
00290 {
00291 public:
00292 CAIdentifierDescriptor(const unsigned char *data, int len = 300) :
00293 MPEGDescriptor(data, len, DescriptorID::ca_identifier) { }
00294
00295
00296
00297
00298 uint CASystemCount(void) const { return DescriptorLength() >> 1; }
00299
00300
00301 int CASystemId(uint i) const
00302 { return (_data[2 + i*2] << 8) | _data[3 + i*2]; }
00303 QString toString(void) const;
00304 };
00305
00306
00307 class CellFrequencyLinkDescriptor : public MPEGDescriptor
00308 {
00309 public:
00310 CellFrequencyLinkDescriptor(const unsigned char *data, int len = 300) :
00311 MPEGDescriptor(data, len, DescriptorID::cell_frequency_link) { }
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326 };
00327
00328
00329 class CellListDescriptor : public MPEGDescriptor
00330 {
00331 public:
00332 CellListDescriptor(const unsigned char *data, int len = 300) :
00333 MPEGDescriptor(data, len, DescriptorID::cell_list) { }
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348
00349
00350
00351
00352
00353
00354 };
00355
00356
00357 class ComponentDescriptor : public MPEGDescriptor
00358 {
00359 public:
00360 ComponentDescriptor(const unsigned char *data, int len = 300) :
00361 MPEGDescriptor(data, len, DescriptorID::component) { }
00362
00363
00364
00365
00366
00367 uint StreamContent(void) const { return _data[2] & 0xf; }
00368
00369 uint ComponentType(void) const { return _data[3]; }
00370
00371 uint ComponentTag(void) const { return _data[4]; }
00372
00373 int LanguageKey(void) const
00374 { return iso639_str3_to_key(&_data[5]); }
00375 QString LanguageString(void) const
00376 { return iso639_key_to_str3(LanguageKey()); }
00377 int CanonicalLanguageKey(void) const
00378 { return iso639_key_to_canonical_key(LanguageKey()); }
00379 QString CanonicalLanguageString(void) const
00380 { return iso639_key_to_str3(CanonicalLanguageKey()); }
00381
00382
00383
00384 bool IsVideo(void) const
00385 {
00386 return 0x1 == StreamContent() ||
00387 0x5 == StreamContent();
00388 }
00389 bool IsAudio(void) const
00390 {
00391 switch(StreamContent())
00392 {
00393 case 0x02:
00394 case 0x04:
00395 case 0x06:
00396 case 0x07:
00397 return true;
00398 default:
00399 return false;
00400 }
00401 }
00402 bool IsSubtitle(void) const { return 0x3 == StreamContent(); }
00403
00404 unsigned char VideoProperties(void) const
00405 {
00406 if (0x1 == StreamContent())
00407 return MPEG2Properties();
00408 if (0x5 == StreamContent())
00409 return VID_AVC | AVCProperties();
00410
00411 return VID_UNKNOWN;
00412 }
00413
00414 unsigned char MPEG2Properties(void) const
00415 {
00416 switch(ComponentType())
00417 {
00418 case 0x2: case 0x3: case 0x4:
00419 case 0x6: case 0x7: case 0x8:
00420 return VID_WIDESCREEN;
00421 case 0x09:
00422 case 0x0D:
00423 return VID_HDTV;
00424 case 0x0A: case 0x0B: case 0x0C:
00425 case 0x0E: case 0x0F: case 0x10:
00426 return VID_WIDESCREEN | VID_HDTV;
00427 default:
00428 return VID_UNKNOWN;
00429 }
00430 }
00431
00432 unsigned char AVCProperties(void) const
00433 {
00434 switch(ComponentType())
00435 {
00436 case 0x3: case 0x4:
00437 case 0x7: case 0x8:
00438 return VID_WIDESCREEN;
00439 case 0x0B: case 0x0C:
00440 case 0x0F: case 0x10:
00441 return VID_WIDESCREEN | VID_HDTV;
00442 case 0x80: case 0x81:
00443 case 0x82: case 0x83:
00444 return VID_WIDESCREEN | VID_HDTV | VID_3DTV;
00445 default:
00446 return VID_UNKNOWN;
00447 }
00448 }
00449
00450 unsigned char AudioProperties(void) const
00451 {
00452 switch (StreamContent())
00453 {
00454 case 0x2:
00455 return MP2Properties();
00456 case 0x04:
00457 return AC3Properties();
00458 case 0x06:
00459 return HEAACProperties();
00460 default:
00461 return AUD_UNKNOWN;
00462 }
00463 }
00464
00465 unsigned char MP2Properties(void) const
00466 {
00467 switch (ComponentType())
00468 {
00469 case 0x1:
00470 return AUD_MONO;
00471 case 0x3:
00472 return AUD_STEREO;
00473 case 0x5:
00474 return AUD_SURROUND;
00475 case 0x40:
00476 return AUD_VISUALIMPAIR;
00477 case 0x41:
00478 return AUD_HARDHEAR;
00479 default:
00480 return AUD_UNKNOWN;
00481 }
00482 }
00483
00484 unsigned char AC3Properties(void) const
00485 {
00486 unsigned char properties = AUD_UNKNOWN;
00487
00488 switch (ComponentType() & 0x7)
00489 {
00490 case 0x0:
00491 properties |= AUD_MONO;
00492 break;
00493 case 0x2:
00494 properties |= AUD_STEREO;
00495 break;
00496 case 0x3:
00497 properties |= AUD_DOLBY;
00498 break;
00499 case 0x4: case 0x5:
00500 properties |= AUD_SURROUND;
00501 break;
00502 }
00503
00504 if (((ComponentType() >> 3) & 0x7) == 0x2)
00505 properties |= AUD_VISUALIMPAIR;
00506
00507 if (((ComponentType() >> 3) & 0x7) == 0x3)
00508 properties |= AUD_HARDHEAR;
00509
00510 return properties;
00511 }
00512
00513 unsigned char HEAACProperties(void) const
00514 {
00515 switch (ComponentType())
00516 {
00517 case 0x1:
00518 return AUD_MONO;
00519 case 0x3:
00520 case 0x43:
00521 return AUD_STEREO;
00522 case 0x5:
00523 return AUD_SURROUND;
00524 case 0x40:
00525 case 0x44:
00526 return AUD_VISUALIMPAIR;
00527 case 0x41:
00528 case 0x45:
00529 return AUD_HARDHEAR;
00530 default:
00531 return AUD_UNKNOWN;
00532 }
00533 }
00534
00535 unsigned char SubtitleType(void) const
00536 {
00537 if (!IsSubtitle())
00538 return SUB_UNKNOWN;
00539
00540 switch (ComponentType())
00541 {
00542 case 0x1:
00543 case 0x3:
00544 case 0x10: case 0x11: case 0x12: case 0x13:
00545 return SUB_NORMAL;
00546 case 0x20: case 0x21: case 0x22: case 0x23:
00547 return SUB_HARDHEAR;
00548 default:
00549 return SUB_UNKNOWN;
00550 }
00551 }
00552
00553 QString toString(void) const
00554 {
00555 return QString("ComponentDescriptor(stream_content: 0x%1, "
00556 "component_type: 0x%2)").arg(StreamContent(), 0, 16)
00557 .arg(ComponentType(), 0, 16);
00558 }
00559 };
00560
00561
00562 class ContentDescriptor : public MPEGDescriptor
00563 {
00564 public:
00565 ContentDescriptor(const unsigned char *data, int len = 300) :
00566 MPEGDescriptor(data, len, DescriptorID::content) { }
00567
00568
00569
00570
00571 uint Count(void) const { return DescriptorLength() >> 1; }
00572
00573
00574
00575 uint Nibble1(uint i) const { return _data[2 + (i<<1)] >> 4; }
00576
00577 uint Nibble2(uint i) const { return _data[2 + (i<<1)] & 0xf; }
00578
00579 uint Nibble(uint i) const { return _data[2 + (i<<1)]; }
00580
00581
00582 uint UserNibble1(uint i) const { return _data[3 + (i<<1)] >> 4; }
00583
00584 uint UserNibble2(uint i) const { return _data[3 + (i<<1)] & 0xf; }
00585 uint UserNibble(uint i) const { return _data[3 + (i<<1)]; }
00586
00587
00588 ProgramInfo::CategoryType GetMythCategory(uint i) const;
00589 QString GetDescription(uint i) const;
00590 QString toString(void) const;
00591
00592 protected:
00593 static void Init(void);
00594
00595 protected:
00596 static QMutex categoryLock;
00597 static QMap<uint,QString> categoryDesc;
00598 static volatile bool categoryDescExists;
00599 };
00600
00601
00602 class CountryAvailabilityDescriptor : public MPEGDescriptor
00603 {
00604 public:
00605 CountryAvailabilityDescriptor(const unsigned char *data, int len = 300) :
00606 MPEGDescriptor(data, len, DescriptorID::country_availability) { }
00607
00608
00609
00610
00611 uint CountryCount(void) const { return ((DescriptorLength() - 1) / 3); }
00612
00613
00614 bool IsAvailable(void) const { return (_data[2] & 0x1); }
00615
00616
00617
00618
00619 QString CountryNames(void) const
00620 {
00621 QString countries="";
00622 for (uint i=0; i<CountryCount(); i++)
00623 {
00624 if (i!=0) countries.append(" ");
00625 countries.append(QString::fromLatin1(
00626 (const char *)_data+(3*(i+1)), 3));
00627 };
00628 return countries;
00629 }
00630
00631 QString toString(void) const
00632 {
00633 return QString("CountryAvailabilityDescriptor: Available(%1) in (%2)")
00634 .arg(IsAvailable()).arg(CountryNames());
00635 }
00636 };
00637
00638
00639 class DataBroadcastDescriptor : public MPEGDescriptor
00640 {
00641 public:
00642 DataBroadcastDescriptor(const unsigned char *data, int len = 300) :
00643 MPEGDescriptor(data, len, DescriptorID::data_broadcast) { }
00644
00645
00646
00647
00648
00649 uint DataBroadcastId(void) const { return _data[2] << 8 | _data[3]; }
00650
00651 uint DataComponentTag(void) const { return _data[4]; }
00652
00653 uint SelectorLength(void) const { return _data[5]; }
00654
00655
00656
00657 const unsigned char *Selector(void) const { return _data + 6; }
00658
00659
00660 int LanguageKey(void) const
00661 { return iso639_str3_to_key(&_data[6 + SelectorLength()]); }
00662 QString LanguageString(void) const
00663 { return iso639_key_to_str3(LanguageKey()); }
00664 int CanonicalLanguageKey(void) const
00665 { return iso639_key_to_canonical_key(LanguageKey()); }
00666 QString CanonicalLanguageString(void) const
00667 { return iso639_key_to_str3(CanonicalLanguageKey()); }
00668
00669 uint TextLength(void) const { return _data[6 + SelectorLength() + 3]; }
00670
00671 QString Text(void) const
00672 {
00673 return dvb_decode_text(&_data[6 + SelectorLength() + 4], TextLength());
00674 }
00675
00676 QString toString(void) const;
00677 };
00678
00679
00680 class DataBroadcastIdDescriptor : public MPEGDescriptor
00681 {
00682 public:
00683 DataBroadcastIdDescriptor(const unsigned char *data, int len = 300) :
00684 MPEGDescriptor(data, len, DescriptorID::data_broadcast_id) { }
00685
00686
00687
00688
00689
00690 uint DataBroadCastId(void) const { return _data[2] << 8 | _data[3]; }
00691
00692
00693 };
00694
00695
00696 class CableDeliverySystemDescriptor : public MPEGDescriptor
00697 {
00698 public:
00699 CableDeliverySystemDescriptor(const unsigned char *data, int len = 300) :
00700 MPEGDescriptor(data, len, DescriptorID::cable_delivery_system) { }
00701
00702
00703
00704
00705
00706 uint FrequencyRaw(void) const
00707 {
00708 return ((_data[2]<<24) | (_data[3]<<16) |
00709 (_data[4]<<8) | (_data[5]));
00710 }
00711 unsigned long long FrequencyHz(void) const
00712 {
00713 return byte4BCD2int(_data[2], _data[3], _data[4], _data[5]) * 100;
00714 }
00715
00716
00717 enum
00718 {
00719 kOuterFEC_None = 0x1,
00720 kOuterFEC_RS204_RS188 = 0x2,
00721 };
00722 uint FECOuter(void) const { return _data[7] & 0xf; }
00723 QString FECOuterString(void) const
00724 {
00725 return (FECOuter() == kOuterFEC_None) ? "None" :
00726 ((FECOuter() == kOuterFEC_RS204_RS188) ? "RS(204/188)" : "unknown");
00727 }
00728
00729 enum
00730 {
00731 kModulationQAM16 = 0x01,
00732 kModulationQAM32 = 0x02,
00733 kModulationQAM64 = 0x03,
00734 kModulationQAM128 = 0x04,
00735 kModulationQAM256 = 0x05,
00736 };
00737 uint Modulation(void) const { return _data[8]; }
00738 QString ModulationString(void) const
00739 {
00740 static QString ms[] =
00741 { "auto", "qam_16", "qam_32", "qam_64", "qam_128", "qam_256" };
00742 return (Modulation() <= kModulationQAM256) ?
00743 ms[Modulation()] : QString("auto");
00744 }
00745
00746 uint SymbolRateRaw(void) const
00747 {
00748 return ((_data[9]<<20) | (_data[10]<<12) |
00749 (_data[11]<<4) | (_data[12]>>4));
00750 }
00751 uint SymbolRateHz(void) const
00752 {
00753 return ((byte3BCD2int(_data[9], _data[10], _data[11]) * 1000) +
00754 (byteBCDH2int(_data[12]) * 100));
00755 }
00756
00757 enum
00758 {
00759 kInnerFEC_1_2_ConvolutionCodeRate = 0x1,
00760 kInnerFEC_2_3_ConvolutionCodeRate = 0x2,
00761 kInnerFEC_3_4_ConvolutionCodeRate = 0x3,
00762 kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
00763 kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
00764 kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
00765 kInnerFEC_None = 0xF,
00766 };
00767 uint FECInner(void) const { return _data[12] & 0xf; }
00768 QString FECInnerString(void) const { return coderate_inner(FECInner()); }
00769 QString toString(void) const;
00770 };
00771
00772
00773 class SatelliteDeliverySystemDescriptor : public MPEGDescriptor
00774 {
00775 public:
00776 SatelliteDeliverySystemDescriptor(
00777 const unsigned char *data, int len = 300) :
00778 MPEGDescriptor(data, len, DescriptorID::satellite_delivery_system) { }
00779
00780
00781
00782
00784 uint FrequencyRaw(void) const
00785 {
00786 return ((_data[2]<<24) | (_data[3]<<16) |
00787 (_data[4]<<8) | (_data[5]));
00788 }
00789 unsigned long long FrequencyHz(void) const
00790 {
00791 return byte4BCD2int(_data[2], _data[3], _data[4], _data[5]) * 10;
00792 }
00794 uint OrbitalPosition(void) const
00795 { return byte2BCD2int(_data[6], _data[7]); }
00796 QString OrbitalPositionString(void) const
00797 {
00798 uint num = OrbitalPosition();
00799 return QString("%1.%2 %3").arg(num / 10).arg(num % 10)
00800 .arg((IsEast()) ? "East" : "West");
00801 }
00802 double OrbitalPositionFloat() const
00803 { return ((double) OrbitalPosition()) / 10.0; }
00805 bool IsEast(void) const { return (_data[8]&0x80); }
00806 bool IsWest(void) const { return !IsEast(); }
00807
00808 uint Polarization(void) const { return (_data[8]>>5)&0x3; }
00809 QString PolarizationString() const
00810 {
00811 static QString ps[] = { "h", "v", "l", "r" };
00812 return ps[Polarization()];
00813 }
00814 bool IsCircularPolarization(void) const { return (_data[8]>>6)&0x1; }
00815 bool IsLinearPolarization(void) const { return !((_data[8]>>6)&0x1); }
00816 bool IsHorizontalLeftPolarization(void) const { return (_data[8]>>5)&0x1; }
00817 bool IsVerticalRightPolarization(void) const
00818 { return !((_data[8]>>5)&0x1); }
00819
00820 enum
00821 {
00822 kRollOff_35,
00823 kRollOff_20,
00824 kRollOff_25,
00825 kRollOff_Auto,
00826 };
00827 uint RollOff(void) const { return (_data[8]>>3)&0x3; }
00828 QString RollOffString(void) const
00829 {
00830 static QString ro[] = { "0.35", "0.20", "0.25", "auto" };
00831 return ro[RollOff()];
00832 }
00833
00834 uint ModulationSystem(void) const { return (_data[8]>>2)&0x1; }
00835 QString ModulationSystemString(void) const
00836 {
00837 return ModulationSystem() ? "DVB-S2" : "DVB-S";
00838 }
00839
00840 enum
00841 {
00842 kModulationQPSK_NS = 0x0,
00843
00844 kModulationQPSK = 0x1,
00845 kModulation8PSK = 0x2,
00846 kModulationQAM16 = 0x3,
00847 };
00848 uint Modulation(void) const { return _data[8]&0x03; }
00849 QString ModulationString(void) const
00850 {
00851 static QString ms[] = { "qpsk", "qpsk", "8psk", "qam_16" };
00852 return ms[Modulation()];
00853 }
00854
00855 uint SymbolRate(void) const
00856 {
00857 return ((_data[9]<<20) | (_data[10]<<12) |
00858 (_data[11]<<4) | (_data[12]>>4));
00859 }
00860 uint SymbolRateHz(void) const
00861 {
00862 return ((byte3BCD2int(_data[9], _data[10], _data[11]) * 1000) +
00863 (byteBCDH2int(_data[12]) * 100));
00864 }
00865
00866 enum
00867 {
00868 kInnerFEC_1_2_ConvolutionCodeRate = 0x1,
00869 kInnerFEC_2_3_ConvolutionCodeRate = 0x2,
00870 kInnerFEC_3_4_ConvolutionCodeRate = 0x3,
00871 kInnerFEC_5_6_ConvolutionCodeRate = 0x4,
00872 kInnerFEC_7_8_ConvolutionCodeRate = 0x5,
00873 kInnerFEC_8_9_ConvolutionCodeRate = 0x6,
00874 kInnerFEC_None = 0xF,
00875 };
00876 uint FECInner(void) const { return _data[12] & 0xf; }
00877 QString FECInnerString(void) const { return coderate_inner(FECInner()); }
00878
00879 QString toString(void) const;
00880 };
00881
00882
00883 class TerrestrialDeliverySystemDescriptor : public MPEGDescriptor
00884 {
00885 public:
00886 TerrestrialDeliverySystemDescriptor(
00887 const unsigned char *data, int len = 300) :
00888 MPEGDescriptor(data, len, DescriptorID::terrestrial_delivery_system) { }
00889
00890
00891
00892
00893
00894 uint Frequency(void) const
00895 {
00896 return ((_data[2]<<24) | (_data[3]<<16) |
00897 (_data[4]<<8) | (_data[5]));
00898 }
00899 uint64_t FrequencyHz(void) const { return uint64_t(Frequency()) * 10ULL; }
00900
00901
00902 enum
00903 {
00904 kBandwidth8Mhz = 0x0,
00905 kBandwidth7Mhz = 0x1,
00906 kBandwidth6Mhz = 0x2,
00907 kBandwidth5Mhz = 0x3,
00908 };
00909 uint Bandwidth(void) const { return _data[6]>>5; }
00910 uint BandwidthHz(void) const { return (8 - Bandwidth()) * 1000000; }
00911 QString BandwidthString(void) const
00912 {
00913 static QString bs[] = { "8", "7", "6", "5" };
00914 return (Bandwidth() <= kBandwidth5Mhz) ? bs[Bandwidth()] : "auto";
00915 }
00916
00917 bool HighPriority(void) const { return _data[6] & 0x10; }
00918
00919 bool IsTimeSlicingIndicatorUsed(void) const { return !(_data[6] & 0x08); }
00920
00921 bool IsMPE_FECUsed(void) const { return !(_data[6] & 0x04); }
00922
00923
00924 enum
00925 {
00926 kConstellationQPSK = 0x0,
00927 kConstellationQAM16 = 0x1,
00928 kConstellationQAM64 = 0x2,
00929 };
00930 uint Constellation(void) const { return _data[7]>>6; }
00931 QString ConstellationString(void) const
00932 {
00933 static QString cs[] = { "qpsk", "qam_16", "qam_64" };
00934 return (Constellation() <= kConstellationQAM64) ?
00935 cs[Constellation()] : "auto";
00936 }
00937
00938 enum
00939 {
00940 kHierarchyInfoNonHierarchicalNativeInterleaver = 0x0,
00941 kHierarchyInfoAlpha1NativeInterleaver = 0x1,
00942 kHierarchyInfoAlpha2NativeInterleaver = 0x2,
00943 kHierarchyInfoAlpha4NativeInterleaver = 0x3,
00944 kHierarchyInfoNonHierarchicalInDepthInterleaver = 0x4,
00945 kHierarchyInfoAlpha1InDepthInterleaver = 0x5,
00946 kHierarchyInfoAlpha2InDepthInterleaver = 0x6,
00947 kHierarchyInfoAlpha4InDepthInterleaver = 0x7,
00948 };
00949 uint Hierarchy(void) const { return (_data[7]>>3) & 0x7; }
00950
00952 QString HierarchyString(void) const
00953 {
00954 static QString hs[] = { "n", "1", "2", "4", "a", "a", "a", "a" };
00955 return hs[Hierarchy()];
00956 }
00957 bool NativeInterleaver(void) const { return _data[7] & 0x20; }
00958 uint Alpha(void) const
00959 {
00960 uint i = (_data[7]>>3) & 0x3;
00961 return (0x2 == i) ? 4 : i;
00962 }
00963
00964 enum
00965 {
00966 kCodeRate_1_2 = 0x0,
00967 kCodeRate_2_3 = 0x1,
00968 kCodeRate_3_4 = 0x2,
00969 kCodeRate_5_6 = 0x3,
00970 kCodeRate_7_8 = 0x4,
00971 };
00972 uint CodeRateHP(void) const { return _data[7] & 0x7; }
00973 QString CodeRateHPString(void) const
00974 {
00975 static QString cr[] = {
00976 "1/2", "2/3", "3/4", "5/6", "7/8", "auto", "auto", "auto"
00977 };
00978 return cr[CodeRateHP()];
00979 }
00980
00981 uint CodeRateLP(void) const { return (_data[8]>>5) & 0x7; }
00982 QString CodeRateLPString(void) const
00983 {
00984 static QString cr[] = {
00985 "1/2", "2/3", "3/4", "5/6", "7/8", "auto", "auto", "auto"
00986 };
00987 return cr[CodeRateLP()];
00988 }
00989
00990 enum
00991 {
00992 kGuardInterval_1_32 = 0x0,
00993 kGuardInterval_1_16 = 0x1,
00994 kGuardInterval_1_8 = 0x2,
00995 kGuardInterval_1_4 = 0x3,
00996 };
00997 uint GuardInterval(void) const { return (_data[8]>>3) & 0x3; }
00998 QString GuardIntervalString(void) const
00999 {
01000 static QString gi[] = { "1/32", "1/16", "1/8", "1/4" };
01001 return gi[GuardInterval()];
01002 }
01003
01004 enum
01005 {
01006 kTransmissionMode2k = 0x00,
01007 kTransmissionMode8k = 0x01,
01008 kTransmissionMode4k = 0x02,
01009 };
01010 uint TransmissionMode(void) const { return (_data[8]>>1) & 0x3; }
01011 QString TransmissionModeString(void) const
01012 {
01013 static QString tm[] = { "2", "8", "4", "auto" };
01014 return tm[TransmissionMode()];
01015 }
01016
01017 bool OtherFrequencyInUse(void) const { return _data[8] & 0x1; }
01018
01019
01020 QString toString(void) const;
01021 };
01022
01023
01024 class DSNGDescriptor : public MPEGDescriptor
01025 {
01026 public:
01027 DSNGDescriptor(const unsigned char *data, int len = 300) :
01028 MPEGDescriptor(data, len, DescriptorID::dsng) { }
01029
01030
01031
01032
01033 };
01034
01035
01036 class ExtendedEventDescriptor : public MPEGDescriptor
01037 {
01038 public:
01039 ExtendedEventDescriptor(const unsigned char *data, int len = 300) :
01040 MPEGDescriptor(data, len, DescriptorID::extended_event) { }
01041
01042
01043
01044
01045
01046 uint DescriptorNumber(void) const { return _data[2] >> 4; }
01047
01048 uint LastNumber(void) const { return _data[2] & 0xf; }
01049
01050 int LanguageKey(void) const
01051 { return iso639_str3_to_key(&_data[3]); }
01052 QString LanguageString(void) const
01053 { return iso639_key_to_str3(LanguageKey()); }
01054 int CanonicalLanguageKey(void) const
01055 { return iso639_key_to_canonical_key(LanguageKey()); }
01056 QString CanonicalLanguageString(void) const
01057 { return iso639_key_to_str3(CanonicalLanguageKey()); }
01058
01059 uint LengthOfItems(void) const { return _data[6]; }
01060
01061
01062
01063
01064
01065
01066
01067
01068 uint TextLength(void) const { return _data[7 + _data[6]]; }
01069
01070 QString Text(void) const
01071 { return dvb_decode_text(&_data[8 + _data[6]], TextLength()); }
01072
01073
01074 QString Text(const unsigned char *encoding_override,
01075 uint encoding_length) const
01076 {
01077 return dvb_decode_text(&_data[8 + _data[6]], TextLength(),
01078 encoding_override, encoding_length);
01079 }
01080
01081 };
01082
01083
01084 class FrequencyListDescriptor : public MPEGDescriptor
01085 {
01086 public:
01087 FrequencyListDescriptor(const unsigned char *data, int len = 300) :
01088 MPEGDescriptor(data, len, DescriptorID::frequency_list) { }
01089
01090
01091
01092
01093
01094
01095 enum
01096 {
01097 kCodingTypeNotDefined = 0x0,
01098 kCodingTypeSatellite = 0x1,
01099 kCodingTypeCable = 0x2,
01100 kCodingTypeTerrestrial = 0x3,
01101 };
01102 uint CodingType(void) const { return _data[2] & 0x3; }
01103
01104
01105
01106
01107 uint FrequencyCount() const { return DescriptorLength()>>2; }
01108 unsigned long long Frequency(uint i) const
01109 {
01110 if (kCodingTypeTerrestrial == CodingType())
01111 return ((_data[3 + (i<<2)]<<24) | (_data[4 + (i<<2)]<<16) |
01112 (_data[5 + (i<<2)]<<8) | (_data[6 + (i<<2)]));
01113 else
01114 return byte4BCD2int(_data[3 + (i<<2)], _data[4 + (i<<2)],
01115 _data[5 + (i<<2)], _data[6 + (i<<2)]);
01116 }
01117 unsigned long long FrequencyHz(uint i) const
01118 {
01119 return Frequency(i) *
01120 ((kCodingTypeTerrestrial == CodingType()) ? 10 : 100);
01121 }
01122
01123 QString toString(void) const;
01124 };
01125
01126
01127
01128 class LocalTimeOffsetDescriptor : public MPEGDescriptor
01129 {
01130 public:
01131 LocalTimeOffsetDescriptor(const unsigned char *data, int len = 300) :
01132 MPEGDescriptor(data, len, DescriptorID::local_time_offset) { }
01133
01134
01135
01136 uint Count(void) const { return DescriptorLength() / 13; }
01137
01138
01139
01140 uint CountryCode(uint i) const
01141 {
01142 int o = 2 + i*13;
01143 return ((_data[o] << 16) | (_data[o+1] << 8) | _data[o+2]);
01144 }
01145 QString CountryCodeString(uint i) const
01146 {
01147 int o = 2 + i*13;
01148 return QString(_data[o]) + QChar(_data[o+1]) + QChar(_data[o+2]);
01149 }
01150
01151 uint CountryRegionId(uint i) const { return _data[2 + i*13 + 3] >> 2; }
01152
01153
01155 bool LocalTimeOffsetPolarity(uint i) const
01156 { return _data[2 + i*13 + 3] & 0x01; }
01157
01158 uint LocalTimeOffset(uint i) const
01159 { return (_data[2 + i*13 + 4] << 8) | _data[2 + i*13 + 5]; }
01160 int LocalTimeOffsetWithPolarity(uint i) const
01161 { return (LocalTimeOffsetPolarity(i) ? -1 : +1) * LocalTimeOffset(i); }
01162
01163
01164
01165 uint NextTimeOffset(uint i) const
01166 { return (_data[2 + i*13 + 11]<<8) | _data[2 + i*13 + 12]; }
01167
01168 QString toString(void) const;
01169 };
01170
01171
01172 class MosaicDescriptor : public MPEGDescriptor
01173 {
01174 public:
01175 MosaicDescriptor(const unsigned char *data, int len = 300) :
01176 MPEGDescriptor(data, len, DescriptorID::mosaic) { }
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221 };
01222
01223
01224 class MultilingualBouquetNameDescriptor : public MPEGDescriptor
01225 {
01226 public:
01227 MultilingualBouquetNameDescriptor(
01228 const unsigned char *data, int len = 300) :
01229 MPEGDescriptor(data, len, DescriptorID::multilingual_bouquet_name) { }
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240 };
01241
01242
01243 class MultilingualNetworkNameDescriptor : public MPEGDescriptor
01244 {
01245 public:
01246 MultilingualNetworkNameDescriptor(
01247 const unsigned char *data, int len = 300) :
01248 MPEGDescriptor(data, len, DescriptorID::multilingual_network_name)
01249 {
01250
01251
01252
01253 }
01254
01255
01256
01257
01258
01259
01260
01261 };
01262
01263
01264 class MultilingualServiceNameDescriptor : public MPEGDescriptor
01265 {
01266 public:
01267 MultilingualServiceNameDescriptor(
01268 const unsigned char *data, int len = 300) :
01269 MPEGDescriptor(data, len, DescriptorID::multilingual_service_name) { }
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282 };
01283
01284
01285 class NVODReferenceDescriptor : public MPEGDescriptor
01286 {
01287 public:
01288 NVODReferenceDescriptor(const unsigned char *data, int len = 300) :
01289 MPEGDescriptor(data, len, DescriptorID::nvod_reference) { }
01290
01291
01292
01293 uint Count(void) const { return DescriptorLength() / 6; }
01294
01295
01296
01297
01298 uint TransportStreamId(uint i) const
01299 { return (_data[i * 6 + 2] << 8) | _data[i * 6 + 3]; }
01300
01301 uint OriginalNetworkId(uint i) const
01302 { return (_data[i * 6 + 4] << 8) | _data[i * 6 + 5]; }
01303
01304 uint ServiceId(uint i) const
01305 { return (_data[i * 6 + 6] << 8) | _data[i * 6 + 7]; }
01306
01307 QString toString(void) const;
01308 };
01309
01310
01311 class ParentalRatingDescriptor : public MPEGDescriptor
01312 {
01313 public:
01314 ParentalRatingDescriptor(const unsigned char *data, int len = 300) :
01315 MPEGDescriptor(data, len, DescriptorID::parental_rating) { }
01316
01317
01318
01319 uint Count(void) const { return DescriptorLength() / 4; }
01320
01321
01322
01323
01324
01325
01326 };
01327
01328
01329 class PDCDescriptor : public MPEGDescriptor
01330 {
01331 public:
01332 PDCDescriptor(const unsigned char *data, int len = 300) :
01333 MPEGDescriptor(data, len, DescriptorID::pdc, 3) { }
01334
01335
01336
01337
01338
01339
01340 uint ProgramIdLabel(void) const
01341 { return (_data[2] & 0x0F) << 16 | _data[3] << 8 | _data[4]; }
01342 QString toString(void) const
01343 {
01344 return QString("PDCDescriptor program_id_label(%1)")
01345 .arg(ProgramIdLabel());
01346 }
01347 };
01348
01349
01350 class PrivateDataSpecifierDescriptor : public MPEGDescriptor
01351 {
01352 public:
01353 PrivateDataSpecifierDescriptor(const unsigned char *data, int len = 300) :
01354 MPEGDescriptor(data, len, DescriptorID::private_data_specifier) { }
01355
01356
01357
01358
01359
01360 };
01361
01362
01363 class ScramblingDescriptor : public MPEGDescriptor
01364 {
01365 public:
01366 ScramblingDescriptor(const unsigned char *data, int len = 300) :
01367 MPEGDescriptor(data, len, DescriptorID::scrambling, 1) { }
01368
01369
01370
01371
01372
01373 uint ScramblingMode(void) const { return _data[2]; }
01374 QString toString(void) const
01375 {
01376 return QString("ScramblingDescriptor scrambling_mode(%1)")
01377 .arg(ScramblingMode());
01378 }
01379 };
01380
01381
01382 class ServiceDescriptorMapping
01383 {
01384 public:
01385 ServiceDescriptorMapping(const uint serviceid) { m_serviceid = serviceid; }
01386 enum
01387 {
01388 kServiceTypeDigitalTelevision = 0x01,
01389 kServiceTypeDigitalRadioSound = 0x02,
01390 kServiceTypeTeletext = 0x03,
01391 kServiceTypeNVODReference = 0x04,
01392 kServiceTypeNVODTimeShifted = 0x05,
01393 kServiceTypeMosaic = 0x06,
01394 kServiceTypePALCodedSignal = 0x07,
01395 kServiceTypeSECAMCodedSignal = 0x08,
01396 kServiceTypeD_D2_MAC = 0x09,
01397 kServiceTypeAdvancedCodecDigitalRadioSound = 0x0A,
01398 kServiceTypeNTSCCodedSignal = 0x0B,
01399 kServiceTypeDataBroadcast = 0x0C,
01400 kServiceTypeCommonInterface = 0x0D,
01401 kServiceTypeRCS_Map = 0x0E,
01402 kServiceTypeRCS_FLS = 0x0F,
01403 kServiceTypeDVB_MHP = 0x10,
01404 kServiceTypeHDTV = 0x11,
01405 kServiceTypeAdvancedCodecSDDigitalTelevision = 0x16,
01406 kServiceTypeAdvancedCodecHDDigitalTelevision = 0x19,
01407 kServiceTypeAdvancedCodecFrameCompatiblePlanoStereoscopicHDTelevisionService = 0x1c,
01408 kServiceTypeEchoStarTV1 = 0x91,
01409 kServiceTypeEchoStarTV2 = 0x9a,
01410 kServiceTypeEchoStarTV3 = 0xa4,
01411 kServiceTypeEchoStarTV4 = 0xa6,
01412 kServiceTypeNimiqTV1 = 0x81,
01413 kServiceTypeNimiqTV2 = 0x85,
01414 kServiceTypeNimiqTV3 = 0x86,
01415 kServiceTypeNimiqTV4 = 0x89,
01416 kServiceTypeNimiqTV5 = 0x8a,
01417 kServiceTypeNimiqTV6 = 0x8d,
01418 kServiceTypeNimiqTV7 = 0x8f,
01419 kServiceTypeNimiqTV8 = 0x90,
01420 kServiceTypeNimiqTV9 = 0x96,
01421
01422 };
01423 uint ServiceType(void) const { return m_serviceid; }
01424 bool IsDTV(void) const
01425 {
01426 return ((ServiceType() == kServiceTypeDigitalTelevision) ||
01427 (ServiceType() ==
01428 kServiceTypeAdvancedCodecSDDigitalTelevision) ||
01429 IsHDTV() ||
01430 (ServiceType() == kServiceTypeEchoStarTV1) ||
01431 (ServiceType() == kServiceTypeEchoStarTV2) ||
01432 (ServiceType() == kServiceTypeEchoStarTV3) ||
01433 (ServiceType() == kServiceTypeEchoStarTV4) ||
01434 (ServiceType() == kServiceTypeNimiqTV1) ||
01435 (ServiceType() == kServiceTypeNimiqTV2) ||
01436 (ServiceType() == kServiceTypeNimiqTV3) ||
01437 (ServiceType() == kServiceTypeNimiqTV4) ||
01438 (ServiceType() == kServiceTypeNimiqTV5) ||
01439 (ServiceType() == kServiceTypeNimiqTV6) ||
01440 (ServiceType() == kServiceTypeNimiqTV7) ||
01441 (ServiceType() == kServiceTypeNimiqTV8) ||
01442 (ServiceType() == kServiceTypeNimiqTV9));
01443 }
01444 bool IsDigitalAudio(void) const
01445 {
01446 return ((ServiceType() == kServiceTypeDigitalRadioSound) ||
01447 (ServiceType() == kServiceTypeAdvancedCodecDigitalRadioSound));
01448 }
01449 bool IsHDTV(void) const
01450 {
01451 return
01452 (ServiceType() == kServiceTypeHDTV) ||
01453 (ServiceType() == kServiceTypeAdvancedCodecHDDigitalTelevision) ||
01454 (ServiceType() == kServiceTypeAdvancedCodecFrameCompatiblePlanoStereoscopicHDTelevisionService);
01455 }
01456 bool IsTeletext(void) const
01457 {
01458 return ServiceType() == kServiceTypeDataBroadcast;
01459 }
01460 QString toString(void) const;
01461
01462 private:
01463 uint m_serviceid;
01464 };
01465
01466
01467 class ServiceDescriptor : public MPEGDescriptor
01468 {
01469 public:
01470 ServiceDescriptor(const unsigned char *data, int len = 300) :
01471 MPEGDescriptor(data, len, DescriptorID::service) { }
01472
01473
01474
01475
01476
01477 uint ServiceType(void) const { return _data[2]; }
01478
01479 uint ServiceProviderNameLength(void) const { return _data[3]; }
01480
01481 QString ServiceProviderName(void) const
01482 { return dvb_decode_text(_data + 4, ServiceProviderNameLength()); }
01483 QString ServiceProviderShortName(void) const
01484 {
01485 return dvb_decode_short_name(_data + 4, ServiceProviderNameLength());
01486 }
01487
01488 uint ServiceNameLength(void) const
01489 { return _data[4 + ServiceProviderNameLength()]; }
01490
01491 QString ServiceName(void) const
01492 {
01493 return dvb_decode_text(_data + 5 + ServiceProviderNameLength(),
01494 ServiceNameLength());
01495 }
01496 QString ServiceShortName(void) const
01497 {
01498 return dvb_decode_short_name(_data + 5 + ServiceProviderNameLength(),
01499 ServiceNameLength());
01500 }
01501 bool IsDTV(void) const
01502 { return ServiceDescriptorMapping(ServiceType()).IsDTV(); }
01503 bool IsDigitalAudio(void) const
01504 { return ServiceDescriptorMapping(ServiceType()).IsDigitalAudio(); }
01505 bool IsHDTV(void) const
01506 { return ServiceDescriptorMapping(ServiceType()).IsHDTV(); }
01507 bool IsTeletext(void) const
01508 { return ServiceDescriptorMapping(ServiceType()).IsTeletext(); }
01509
01510 QString toString(void) const
01511 {
01512 return QString("ServiceDescriptor: %1 %2").arg(ServiceName())
01513 .arg(ServiceDescriptorMapping(ServiceType()).toString());
01514 }
01515 };
01516
01517
01518 class ServiceAvailabilityDescriptor : public MPEGDescriptor
01519 {
01520 public:
01521 ServiceAvailabilityDescriptor(const unsigned char *data, int len = 300) :
01522 MPEGDescriptor(data, len, DescriptorID::service_availability) { }
01523
01524
01525
01526
01527
01528
01529
01530 };
01531
01532
01533 class ServiceListDescriptor : public MPEGDescriptor
01534 {
01535 public:
01536 ServiceListDescriptor(const unsigned char *data, int len = 300) :
01537 MPEGDescriptor(data, len, DescriptorID::service_list) { }
01538
01539
01540
01541
01542
01543
01544
01545
01546
01547 uint ServiceCount(void) const { return DescriptorLength() / 3; }
01548
01549 uint ServiceID(uint i) const
01550 { return (_data[2+i*3] << 8) | _data[3+i*3]; }
01551
01552 uint ServiceType(uint i) const { return _data[4+i*3]; }
01553
01554 QString toString(void) const
01555 {
01556 QString str = QString("ServiceListDescriptor: %1 Services\n")
01557 .arg(ServiceCount());
01558 for (uint i=0; i<ServiceCount(); i++)
01559 {
01560 if (i!=0) str.append("\n");
01561 str.append(QString(" Service (%1) Type%2").arg(ServiceID(i))
01562 .arg(ServiceDescriptorMapping(ServiceType(i)).toString()));
01563 }
01564 return str;
01565 }
01566 };
01567
01568
01569 class ServiceMoveDescriptor : public MPEGDescriptor
01570 {
01571 public:
01572 ServiceMoveDescriptor(const unsigned char *data, int len = 300) :
01573 MPEGDescriptor(data, len, DescriptorID::service_move) { }
01574
01575
01576
01577
01578
01579
01580
01581 };
01582
01583
01584 class ShortEventDescriptor : public MPEGDescriptor
01585 {
01586 public:
01587 ShortEventDescriptor(const unsigned char *data, int len = 300) :
01588 MPEGDescriptor(data, len, DescriptorID::short_event) { }
01589
01590
01591
01592
01593
01594 int LanguageKey(void) const
01595 { return iso639_str3_to_key(&_data[2]); }
01596 QString LanguageString(void) const
01597 { return iso639_key_to_str3(LanguageKey()); }
01598 int CanonicalLanguageKey(void) const
01599 { return iso639_key_to_canonical_key(LanguageKey()); }
01600 QString CanonicalLanguageString(void) const
01601 { return iso639_key_to_str3(CanonicalLanguageKey()); }
01602
01603 uint EventNameLength(void) const { return _data[5]; }
01604
01605 QString EventName(void) const
01606 { return dvb_decode_text(&_data[6], _data[5]); }
01607 QString EventShortName(void) const
01608 { return dvb_decode_short_name(&_data[6], _data[5]); }
01609
01610 uint TextLength(void) const { return _data[6 + _data[5]]; }
01611
01612 QString Text(void) const
01613 { return dvb_decode_text(&_data[7 + _data[5]], TextLength()); }
01614
01615
01616 QString EventName(const unsigned char *encoding_override,
01617 uint encoding_length) const
01618 {
01619 return dvb_decode_text(&_data[6], _data[5],
01620 encoding_override, encoding_length);
01621 }
01622
01623 QString Text(const unsigned char *encoding_override,
01624 uint encoding_length) const
01625 {
01626 return dvb_decode_text(&_data[7 + _data[5]], TextLength(),
01627 encoding_override, encoding_length);
01628 }
01629
01630
01631 QString toString(void) const
01632 { return LanguageString() + " : " + EventName() + " : " + Text(); }
01633 };
01634
01635
01636 class ShortSmoothingBufferDescriptor : public MPEGDescriptor
01637 {
01638 public:
01639 ShortSmoothingBufferDescriptor(const unsigned char *data, int len = 300) :
01640 MPEGDescriptor(data, len, DescriptorID::short_smoothing_buffer) { }
01641
01642
01643
01644
01645
01646
01647
01648
01649 };
01650
01651
01654 class StreamIdentifierDescriptor : public MPEGDescriptor
01655 {
01656 public:
01657 StreamIdentifierDescriptor(const unsigned char *data, int len = 300) :
01658 MPEGDescriptor(data, len, DescriptorID::stream_identifier, 1) { }
01659
01660
01661
01662
01663
01664 uint ComponentTag(void) const { return _data[2]; }
01665 QString toString(void) const
01666 {
01667 return QString("Stream Identifier Descriptor (0x52): ComponentTag=0x%1")
01668 .arg(ComponentTag(),1,16);
01669 }
01670 };
01671
01672
01673 class StuffingDescriptor : public MPEGDescriptor
01674 {
01675 public:
01676 StuffingDescriptor(const unsigned char *data, int len = 300) :
01677 MPEGDescriptor(data, len, DescriptorID::dvb_stuffing) { }
01678
01679
01680
01681
01682 QString toString(void) const
01683 {
01684 return QString("Stuffing Descriptor (0x42) length(%1)")
01685 .arg(DescriptorLength());
01686 }
01687 };
01688
01689
01690 class SubtitlingDescriptor : public MPEGDescriptor
01691 {
01692 public:
01693 SubtitlingDescriptor(const unsigned char *data, int len = 300) :
01694 MPEGDescriptor(data, len, DescriptorID::subtitling) { }
01695
01696
01697
01698
01699 uint StreamCount(void) const { return DescriptorLength() >> 3; }
01700
01701
01702
01703 int LanguageKey(uint i) const
01704 { return iso639_str3_to_key(&_data[2 + (i<<3)]); }
01705 QString LanguageString(uint i) const
01706 { return iso639_key_to_str3(LanguageKey(i)); }
01707 int CanonicalLanguageKey(uint i) const
01708 { return iso639_key_to_canonical_key(LanguageKey(i)); }
01709 QString CanonicalLanguageString(uint i) const
01710 { return iso639_key_to_str3(CanonicalLanguageKey(i)); }
01711
01712
01713 uint SubtitleType(uint i) const
01714 { return _data[5 + (i<<3)]; }
01715
01716 uint CompositionPageID(uint i) const
01717 { return (_data[6 + (i<<3)] << 8) | _data[7 + (i<<3)]; }
01718
01719 uint AncillaryPageID(uint i) const
01720 { return (_data[8 + (i<<3)] << 8) | _data[9 + (i<<3)]; }
01721
01722 };
01723
01724
01725 class TelephoneDescriptor : public MPEGDescriptor
01726 {
01727 public:
01728 TelephoneDescriptor(const unsigned char *data, int len = 300) :
01729 MPEGDescriptor(data, len, DescriptorID::telephone) { }
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755 };
01756
01757
01758 class TeletextDescriptor : public MPEGDescriptor
01759 {
01760 public:
01761 TeletextDescriptor(const unsigned char *data, int len = 300) :
01762 MPEGDescriptor(data, len, DescriptorID::teletext) { }
01763
01764
01765
01766
01767 uint StreamCount(void) const { return DescriptorLength() / 5; }
01768
01769
01770
01771
01772 int LanguageKey(uint i) const
01773 { return iso639_str3_to_key(&_data[2 + (i*5)]); }
01774 QString LanguageString(uint i) const
01775 { return iso639_key_to_str3(LanguageKey(i)); }
01776 int CanonicalLanguageKey(uint i) const
01777 { return iso639_key_to_canonical_key(LanguageKey(i)); }
01778 QString CanonicalLanguageString(uint i) const
01779 { return iso639_key_to_str3(CanonicalLanguageKey(i)); }
01780
01781 uint TeletextType(uint i) const
01782 { return _data[5 + (i*5)] >> 3; }
01783
01784 uint TeletextMagazineNum(uint i) const
01785 { return _data[5 + (i*5)] & 0x7; }
01786
01787 uint TeletextPageNum(uint i) const
01788 { return _data[6 + (i*5)]; }
01789
01790 QString toString(void) const;
01791 };
01792
01793
01794 class TimeShiftedEventDescriptor : public MPEGDescriptor
01795 {
01796 public:
01797 TimeShiftedEventDescriptor(const unsigned char *data, int len = 300) :
01798 MPEGDescriptor(data, len, DescriptorID::time_shifted_event) { }
01799
01800
01801
01802
01803
01804
01805 };
01806
01807
01808 class TimeShiftedServiceDescriptor : public MPEGDescriptor
01809 {
01810 public:
01811 TimeShiftedServiceDescriptor(const unsigned char *data, int len = 300) :
01812 MPEGDescriptor(data, len, DescriptorID::dvb_time_shifted_service) { }
01813
01814
01815
01816
01817
01818 };
01819
01820
01821 class TransportStreamDescriptor : public MPEGDescriptor
01822 {
01823 public:
01824 TransportStreamDescriptor(const unsigned char *data, int len = 300) :
01825 MPEGDescriptor(data, len, DescriptorID::transport_stream) { }
01826
01827
01828
01829
01830
01831 QString Data(void) const
01832 { return dvb_decode_text(&_data[2], DescriptorLength()); }
01833 QString toString(void) const
01834 { return QString("TransportStreamDescriptor data(%1)").arg(Data()); }
01835 };
01836
01837
01838 class VBIDataDescriptor : public MPEGDescriptor
01839 {
01840 public:
01841 VBIDataDescriptor(const unsigned char *data, int len = 300) :
01842 MPEGDescriptor(data, len, DescriptorID::vbi_data) { }
01843
01844
01845
01846
01847
01848
01849
01850
01851
01852
01853
01854
01855
01856
01857
01858
01859
01860
01861
01862
01863
01864
01865 };
01866
01867
01868 class VBITeletextDescriptor : public MPEGDescriptor
01869 {
01870 public:
01871 VBITeletextDescriptor(const unsigned char *data, int len = 300) :
01872 MPEGDescriptor(data, len, DescriptorID::vbi_teletext) { }
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882
01883
01884 };
01885
01886
01887 class PartialTransportStreamDescriptor : public MPEGDescriptor
01888 {
01889 public:
01890 PartialTransportStreamDescriptor(const unsigned char *data, int len = 300) :
01891 MPEGDescriptor(data, len, DescriptorID::partial_transport_stream) { }
01892
01893
01894
01895
01896
01897
01898 uint PeakRate(void) const
01899 { return (_data[2] & 0x3f) << 16 | _data[3] | _data[4]; }
01900
01901
01902 uint SmoothRate(void) const
01903 { return (_data[5] & 0x3f) << 16 | _data[6] | _data[7]; }
01904
01905
01906 uint SmoothBuf(void) const { return ((_data[8] & 0x3f) << 8) | _data[9]; }
01907 QString toString(void) const;
01908 };
01909
01910
01911
01912 class AC3Descriptor : public MPEGDescriptor
01913 {
01914 public:
01915 AC3Descriptor(const unsigned char *data, int len = 300) :
01916 MPEGDescriptor(data, len, DescriptorID::ac3) { }
01917
01918
01919
01920
01921
01922 bool HasComponentType(void) const { return _data[2] & 0x80; }
01923
01924 bool HasBSID(void) const { return _data[2] & 0x40; }
01925
01926 bool HasMainID(void) const { return _data[2] & 0x20; }
01927
01928 bool HasASVC(void) const { return _data[2] & 0x10; }
01929
01930
01931
01932 uint ComponentType(void) const { return _data[3]; }
01933
01934
01935 uint BSID(void) const
01936 { return (HasComponentType()) ? _data[4] : _data[3]; }
01937
01938
01939 uint MainID(void) const
01940 {
01941 int offset = 3;
01942 offset += (HasComponentType()) ? 1 : 0;
01943 offset += (HasBSID()) ? 1 : 0;
01944 return _data[offset];
01945 }
01946
01947
01948 uint ASVC(void) const
01949 {
01950 int offset = 3;
01951 offset += (HasComponentType()) ? 1 : 0;
01952 offset += (HasBSID()) ? 1 : 0;
01953 offset += (HasMainID()) ? 1 : 0;
01954 return _data[offset];
01955 }
01956
01957
01958
01959 QString toString(void) const;
01960 };
01961
01962 static QString coderate_inner(uint cr)
01963 {
01964 switch (cr)
01965 {
01966 case 0x0: return "auto";
01967 case 0x1: return "1/2";
01968 case 0x2: return "2/3";
01969 case 0x3: return "3/4";
01970 case 0x4: return "5/6";
01971 case 0x5: return "7/8";
01972 case 0x8: return "8/9";
01973 case 0xf: return "none";
01974 default: return "auto";
01975 }
01976 }
01977
01978 class UKChannelListDescriptor : public MPEGDescriptor
01979 {
01980 public:
01981 UKChannelListDescriptor(const unsigned char *data, int len = 300) :
01982 MPEGDescriptor(data, len, PrivateDescriptorID::dvb_uk_channel_list) { }
01983
01984
01985
01986
01987 uint ChannelCount(void) const { return DescriptorLength() >> 2; }
01988
01989 uint ServiceID(uint i) const
01990 { return (_data[2 + (i<<2)] << 8) | _data[3 + (i<<2)]; }
01991
01992 uint ChannelNumber(uint i) const
01993 { return ((_data[4 + (i<<2)] << 8) | _data[5 + (i<<2)]) & 0x3ff; }
01994
01995 QString toString(void) const;
01996 };
01997
01998
01999 class DVBContentIdentifierDescriptor : public MPEGDescriptor
02000 {
02001 public:
02002 DVBContentIdentifierDescriptor(const unsigned char *data, int len = 300) :
02003 MPEGDescriptor(data, len, DescriptorID::dvb_content_identifier) { }
02004
02005
02006
02007
02008 uint ContentType(void) const { return _data[2] >> 2; }
02009
02010 uint ContentEncoding(void) const { return _data[2] & 0x03; }
02011
02012
02013 QString ContentId(void) const
02014 {
02015 return QString::fromLatin1((const char *)_data+4, _data[3]);
02016 }
02017 };
02018
02019
02020 class DefaultAuthorityDescriptor : public MPEGDescriptor
02021 {
02022 public:
02023 DefaultAuthorityDescriptor(const unsigned char *data, int len = 300) :
02024 MPEGDescriptor(data, len, DescriptorID::default_authority) { }
02025
02026
02027
02028
02029 QString DefaultAuthority(void) const
02030 {
02031 return QString::fromLatin1((const char *)_data+2, _data[1]);
02032 }
02033
02034 QString toString(void) const
02035 {
02036 return QString("DefaultAuthorityDescriptor: Authority(%1)")
02037 .arg(DefaultAuthority());
02038 }
02039 };
02040
02041 #endif