include/lib/dvb/si.h

   1 #ifndef __si_h
   2 #define __si_h
   3
   4 #include <vector>
   5
   6 #define SUPPORT_XML
   7 #include <lib/dvb/esection.h>
   8 #include <lib/base/estring.h>
   9 #include <lib/base/eerror.h>
  10 #include <lib/base/eptrlist.h>
  11 #include <lib/dvb/lowlevel/sdt.h>
  12 #include <lib/dvb/lowlevel/descr.h>
  13 #include <lib/dvb/lowlevel/ca.h>
  14 #include <lib/dvb/lowlevel/pmt.h>
  15 #include <lib/dvb/lowlevel/nit.h>
  16 #include <lib/dvb/lowlevel/eit.h>
  17 #include <lib/dvb/lowlevel/bat.h>
  18
  19 time_t parseDVBtime(__u8 t1, __u8 t2, __u8 t3, __u8 t4, __u8 t5);
  20 int fromBCD(int bcd);
  21 int toBCD(int dec);
  22
  23 class Descriptor
  24 {
  25         int tag;
  26 protected:
  27         int len;
  28 public:
  29         inline Descriptor(descr_gen_t *descr)
  30                 :tag(*((__u8*)descr)), len((__u8)descr->descriptor_length)
  31         {
  32                 len+=2;
  33         };
  34         inline virtual ~Descriptor(){};
  35
  36         static Descriptor *create(descr_gen_t *data, int tsidonid=0);
  37         int Tag() { return tag; }
  38
  39 #ifdef SUPPORT_XML
  40         eString toXML();
  41         /*
  42                 <descriptor>
  43                         <raw>...</raw>
  44                         <parsed>
  45                                 <ComponentDescriptor>
  46                                         ...
  47                                 </ComponentDescriptor>
  48                         </parsed>
  49                 </descriptor>
  50         */
  51   virtual eString toString()=0;
  52 #endif
  53 };
  54
  55 class UnknownDescriptor: public Descriptor
  56 {
  57 public:
  58   __u8 *data;
  59   UnknownDescriptor(descr_gen_t *descr);
  60   ~UnknownDescriptor();
  61   eString toString();
  62   int length() { return len-2; }
  63 };
  64
  65 class ServiceDescriptor: public Descriptor
  66 {
  67 public:
  68   int service_type, tsidonid;
  69   eString service_provider, service_name;
  70   static const int CTag() { return DESCR_SERVICE; }
  71   ServiceDescriptor(sdt_service_desc *descr, int tsidonid);
  72   ~ServiceDescriptor();
  73   eString toString();
  74 };
  75
  76 class CAIdentifierDescriptor: public Descriptor
  77 {
  78 public:
  79   __u16 *CA_system_id;
  80   int CA_system_ids;
  81   CAIdentifierDescriptor(descr_gen_t *descr);
  82   ~CAIdentifierDescriptor();
  83   eString toString();
  84 };
  85
  86 class LinkageDescriptor: public Descriptor
  87 {
  88 public:
  89   int transport_stream_id;
  90   int original_network_id;
  91   int service_id;
  92   int linkage_type;
  93
  94   __u8 *private_data;
  95   int priv_len;
  96
  97   int handover_type;
  98   int origin_type;
  99
 100   int network_id;
 101   int initial_service_id;
 102
 103   LinkageDescriptor(descr_linkage_struct *descr);
 104   ~LinkageDescriptor();
 105   eString toString();
 106 };
 107
 108 class NVODReferenceEntry
 109 {
 110 public:
 111   bool operator==( const NVODReferenceEntry &e )
 112   {
 113     return e.transport_stream_id == transport_stream_id
 114       && e.original_network_id == original_network_id
 115       && e.service_id == service_id;
 116   }
 117   __u16 transport_stream_id, original_network_id, service_id;
 118   NVODReferenceEntry(__u16 transport_stream_id, __u16 original_network_id, __u16 service_id);
 119   ~NVODReferenceEntry();
 120 };
 121
 122 class NVODReferenceDescriptor: public Descriptor
 123 {
 124 public:
 125   NVODReferenceDescriptor(descr_gen_t *descr);
 126   ~NVODReferenceDescriptor();
 127   eString toString();
 128
 129   ePtrList<NVODReferenceEntry> entries;
 130 };
 131
 132 class TimeShiftedServiceDescriptor: public Descriptor
 133 {
 134 public:
 135   int reference_service_id;
 136   TimeShiftedServiceDescriptor(descr_time_shifted_service_struct *descr);
 137   eString toString();
 138 };
 139
 140 class TimeShiftedEventDescriptor: public Descriptor
 141 {
 142 public:
 143   int reference_service_id;
 144   int reference_event_id;
 145   TimeShiftedEventDescriptor(descr_time_shifted_event_struct *descr);
 146   eString toString();
 147 };
 148
 149
 150 class StreamIdentifierDescriptor: public Descriptor
 151 {
 152 public:
 153   int component_tag;
 154   StreamIdentifierDescriptor(descr_stream_identifier_struct *descr);
 155   eString toString();
 156 };
 157
 158 class CADescriptor: public Descriptor
 159 {
 160 public:
 161   __u16 CA_system_ID, CA_PID;
 162   __u8 *data;
 163   CADescriptor(ca_descr_t *descr);
 164   ~CADescriptor();
 165   eString toString();
 166 };
 167
 168 class NetworkNameDescriptor: public Descriptor
 169 {
 170 public:
 171   eString network_name;
 172   NetworkNameDescriptor(descr_gen_t *descr);
 173   ~NetworkNameDescriptor();
 174   eString toString();
 175 };
 176
 177 class CableDeliverySystemDescriptor: public Descriptor
 178 {
 179 public:
 180   __u32 frequency;
 181   int FEC_outer, modulation, symbol_rate, FEC_inner;
 182   CableDeliverySystemDescriptor(descr_cable_delivery_system_struct *descr);
 183   ~CableDeliverySystemDescriptor();
 184   eString toString();
 185 };
 186
 187 class SatelliteDeliverySystemDescriptor: public Descriptor
 188 {
 189 public:
 190   __u32 frequency;
 191   __u16 orbital_position;
 192   int west_east_flag;
 193   int polarisation;
 194   int modulation;
 195   __u32 symbol_rate;
 196   int FEC_inner;
 197   SatelliteDeliverySystemDescriptor(descr_satellite_delivery_system_struct *descr);
 198   ~SatelliteDeliverySystemDescriptor();
 199   eString toString();
 200 };
 201
 202 class TerrestrialDeliverySystemDescriptor: public Descriptor
 203 {
 204 public:
 205   __u32 centre_frequency;
 206   int bandwidth;
 207   int constellation;
 208   int hierarchy_information;
 209   int code_rate_hp_stream;
 210   int code_rate_lp_stream;
 211   int guard_interval;
 212   int transmission_mode;
 213   int other_frequency_flag;
 214   TerrestrialDeliverySystemDescriptor(descr_terrestrial_delivery_system_struct *descr);
 215   ~TerrestrialDeliverySystemDescriptor();
 216   eString toString();
 217 };
 218
 219 class ServiceListDescriptorEntry
 220 {
 221 public:
 222   ServiceListDescriptorEntry(__u16 service_id, __u8 service_type);
 223   ~ServiceListDescriptorEntry();
 224
 225   __u16 service_id;
 226   __u8 service_type;
 227 };
 228
 229 class ServiceListDescriptor: public Descriptor
 230 {
 231 public:
 232   ServiceListDescriptor(descr_gen_t *descr);
 233   ~ServiceListDescriptor();
 234   eString toString();
 235
 236   ePtrList<ServiceListDescriptorEntry> entries;
 237 };
 238
 239 class ShortEventDescriptor: public Descriptor
 240 {
 241 public:
 242         ShortEventDescriptor(descr_gen_t *descr, int tsidonid);
 243         ShortEventDescriptor(): Descriptor((descr_gen_t*)"\x4d") { };
 244         eString toString();
 245         char language_code[3];
 246         eString event_name;
 247         eString text;
 248         int tsidonid;
 249 };
 250
 251 class ISO639LanguageDescriptor: public Descriptor
 252 {
 253 public:
 254         ISO639LanguageDescriptor(descr_gen_t *descr);
 255         eString toString();
 256         char language_code[3];
 257         int audio_type;
 258 };
 259
 260 class AC3Descriptor: public Descriptor
 261 {
 262 public:
 263         AC3Descriptor(descr_gen_t *descr);
 264         eString toString();
 265         int AC3_type, bsid, mainid, asvc;
 266 };
 267
 268 class BouquetNameDescriptor: public Descriptor
 269 {
 270 public:
 271         BouquetNameDescriptor(descr_gen_t *descr);
 272         eString toString();
 273         eString name;
 274 };
 275
 276 class ItemEntry
 277 {
 278 public:
 279         eString item_description;
 280         eString item;
 281         ItemEntry(eString &item_description, eString &item);
 282         ~ItemEntry();
 283 };
 284
 285 class ExtendedEventDescriptor: public Descriptor
 286 {
 287 public:
 288         ExtendedEventDescriptor(descr_gen_t *descr, int tsidonid);
 289         eString toString();
 290         int descriptor_number;
 291         int last_descriptor_number;
 292         char language_code[3];
 293         ePtrList< ItemEntry > items;
 294         eString text;
 295         int tsidonid;
 296 };
 297
 298 class ComponentDescriptor: public Descriptor
 299 {
 300 public:
 301         ComponentDescriptor(descr_component_struct *descr);
 302         eString toString();
 303
 304         int stream_content, component_type, component_tag;
 305         char language_code[3];
 306         eString text;
 307 };
 308
 309 class ContentDescriptor: public Descriptor
 310 {
 311 public:
 312         ContentDescriptor(descr_gen_t *descr);
 313         ePtrList< descr_content_entry_struct > contentList;
 314         eString toString();
 315 };
 316
 317 class LesRadiosDescriptor: public Descriptor
 318 {
 319 public:
 320         LesRadiosDescriptor(descr_lesradios_struct *descr);
 321         eString toString();
 322
 323         int id;
 324         eString name;
 325 };
 326
 327 class MHWDataDescriptor: public Descriptor
 328 {
 329 public:
 330         MHWDataDescriptor(descr_mhw_data_struct *desrc);
 331         eString toString();
 332
 333         char type[8];
 334 };
 335
 336 class ParentalRatingDescriptor: public Descriptor
 337 {
 338 public:
 339         ParentalRatingDescriptor(descr_gen_struct *descr);
 340         eString toString();
 341         std::map< eString, int > entryMap; // Country Code : age
 342 };
 343
 344 class RegistrationDescriptor: public Descriptor
 345 {
 346 public:
 347         RegistrationDescriptor(descr_gen_struct *descr);
 348         eString toString();
 349         char format_identifier[4];
 350         eString additional_identification_info;
 351 };
 352
 353 class PrivateDataSpecifierDescriptor: public Descriptor
 354 {
 355 public:
 356         PrivateDataSpecifierDescriptor(descr_gen_struct *descr);
 357         eString toString();
 358         unsigned long private_data_specifier;
 359 };
 360
 361 class SubtitleEntry
 362 {
 363 public:
 364         SubtitleEntry(__u8 *data);
 365         char language_code[3];
 366         int subtitling_type;
 367         int composition_page_id;
 368         int ancillary_page_id;
 369 };
 370
 371 class SubtitlingDescriptor: public Descriptor
 372 {
 373 public:
 374         SubtitlingDescriptor(descr_gen_struct *descr);
 375         eString toString();
 376         ePtrList<SubtitleEntry> entries;
 377 };
 378
 379 class PATEntry
 380 {
 381 public:
 382         PATEntry(int program_number, int program_map_PID): program_number(program_number), program_map_PID(program_map_PID)
 383         {
 384         }
 385         int program_number;
 386         int program_map_PID;
 387 };
 388
 389 class PAT: public eTable
 390 {
 391 protected:
 392         int data(__u8 *data);
 393 public:
 394         PAT();
 395
 396         PATEntry *searchService(int service_id)
 397         {
 398                 for (ePtrList<PATEntry>::iterator i(entries); i != entries.end(); ++i)
 399                         if (i->program_number==service_id)
 400                                 return *i;
 401                 return 0;
 402         }
 403
 404         int transport_stream_id;
 405         ePtrList<PATEntry> entries;
 406
 407         __u8 *getRAW();
 408 };
 409
 410 class SDTEntry
 411 {
 412 public:
 413         SDTEntry(sdt_descr_t *descr, int tsidonid);
 414         int service_id;
 415         int EIT_schedule_flag;
 416         int EIT_present_following_flag;
 417         int running_status;
 418         int free_CA_mode;
 419         ePtrList< Descriptor > descriptors;
 420 };
 421
 422 class SDT: public eTable
 423 {
 424 protected:
 425         int data(__u8 *data);
 426 public:
 427         enum { typeActual=0, typeOther=1, typeBoth=2 };
 428         SDT(int type=typeActual, int tsid=-1);
 429
 430         int transport_stream_id, original_network_id;
 431         ePtrList<SDTEntry> entries;
 432 };
 433
 434 class PMTEntry
 435 {
 436 public:
 437         PMTEntry(pmt_info_t* info);
 438         int stream_type;
 439         int elementary_PID;
 440         ePtrList< Descriptor > ES_info;
 441 };
 442
 443 class PMT: public eTable
 444 {
 445 protected:
 446         int data(__u8 *data);
 447 public:
 448         PMT(int pid, int service_id, int version=-1);
 449         ~PMT();
 450
 451         int program_number, PCR_PID, pid, version_number;
 452
 453         eTable *createNext();
 454         ePtrList< Descriptor > program_info;
 455         ePtrList<__u8> program_infoPlain;
 456
 457         ePtrList<PMTEntry> streams;
 458         ePtrList<__u8> streamsPlain;
 459
 460         __u8* getRAW();
 461 };
 462
 463 class NITEntry
 464 {
 465 public:
 466         NITEntry(nit_ts_t* ts);
 467
 468         __u16 transport_stream_id, original_network_id;
 469         ePtrList< Descriptor > transport_descriptor;
 470 };
 471
 472 class NIT: public eTable
 473 {
 474 protected:
 475         int data(__u8 *data);
 476 public:
 477         enum
 478         {
 479                 typeActual=0, typeOther
 480         };
 481         NIT(int pid, int type=0);
 482         int network_id;
 483         ePtrList<NITEntry> entries;
 484         ePtrList< Descriptor > network_descriptor;
 485 };
 486
 487 class EITEvent
 488 {
 489 public:
 490         EITEvent(const eit_event_struct *event, int tsidonid);
 491         EITEvent();
 492         int event_id;
 493         time_t start_time;
 494         int duration;
 495         int running_status;
 496         int free_CA_mode;
 497         ePtrList< Descriptor > descriptor;
 498 };
 499
 500 class EIT: public eTable
 501 {
 502 protected:
 503         int data(__u8 *data);
 504 public:
 505         enum
 506         {
 507                 tsActual=0, tsOther, tsFaked
 508         };
 509         enum
 510         {
 511                 typeNowNext=0, typeSchedule
 512         };
 513
 514         EIT(int type, int service_id=-1, int ts=tsActual, int version=-1);
 515         EIT( const EIT* eit );
 516         EIT();
 517         ~EIT();
 518         eTable *createNext();
 519
 520         int type, ts, service_id, version_number, current_next_indicator, transport_stream_id, original_network_id;
 521         ePtrList<EITEvent> events;
 522         ePtrList<__u8> eventsPlain;
 523 };
 524
 525 class TDT: public eTable
 526 {
 527 protected:
 528         int data(__u8 *data);
 529 public:
 530         TDT();
 531
 532         time_t UTC_time;
 533 };
 534
 535 class BATEntry
 536 {
 537 public:
 538         BATEntry(bat_loop_struct *data);
 539         int transport_stream_id, original_network_id;
 540         ePtrList< Descriptor > transport_descriptors;
 541 };
 542
 543 class BAT: public eTable
 544 {
 545 protected:
 546         int data(__u8 *data);
 547 public:
 548         BAT();
 549
 550         int bouquet_id;
 551         ePtrList< Descriptor > bouquet_descriptors;
 552         ePtrList<BATEntry> entries;
 553 };
 554 #endif