Version 0.92vdr-0.92

- The "channel not sync'ed" log message now also lists the card number.
- Now using the EIT services from 'libdtv' (thanks to Rolf Hakenes), which
  provides EPG information for NVOD ("Near Video On Demand") channels.
- Doing some bug fixing on the EPG data (some tv stations apparently have
  their own idea on how to fill in the data...). The level up to which EPG
  bugs are fixed can be controlled with the EPGBugfixLevel parameter in the
  "Setup" menu (see MANUAL for details, and cEventInfo::FixEpgBugs() in eit.c
  for the actual implementation).
- Fixed broken recordings after a driver buffer overflow.
- Fixed the chirping sound after Pause/Play of a DVD (thanks to Andreas
  Schultz).

2 files changed, 2021 insertions, 0 deletions

diff --git a/libdtv/libsi/include/libsi.h b/libdtv/libsi/include/libsi.h
new file mode 100644
index 0000000..3790ae1
--- /dev/null
+++ b/libdtv/libsi/include/libsi.h
@@ -0,0 +1,816 @@
+//////////////////////////////////////////////////////////////
+///                                                        ///
+/// libsi.h: definitions for data structures of libsi      ///
+///                                                        ///
+//////////////////////////////////////////////////////////////
+
+// $Revision: 1.1 $
+// $Date: 2001/06/26 07:18:43 $
+// $Author: kls $
+//
+//   (C) 2001 Rolf Hakenes <hakenes@hippomi.de>, under the GNU GPL.
+//
+// libsi is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// libsi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You may have received a copy of the GNU General Public License
+// along with libsi; see the file COPYING.  If not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+#ifndef LIBSI_H
+#define LIBSI_H
+
+#include <time.h>
+#include <sys/types.h>
+#include <asm/types.h>
+
+
+  /* Program Identifier */
+
+#define PID_PAT               0x00           /* Program Association Table */
+#define PID_BAT               0x01           /* Bouquet Association Table */
+#define PID_CAT               0x01           /* Conditional Access Table */
+#define PID_NIT               0x10           /* Network Information Table */
+#define PID_SDT               0x11           /* Service Description Table */
+#define PID_EIT               0x12           /* Event Information Table */
+#define PID_RST               0x13           /* Running Status Table */
+#define PID_TDT               0x14           /* Time Date Table */
+#define PID_TOT               0x14           /* Time Offset Table */
+#define PID_ST                0x14           /* Stuffing Table */
+                           /* 0x15 - 0x1F */ /* Reserved for future use */
+
+  /* Table Identifier */
+
+#define TID_PAT               0x00           /* Program Association Section */
+#define TID_CAT               0x01           /* Conditional Access Section */
+#define TID_PMT               0x02           /* Conditional Access Section */
+                           /* 0x03 - 0x3F */ /* Reserved for future use */
+#define TID_NIT_ACT           0x40           /* Network Information Section -
+                                                   actual */
+#define TID_NIT_OTH           0x41           /* Network Information Section -
+                                                   other */
+#define TID_SDT_ACT           0x42           /* Service Description Section -
+                                                   actual */
+#define TID_SDT_OTH           0x46           /* Service Description Section -
+                                                   other */
+#define TID_EIT_ACT           0x4E           /* Event Information Section -
+                                                   actual */
+#define TID_EIT_OTH           0x4F           /* Event Information Section -
+                                                   other */
+#define TID_EIT_ACT_SCH       0x50           /* Event Information Section -
+                                                   actual, schedule  */
+#define TID_EIT_OTH_SCH       0x60           /* Event Information Section -
+                                                   other, schedule */
+#define TID_TDT               0x70           /* Time Date Section */
+#define TID_TOT               0x73           /* Time Offset Section */
+#define TID_CA_ECM_0          0x80
+#define TID_CA_ECM_1          0x81
+
+#define TID_BAT               0x01           /* Bouquet Association Section */
+
+#define TID_EIT               0x12           /* Event Information Section */
+#define TID_RST               0x13           /* Running Status Section */
+#define TID_ST                0x14           /* Stuffung Section */
+                           /* 0xFF */        /* Reserved for future use */
+
+  /* Descriptor Identifier */
+
+  /* defined by ISO/IEC 13818-1 */
+
+#define DESCR_VIDEO_STREAM                   0x02
+#define DESCR_AUDIO_STREAM                   0x03
+#define DESCR_HIERARCHY                      0x04
+#define DESCR_REGISTRATION                   0x05
+#define DESCR_DATA_STREAM_ALIGN              0x06
+#define DESCR_TARGET_BACKGRID                0x07
+#define DESCR_VIDEO_WINDOW                   0x08
+#define DESCR_CA                             0x09
+#define DESCR_ISO_639_LANGUAGE               0x0A
+#define DESCR_SYSTEM_CLOCK                   0x0B
+#define DESCR_MULTIPLEX_BUFFER_UTIL          0x0C
+#define DESCR_COPYRIGHT                      0x0D
+#define DESCR_MAXIMUM_BITRATE                0x0E
+#define DESCR_PRIVATE_DATA_IND               0x0F
+#define DESCR_SMOOTHING_BUFFER               0x10
+#define DESCR_STD                            0x11
+#define DESCR_IBP                            0x12
+                                          /* 0x13 - 0x3F */ /* Reserved */
+
+  /* defined by ETSI */
+
+#define DESCR_NW_NAME                        0x40
+#define DESCR_SERVICE_LIST                   0x41
+#define DESCR_STUFFING                       0x42
+#define DESCR_SAT_DEL_SYS                    0x43
+#define DESCR_CABLE_DEL_SYS                  0x44
+#define DESCR_VBI_DATA                       0x45
+#define DESCR_VBI_TELETEXT                   0x46
+#define DESCR_BOUQUET_NAME                   0x47
+#define DESCR_SERVICE                        0x48
+#define DESCR_COUNTRY_AVAIL                  0x49
+#define DESCR_LINKAGE                        0x4A
+#define DESCR_NVOD_REF                       0x4B
+#define DESCR_TIME_SHIFTED_SERVICE           0x4C
+#define DESCR_SHORT_EVENT                    0x4D
+#define DESCR_EXTENDED_EVENT                 0x4E
+#define DESCR_TIME_SHIFTED_EVENT             0x4F
+#define DESCR_COMPONENT                      0x50
+#define DESCR_MOSAIC                         0x51
+#define DESCR_STREAM_ID                      0x52
+#define DESCR_CA_IDENT                       0x53
+#define DESCR_CONTENT                        0x54
+#define DESCR_PARENTAL_RATING                0x55
+#define DESCR_TELETEXT                       0x56
+#define DESCR_TELEPHONE                      0x57
+#define DESCR_LOCAL_TIME_OFF                 0x58
+#define DESCR_SUBTITLING                     0x59
+#define DESCR_TERR_DEL_SYS                   0x5A
+#define DESCR_ML_NW_NAME                     0x5B
+#define DESCR_ML_BQ_NAME                     0x5C
+#define DESCR_ML_SERVICE_NAME                0x5D
+#define DESCR_ML_COMPONENT                   0x5E
+#define DESCR_PRIV_DATA_SPEC                 0x5F
+#define DESCR_SERVICE_MOVE                   0x60
+#define DESCR_SHORT_SMOOTH_BUF               0x61
+#define DESCR_FREQUENCY_LIST                 0x62
+#define DESCR_PARTIAL_TP_STREAM              0x63
+#define DESCR_DATA_BROADCAST                 0x64
+#define DESCR_CA_SYSTEM                      0x65
+#define DESCR_DATA_BROADCAST_ID              0x66
+#define DESCR_TRANSPORT_STREAM               0x67
+#define DESCR_DSNG                           0x68
+#define DESCR_PDC                            0x69
+#define DESCR_AC3                            0x6A
+#define DESCR_ANCILLARY_DATA                 0x6B
+#define DESCR_CELL_LIST                      0x6C
+#define DESCR_CELL_FREQ_LINK                 0x6D
+#define DESCR_ANNOUNCEMENT_SUPPORT           0x6E
+
+
+#define MAX_SECTION_BUFFER 4096
+
+
+/* Strukturen zur Aufnahme der SDT und EIT Informationen */
+
+struct Service {
+   struct NODE          Node;
+   int                  ServiceID;
+   int                  TransportStreamID;
+   int                  OriginalNetworkID;
+   int                  SdtVersion;
+   unsigned short       Status;
+   struct LIST         *Descriptors;
+   struct LIST         *Events;
+};
+
+#define EIT_SCHEDULE_FLAG               0x0001
+#define GetScheduleFlag(x)              ((x)&EIT_SCHEDULE_FLAG)
+#define SetScheduleFlag(x)              ((x)|=EIT_SCHEDULE_FLAG)
+#define EIT_PRESENT_FOLLOWING_FLAG      0x0002
+#define GetPresentFollowing(x)          ((x)&EIT_PRESENT_FOLLOWING_FLAG)
+#define SetPresentFollowing(x)          ((x)|=EIT_PRESENT_FOLLOWING_FLAG)
+#define RUNNING_STATUS_NOT_RUNNING      0x0000
+#define RUNNING_STATUS_AWAITING         0x0004
+#define RUNNING_STATUS_PAUSING          0x0008
+#define RUNNING_STATUS_RUNNING          0x000C
+#define GetRunningStatus(x)             ((x)&RUNNING_STATUS_RUNNING)
+#define SetRunningStatus(x,s)           ((x)|=((s)&RUNNING_STATUS_RUNNING))
+#define FREE_TO_AIR                     0x0000
+#define CONDITIONAL_ACCESS              0x0010
+#define GetConditionalAccess(x)         ((x)&CONDITIONAL_ACCESS)
+#define SetConditionalAccess(x)         ((x)|=CONDITIONAL_ACCESS)
+
+#define CreateService(service, svid, tsid, onid, vers, sta) \
+   do \
+   { \
+      xCreateNode (service, NULL); \
+      service->ServiceID = svid; \
+      service->TransportStreamID = tsid; \
+      service->OriginalNetworkID = onid; \
+      service->SdtVersion = vers; \
+      service->Status = sta; \
+      service->Descriptors = xNewList (NULL); \
+      service->Events = xNewList (NULL); \
+   } while (0)
+
+
+struct Event {
+   struct NODE          Node;
+   int                  EventID;
+   int                  ServiceID;
+   int                  EitVersion;
+   int                  TransportStreamID;
+   int                  OriginalNetworkID;
+   time_t               StartTime;
+   time_t               Duration;
+   unsigned short       Status;
+   struct LIST         *Descriptors;
+};
+
+#define CreateEvent(event, evid, svid, tsid, onid, vers, sta) \
+   do \
+   { \
+      xCreateNode (event, NULL); \
+      event->EventID = evid; \
+      event->ServiceID = svid; \
+      event->TransportStreamID = tsid; \
+      event->OriginalNetworkID = onid; \
+      event->EitVersion = vers; \
+      event->Status = sta; \
+      event->Descriptors = xNewList (NULL); \
+   } while (0)
+
+
+/* Strukturen zur Aufnahme der PAT und PMT Informationen */
+
+struct Program {
+   struct NODE          Node;
+   int                  ProgramID;
+   int                  TransportStreamID;
+   int                  NetworkPID;
+   int                  PatVersion;
+   struct LIST         *Pids;
+};
+
+#define CreateProgram(program, pgid, tsid, npid, vers) \
+   do \
+   { \
+      xCreateNode (program, NULL); \
+      program->ProgramID = pgid; \
+      program->TransportStreamID = tsid; \
+      program->NetworkPID = npid; \
+      program->PatVersion = vers; \
+      program->Pids = xNewList (NULL); \
+   } while (0)
+
+struct Pid {
+   struct NODE          Node;
+   int                  ProgramID;
+   int                  PcrPID;
+   int                  PmtVersion;
+   struct LIST         *Descriptors;
+   struct LIST         *InfoList;
+};
+
+#define CreatePid(pid, pgid, pcid, vers) \
+   do \
+   { \
+      xCreateNode (pid, NULL); \
+      pid->ProgramID = pgid; \
+      pid->PcrPID = pcid; \
+      pid->PmtVersion = vers; \
+      pid->Descriptors = xNewList (NULL); \
+      pid->InfoList = xNewList (NULL); \
+   } while (0)
+
+struct PidInfo {
+   struct NODE          Node;
+   int                  StreamType;
+   int                  ElementaryPid;
+   struct LIST         *Descriptors;
+};
+
+#define CreatePidInfo(pidinfo, styp, epid) \
+   do \
+   { \
+      xCreateNode (pidinfo, NULL); \
+      pidinfo->StreamType = styp; \
+      pidinfo->ElementaryPid = epid; \
+      pidinfo->Descriptors = xNewList (NULL); \
+   } while (0)
+
+
+#define STREAMTYPE_ISO_VIDEO                     1
+#define STREAMTYPE_13818_VIDEO                   2
+#define STREAMTYPE_11172_AUDIO                   3
+#define STREAMTYPE_13818_AUDIO                   4
+#define STREAMTYPE_VIDEOTEXT                     6
+#define STREAMTYPE_13522_MPEG                    7
+#define STREAMTYPE_ITU_222                       8
+#define STREAMTYPE_13818_A                       9
+#define STREAMTYPE_13818_B                      10
+#define STREAMTYPE_13818_C                      11
+#define STREAMTYPE_13818_D                      12
+#define STREAMTYPE_13818_AUX                    13
+
+/* Descriptors */
+
+#define DescriptorTag(x) ((struct Descriptor *)(x))->Tag
+
+struct Descriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+};
+
+
+/* Iso639LanguageDescriptor */
+
+struct Iso639LanguageDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   char                 LanguageCode[4];
+};
+
+#define CreateIso639LanguageDescriptor(descr, lc1, lc2, lc3) \
+   do \
+   { \
+      xCreateNode (((struct Iso639LanguageDescriptor *)descr), NULL); \
+      ((struct Iso639LanguageDescriptor *)descr)->Tag = DESCR_ISO_639_LANGUAGE; \
+      ((struct Iso639LanguageDescriptor *)descr)->LanguageCode[0] = lc1; \
+      ((struct Iso639LanguageDescriptor *)descr)->LanguageCode[1] = lc2; \
+      ((struct Iso639LanguageDescriptor *)descr)->LanguageCode[2] = lc3; \
+      ((struct Iso639LanguageDescriptor *)descr)->LanguageCode[3] = '\0'; \
+   } while (0)
+
+
+/* AncillaryDataDescriptor */
+
+struct AncillaryDataDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   unsigned short       Identifier;
+};
+
+#define ANCILLARY_DATA_DVD_VIDEO            0x0001
+#define ANCILLARY_DATA_EXTENDED             0x0002
+#define ANCILLARY_DATA_SWITCHING            0x0004
+#define ANCILLARY_DATA_DAB                  0x0008
+#define ANCILLARY_DATA_SCALE_FACTOR         0x0010
+
+#define CreateAncillaryDataDescriptor(descr, id) \
+   do \
+   { \
+      xCreateNode (((struct AncillaryDataDescriptor *)descr), NULL); \
+      ((struct AncillaryDataDescriptor *)descr)->Tag = DESCR_ANCILLARY_DATA; \
+      ((struct AncillaryDataDescriptor *)descr)->Identifier = id; \
+   } while (0)
+
+
+/* BouquetNameDescriptor */
+
+struct BouquetNameDescriptor {
+   struct NODE          Node;    /* Node enthält Namen */
+   unsigned short       Tag;
+};
+
+#define CreateBouquetNameDescriptor(descr, text) \
+   do \
+   { \
+      xCreateNode (((struct BouquetNameDescriptor *)descr), text); \
+      ((struct BouquetNameDescriptor *)descr)->Tag = DESCR_BOUQUET_NAME; \
+   } while (0)
+
+
+/* CountryAvailabilityDescriptor */
+
+struct CountryAvailabilityDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   unsigned short       AvailibilityFlag;
+   unsigned short       Amount;           /* CountryCodes */
+   char                *CountryCodes;
+};
+
+#define COUNTRIES_ARE_AVAILABLE   0x0001
+#define COUNTRIES_ARE_UNAVAILABLE 0x0000
+
+#define CreateCountryAvailabilityDescriptor(descr, ava) \
+   do \
+   { \
+      xCreateNode (((struct CountryAvailabilityDescriptor *)descr), NULL); \
+      ((struct CountryAvailabilityDescriptor *)descr)->Tag = DESCR_COUNTRY_AVAIL; \
+      ((struct CountryAvailabilityDescriptor *)descr)->AvailibilityFlag = ava; \
+      ((struct CountryAvailabilityDescriptor *)descr)->Amount = 0; \
+      ((struct CountryAvailabilityDescriptor *)descr)->CountryCodes = NULL; \
+   } while (0)
+
+#define AddCountryAvailabilityCode(descr, lc1, lc2, lc3) \
+   do \
+   { \
+      char tmpbuf[4], *tmpptr, *ttptr; \
+      \
+      tmpbuf[0] = lc1; tmpbuf[1] = lc2; \
+      tmpbuf[2] = lc3; tmpbuf[3] = '\0'; \
+      xMemAlloc (((struct CountryAvailabilityDescriptor *)descr)->Amount*4 + 8, &tmpptr); \
+      ttptr = tmpptr; \
+      if (((struct CountryAvailabilityDescriptor *)descr)->CountryCodes) { \
+         memcpy (ttptr, ((struct CountryAvailabilityDescriptor *)descr)->CountryCodes, \
+                        ((struct CountryAvailabilityDescriptor *)descr)->Amount*4); \
+         ttptr += ((struct CountryAvailabilityDescriptor *)descr)->Amount*4; \
+      } \
+      memcpy (ttptr, tmpbuf, 4); \
+      ((struct CountryAvailabilityDescriptor *)descr)->CountryCodes = tmpptr; \
+   } while (0)
+
+
+/* CaIdentifierDescriptor */
+
+struct CaIdentifierDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   unsigned short       Amount;           /* SystemIDs */
+   unsigned short      *SystemID;
+};
+
+#define CreateCaIdentifierDescriptor(descr, amo) \
+   do \
+   { \
+      xCreateNode (((struct CaIdentifierDescriptor *)descr), NULL); \
+      ((struct CaIdentifierDescriptor *)descr)->Tag = DESCR_CA_IDENT; \
+      ((struct CaIdentifierDescriptor *)descr)->Amount = amo; \
+      xMemAlloc (amo*2+2, &((struct CaIdentifierDescriptor *)descr)->SystemID); \
+   } while (0)
+
+#define SetCaIdentifierID(descr, num, id) \
+      ((struct CaIdentifierDescriptor *)descr)->SystemID[num] = id
+#define GetCaIdentifierID(descr, num) (((struct CaIdentifierDescriptor *)descr)->SystemID[num])
+
+
+/* StreamIdentifierDescriptor */
+
+struct StreamIdentifierDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   unsigned short       ComponentTag;
+};
+
+#define CreateStreamIdentifierDescriptor(descr, ctag) \
+   do \
+   { \
+      xCreateNode (((struct StreamIdentifierDescriptor *)descr), NULL); \
+      ((struct StreamIdentifierDescriptor *)descr)->Tag = DESCR_STREAM_ID; \
+      ((struct StreamIdentifierDescriptor *)descr)->ComponentTag = (ctag); \
+   } while (0)
+
+
+/* DataBroadcastDescriptor */
+
+struct DataBroadcastDescriptor {
+   struct NODE          Node;          /* Node enthält DescriptorText */
+   unsigned short       Tag;
+   unsigned short       DataBroadcastID;
+   unsigned short       ComponentTag;
+   unsigned short       SelectorLength;
+   unsigned char       *SelectorBytes;
+   char                 LanguageCode[4];
+};
+
+struct MosaicDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   /* to be defined */
+};
+
+struct MultiLingualServiceDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   /* to be defined */
+};
+
+
+/* NvodReferenceDescriptor */
+
+struct NvodReferenceDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   struct LIST         *Items;
+};
+
+#define CreateNvodReferenceDescriptor(descr) \
+   do \
+   { \
+      xCreateNode (((struct NvodReferenceDescriptor *)descr), NULL); \
+      ((struct NvodReferenceDescriptor *)descr)->Tag = DESCR_NVOD_REF; \
+      ((struct NvodReferenceDescriptor *)descr)->Items = xNewList (NULL); \
+   } while (0)
+
+struct NvodReferenceItem {
+   struct NODE          Node;
+   int                  TransportStreamID;
+   int                  OriginalNetworkID;
+   int                  ServiceID;
+};
+
+#define CreateNvodReferenceItem(itm, tpid, onid, svid) \
+   do \
+   { \
+      xCreateNode (itm, NULL); \
+      itm->TransportStreamID = tpid; \
+      itm->OriginalNetworkID = onid; \
+      itm->ServiceID = svid; \
+   } while (0)
+
+#define AddNvodReferenceItem(desc, tpid, onid, svid) \
+   do \
+   { \
+      struct NvodReferenceItem *item; \
+      \
+      CreateNvodReferenceItem(item, tpid, onid, svid); \
+      xAddTail (((struct NvodReferenceDescriptor *)desc)->Items, item); \
+   } while (0)
+
+
+/* LinkageDescriptor */
+
+struct LinkageDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   int                  TransportStreamID;
+   int                  OriginalNetworkID;
+   int                  ServiceID;
+   int                  LinkageType;
+   int                  PrivateDataLength;
+   unsigned char       *PrivateData;
+};
+
+#define CreateLinkageDescriptor(descr, tpid, onid, svid, ltyp, pdl, pdp) \
+   do \
+   { \
+      xCreateNode (((struct LinkageDescriptor *)descr), NULL); \
+      ((struct LinkageDescriptor *)descr)->Tag = DESCR_LINKAGE; \
+      ((struct LinkageDescriptor *)descr)->TransportStreamID = tpid; \
+      ((struct LinkageDescriptor *)descr)->OriginalNetworkID = onid; \
+      ((struct LinkageDescriptor *)descr)->ServiceID = svid; \
+      ((struct LinkageDescriptor *)descr)->LinkageType = ltyp; \
+      ((struct LinkageDescriptor *)descr)->PrivateDataLength = pdl; \
+      xMemAlloc ((pdl)+1, &(((struct LinkageDescriptor *) \
+         descr)->PrivateData)); \
+      memcpy ((((struct LinkageDescriptor *)descr)->PrivateData),(pdp),(pdl));\
+   } while (0)
+
+
+/* ServiceDescriptor */
+
+struct ServiceDescriptor {
+   struct NODE          Node;      /* Node enthält ServiceName */
+   unsigned short       Tag;
+   unsigned short       ServiceType;
+   char                *ServiceProvider;
+};
+
+#define CreateServiceDescriptor(descr, styp, prov, name) \
+   do \
+   { \
+      xCreateNode (((struct ServiceDescriptor *)descr), name); \
+      ((struct ServiceDescriptor *)descr)->Tag = DESCR_SERVICE; \
+      ((struct ServiceDescriptor *)descr)->ServiceType = styp; \
+      ((struct ServiceDescriptor *)descr)->ServiceProvider = prov; \
+   } while (0)
+
+
+
+struct TelephoneDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   /* to be defined */
+};
+
+
+/* TimeShiftedServiceDescriptor */
+
+struct TimeShiftedServiceDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   int                  ReferenceServiceID;
+};
+
+#define CreateTimeShiftedServiceDescriptor(descr, svid) \
+   do \
+   { \
+      xCreateNode (((struct TimeShiftedServiceDescriptor *)descr), NULL); \
+      ((struct TimeShiftedServiceDescriptor *)descr)->Tag = DESCR_TIME_SHIFTED_SERVICE; \
+      ((struct TimeShiftedServiceDescriptor *)descr)->ReferenceServiceID = svid; \
+   } while (0)
+
+
+/* TimeShiftedEventDescriptor */
+
+struct TimeShiftedEventDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   int                  ReferenceServiceID;
+   int                  ReferenceEventID;
+};
+
+#define CreateTimeShiftedEventDescriptor(descr, svid, evid) \
+   do \
+   { \
+      xCreateNode (((struct TimeShiftedEventDescriptor *)descr), NULL); \
+      ((struct TimeShiftedEventDescriptor *)descr)->Tag = DESCR_TIME_SHIFTED_EVENT; \
+      ((struct TimeShiftedEventDescriptor *)descr)->ReferenceServiceID = svid; \
+      ((struct TimeShiftedEventDescriptor *)descr)->ReferenceEventID = evid; \
+   } while (0)
+
+
+/* ComponentDescriptor */
+
+struct ComponentDescriptor {
+   struct NODE          Node;   /* Node enthält ComponentText */
+   unsigned short       Tag;
+   unsigned short       StreamContent;
+   unsigned short       ComponentType;
+   unsigned short       ComponentTag;
+   char                 LanguageCode[4];
+};
+
+#define CreateComponentDescriptor(descr, scnt, ctyp, tag, lc1, lc2, lc3, txt) \
+   do \
+   { \
+      xCreateNode (((struct ComponentDescriptor *)descr), txt); \
+      ((struct ComponentDescriptor *)descr)->Tag = DESCR_COMPONENT; \
+      ((struct ComponentDescriptor *)descr)->StreamContent = scnt; \
+      ((struct ComponentDescriptor *)descr)->ComponentType = ctyp; \
+      ((struct ComponentDescriptor *)descr)->ComponentTag = tag; \
+      ((struct ComponentDescriptor *)descr)->LanguageCode[0] = lc1; \
+      ((struct ComponentDescriptor *)descr)->LanguageCode[1] = lc2; \
+      ((struct ComponentDescriptor *)descr)->LanguageCode[2] = lc3; \
+      ((struct ComponentDescriptor *)descr)->LanguageCode[3] = '\0'; \
+   } while (0)
+
+
+/* ContentDescriptor */
+
+struct ContentDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   unsigned short       Amount;        /* ContentIDs */
+   unsigned short      *ContentID;
+};
+
+#define CreateContentDescriptor(descr, amo) \
+   do \
+   { \
+      xCreateNode (((struct ContentDescriptor *)descr), NULL); \
+      ((struct ContentDescriptor *)descr)->Tag = DESCR_CONTENT; \
+      ((struct ContentDescriptor *)descr)->Amount = amo; \
+      xMemAlloc (amo*2+2, &((struct ContentDescriptor *)descr)->ContentID); \
+   } while (0)
+
+#define SetContentID(descr, num, cnib1, cnib2, unib1, unib2) \
+   do \
+   { \
+      ((struct ContentDescriptor *)descr)->ContentID[num] = \
+         ((cnib1&0xF) << 12) | ((cnib2&0xF) << 8) | \
+         ((unib1&0xF) << 4) | (unib2&0xF); \
+   } while (0)
+#define GetContentContentNibble1(descr, num) ((((struct ContentDescriptor *)descr)->ContentID[num]&0xF000) >> 12)
+#define GetContentContentNibble2(descr, num) ((((struct ContentDescriptor *)descr)->ContentID[num]&0x0F00) >> 8)
+#define GetContentUserNibble1(descr, num) ((((struct ContentDescriptor *)descr)->ContentID[num]&0x00F0) >> 4)
+#define GetContentUserNibble2(descr, num) (((struct ContentDescriptor *)descr)->ContentID[num]&0x000F)
+
+
+/* ExtendedEventDescriptor */
+
+struct ExtendedEventDescriptor {
+   struct NODE          Node;    /* Node enthält EventText */
+   unsigned short       Tag;
+   unsigned short       DescriptorNumber;
+   unsigned short       LastDescriptorNumber;
+   char                 LanguageCode[4];
+   struct LIST         *Items;
+};
+
+#define CreateExtendedEventDescriptor(descr, dnum, ldnb, lc1, lc2, lc3, text) \
+   do \
+   { \
+      xCreateNode (((struct ExtendedEventDescriptor *)descr), text); \
+      ((struct ExtendedEventDescriptor *)descr)->Tag = DESCR_EXTENDED_EVENT; \
+      ((struct ExtendedEventDescriptor *)descr)->DescriptorNumber = dnum; \
+      ((struct ExtendedEventDescriptor *)descr)->LastDescriptorNumber = ldnb; \
+      ((struct ExtendedEventDescriptor *)descr)->LanguageCode[0] = lc1; \
+      ((struct ExtendedEventDescriptor *)descr)->LanguageCode[1] = lc2; \
+      ((struct ExtendedEventDescriptor *)descr)->LanguageCode[2] = lc3; \
+      ((struct ExtendedEventDescriptor *)descr)->LanguageCode[3] = '\0'; \
+      ((struct ExtendedEventDescriptor *)descr)->Items = xNewList (NULL); \
+   } while (0)
+
+struct ExtendedEventItem {
+   struct NODE          Node;    /* Node enthält ItemDescription Text */
+   char                *Text;
+};
+
+#define CreateExtendedEventItem(itm, dtxt, text) \
+   do \
+   { \
+      xCreateNode (itm, dtxt); \
+      itm->Text = text; \
+   } while (0)
+
+#define AddExtendedEventItem(desc, dtxt, text) \
+   do \
+   { \
+      struct ExtendedEventItem *item; \
+      \
+      CreateExtendedEventItem(item, dtxt, text); \
+      xAddTail (((struct ExtendedEventDescriptor *)desc)->Items, item); \
+   } while (0)
+
+
+/* ParentalRatingDescriptor */
+
+struct ParentalRatingDescriptor {
+   struct NODE          Node;
+   unsigned short       Tag;
+   struct LIST         *Ratings;
+};
+
+#define CreateParentalRatingDescriptor(descr) \
+   do \
+   { \
+      xCreateNode (((struct ParentalRatingDescriptor *)descr), NULL); \
+      ((struct ParentalRatingDescriptor *)descr)->Tag = DESCR_PARENTAL_RATING; \
+      ((struct ParentalRatingDescriptor *)descr)->Ratings = xNewList (NULL); \
+   } while (0)
+
+struct ParentalRating {
+   struct NODE          Node;    /* Node enthält ItemDescription Text */
+   char                 LanguageCode[4];
+   char                 Rating;
+};
+
+#define CreateParentalRating(rat, lc1, lc2, lc3, val) \
+   do \
+   { \
+      xCreateNode (rat, NULL); \
+      rat->LanguageCode[0] = lc1; \
+      rat->LanguageCode[1] = lc2; \
+      rat->LanguageCode[2] = lc3; \
+      rat->LanguageCode[3] = '\0'; \
+      rat->Rating = val; \
+   } while (0)
+
+#define AddParentalRating(desc, lc1, lc2, lc3, val) \
+   do \
+   { \
+      struct ParentalRating *item; \
+      \
+      CreateParentalRating(item, lc1, lc2, lc3, val); \
+      xAddTail (((struct ParentalRatingDescriptor *)desc)->Ratings, item); \
+   } while (0)
+
+/* ShortEventDescriptor */
+
+struct ShortEventDescriptor {
+   struct NODE          Node;    /* Node enthält EventName */
+   unsigned short       Tag;
+   char                 LanguageCode[4];
+   char                *Text;
+};
+
+#define CreateShortEventDescriptor(descr, name, lc1, lc2, lc3, text) \
+   do \
+   { \
+      xCreateNode (((struct ShortEventDescriptor *)descr), name); \
+      ((struct ShortEventDescriptor *)descr)->Tag = DESCR_SHORT_EVENT; \
+      ((struct ShortEventDescriptor *)descr)->LanguageCode[0] = lc1; \
+      ((struct ShortEventDescriptor *)descr)->LanguageCode[1] = lc2; \
+      ((struct ShortEventDescriptor *)descr)->LanguageCode[2] = lc3; \
+      ((struct ShortEventDescriptor *)descr)->LanguageCode[3] = '\0'; \
+      ((struct ShortEventDescriptor *)descr)->Text = text; \
+   } while (0)
+
+
+
+/* Prototypes */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* si_parser.c */
+
+struct LIST *siParsePAT (u_char *);
+struct Pid *siParsePMT (u_char *);
+struct LIST *siParseSDT (u_char *);
+struct LIST *siParseEIT (u_char *);
+time_t siParseTDT (u_char *);
+void siParseDescriptors (struct LIST *, u_char *, u_int, u_char);
+void siParseDescriptor (struct LIST *, u_char *);
+char *siGetDescriptorText (u_char *, u_int);
+u_long crc32 (char *data, int len);
+
+/* si_debug_services.c */
+
+void siDebugServices (struct LIST *);
+void siDebugService (struct Service *);
+void siDebugEvents (char *, struct LIST *);
+void siDebugPrograms (char *, struct LIST *);
+void siDebugProgram (struct Program *);
+void siDebugPids (char *, struct LIST *);
+void siDebugDescriptors (char *, struct LIST *);
+void siDebugEitServices (struct LIST *);
+void siDebugEitEvents (char *, struct LIST *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libdtv/libsi/include/si_tables.h b/libdtv/libsi/include/si_tables.h
new file mode 100644
index 0000000..517838a
--- /dev/null
+++ b/libdtv/libsi/include/si_tables.h
@@ -0,0 +1,1205 @@
+//////////////////////////////////////////////////////////////
+///                                                        ///
+/// si_tables.h: definitions for data structures of the    ///
+///              incoming SI data stream                   ///
+///                                                        ///
+//////////////////////////////////////////////////////////////
+
+// $Revision: 1.1 $
+// $Date: 2001/06/25 12:41:20 $
+// $Author: kls $
+//
+//   (C) 2001 Rolf Hakenes <hakenes@hippomi.de>, under the GNU GPL.
+//
+// libsi is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// libsi is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You may have received a copy of the GNU General Public License
+// along with libsi; see the file COPYING.  If not, write to the
+// Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+#ifndef SI_TABLES_H
+#define SI_TABLES_H
+
+#define HILO(x) (x##_hi << 8 | x##_lo)
+
+#define MjdToEpochTime(x) (((x##_hi << 8 | x##_lo)-40587)*86400)
+#define BcdTimeToSeconds(x) ((3600 * ((10*((x##_h & 0xF0)>>4)) + (x##_h & 0xF))) + \
+                             (60 * ((10*((x##_m & 0xF0)>>4)) + (x##_m & 0xF))) + \
+                             ((10*((x##_s & 0xF0)>>4)) + (x##_s & 0xF)))
+
+#define TableHasMoreSections(x) (((pat_t *)(x))->last_section_number > ((pat_t *)(x))->section_number)
+#define GetTableId(x) ((pat_t *)(x))->table_id
+#define GetSectionNumber(x) ((pat_t *)(x))->section_number
+#define GetLastSectionNumber(x) ((pat_t *)(x))->last_section_number
+#define GetServiceId(x) (((eit_t *)(x))->service_id_hi << 8) | ((eit_t *)(x))->service_id_lo
+
+/*
+ *
+ *    ETSI ISO/IEC 13818-1 specifies SI which is referred to as PSI. The PSI
+ *    data provides information to enable automatic configuration of the
+ *    receiver to demultiplex and decode the various streams of programs
+ *    within the multiplex. The PSI data is structured as four types of table.
+ *    The tables are transmitted in sections.
+ *
+ *    1) Program Association Table (PAT):
+ *
+ *       - for each service in the multiplex, the PAT indicates the location
+ *         (the Packet Identifier (PID) values of the Transport Stream (TS)
+ *         packets) of the corresponding Program Map Table (PMT).
+ *         It also gives the location of the Network Information Table (NIT).
+ *
+ */
+
+#define PAT_LEN 8
+
+typedef struct {
+   u_char table_id                               :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1;
+   u_char dummy                                  :1;        // has to be 0
+   u_char                                        :2;
+   u_char section_length_hi                      :4;
+#else
+   u_char section_length_hi                      :4;
+   u_char                                        :2;
+   u_char dummy                                  :1;        // has to be 0
+   u_char section_syntax_indicator               :1;
+#endif
+   u_char section_length_lo                      :8;
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :2;
+   u_char version_number                         :5;
+   u_char current_next_indicator                 :1;
+#else
+   u_char current_next_indicator                 :1;
+   u_char version_number                         :5;
+   u_char                                        :2;
+#endif
+   u_char section_number                         :8;
+   u_char last_section_number                    :8;
+} pat_t;
+
+#define PAT_PROG_LEN 4
+
+typedef struct {
+   u_char program_number_hi                      :8;
+   u_char program_number_lo                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :3;
+   u_char network_pid_hi                         :5;
+#else
+   u_char network_pid_hi                         :5;
+   u_char                                        :3;
+#endif
+   u_char network_pid_lo                         :8; 
+   /* or program_map_pid (if prog_num=0)*/
+} pat_prog_t;
+
+/*
+ *
+ *    2) Conditional Access Table (CAT):
+ *
+ *       - the CAT provides information on the CA systems used in the
+ *         multiplex; the information is private and dependent on the CA
+ *         system, but includes the location of the EMM stream, when
+ *         applicable.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    3) Program Map Table (PMT):
+ *
+ *       - the PMT identifies and indicates the locations of the streams that
+ *         make up each service, and the location of the Program Clock
+ *         Reference fields for a service.
+ *
+ */
+
+#define PMT_LEN 12
+
+typedef struct {
+   u_char table_id                               :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1;
+   u_char dummy                                  :1; // has to be 0
+   u_char                                        :2;
+   u_char section_length_hi                      :4;
+#else
+   u_char section_length_hi                      :4;
+   u_char                                        :2;
+   u_char dummy                                  :1; // has to be 0
+   u_char section_syntax_indicator               :1;
+#endif
+   u_char section_length_lo                      :8;
+   u_char program_number_hi                      :8;
+   u_char program_number_lo                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :2;
+   u_char version_number                         :5;
+   u_char current_next_indicator                 :1;
+#else
+   u_char current_next_indicator                 :1;
+   u_char version_number                         :5;
+   u_char                                        :2;
+#endif
+   u_char section_number                         :8;
+   u_char last_section_number                    :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :3;
+   u_char PCR_PID_hi                             :5;
+#else
+   u_char PCR_PID_hi                             :5;
+   u_char                                        :3;
+#endif
+   u_char PCR_PID_lo                             :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4;
+   u_char program_info_length_hi                 :4;
+#else
+   u_char program_info_length_hi                 :4;
+   u_char                                        :4;
+#endif
+   u_char program_info_length_lo                 :8;
+   //descriptors
+} pmt_t;
+
+#define PMT_INFO_LEN 5
+
+typedef struct {
+   u_char stream_type                            :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :3;
+   u_char elementary_PID_hi                      :5;
+#else
+   u_char elementary_PID_hi                      :5;
+   u_char                                        :3;
+#endif
+   u_char elementary_PID_lo                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4;
+   u_char ES_info_length_hi                      :4;
+#else
+   u_char ES_info_length_hi                      :4;
+   u_char                                        :4;
+#endif
+   u_char ES_info_length_lo                      :8;
+   // descriptors
+} pmt_info_t;
+
+/*
+ *
+ *    4) Network Information Table (NIT):
+ *
+ *       - the NIT is intended to provide information about the physical
+ *         network. The syntax and semantics of the NIT are defined in
+ *         ETSI EN 300 468.
+ *
+ */
+
+#define NIT_LEN 10 
+
+typedef struct { 
+   u_char table_id                               :8; 
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1; 
+   u_char                                        :3; 
+   u_char section_length_hi                      :4; 
+#else 
+   u_char section_length_hi                      :4; 
+   u_char                                        :3; 
+   u_char section_syntax_indicator               :1; 
+#endif
+   u_char section_length_lo                      :8; 
+   u_char network_id_hi                          :8; 
+   u_char network_id_lo                          :8; 
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :2; 
+   u_char version_number                         :5; 
+   u_char current_next_indicator                 :1; 
+#else
+   u_char current_next_indicator                 :1; 
+   u_char version_number                         :5; 
+   u_char                                        :2; 
+#endif
+   u_char section_number                         :8; 
+   u_char last_section_number                    :8; 
+#if BYTE_ORDER == BIG_ENDIAN 
+   u_char                                        :4; 
+   u_char network_descriptor_length_hi           :4; 
+#else
+   u_char network_descriptor_length_hi           :4; 
+   u_char                                        :4; 
+#endif
+   u_char network_descriptor_length_lo           :8; 
+  /* descriptors */
+} nit_t; 
+ 
+#define SIZE_NIT_MID 2 
+
+typedef struct {                                 // after descriptors 
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4; 
+   u_char transport_stream_loop_length_hi        :4; 
+#else
+   u_char transport_stream_loop_length_hi        :4; 
+   u_char                                        :4; 
+#endif
+   u_char transport_stream_loop_length_lo        :8; 
+} nit_mid_t; 
+ 
+#define SIZE_NIT_END 4 
+
+struct nit_end_struct { 
+   long CRC; 
+}; 
+ 
+#define NIT_TS_LEN 6 
+
+typedef struct { 
+   u_char transport_stream_id_hi                 :8; 
+   u_char transport_stream_id_lo                 :8; 
+   u_char original_network_id_hi                 :8; 
+   u_char original_network_id_lo                 :8; 
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4; 
+   u_char transport_descriptors_length_hi        :4; 
+#else  
+   u_char transport_descriptors_length_hi        :4; 
+   u_char                                        :4; 
+#endif
+   u_char transport_descriptors_length_lo        :8; 
+   /* descriptors  */
+} nit_ts_t;
+
+/*
+ *
+ *    In addition to the PSI, data is needed to provide identification of
+ *    services and events for the user. In contrast with the PAT, CAT, and
+ *    PMT of the PSI, which give information only for the multiplex in which
+ *    they are contained (the actual multiplex), the additional information
+ *    defined within the present document can also provide information on
+ *    services and events carried by different multiplexes, and even on other
+ *    networks. This data is structured as nine tables:
+ *
+ *    1) Bouquet Association Table (BAT):
+ *
+ *       - the BAT provides information regarding bouquets. As well as giving
+ *         the name of the bouquet, it provides a list of services for each
+ *         bouquet.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    2) Service Description Table (SDT):
+ *
+ *       - the SDT contains data describing the services in the system e.g.
+ *         names of services, the service provider, etc.
+ *
+ */
+
+#define SDT_LEN 11
+
+typedef struct {
+   u_char table_id                               :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1;
+   u_char                                        :3;
+   u_char section_length_hi                      :4;
+#else
+   u_char section_length_hi                      :4;
+   u_char                                        :3;
+   u_char section_syntax_indicator               :1;
+#endif
+   u_char section_length_lo                      :8;
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :2;
+   u_char version_number                         :5;
+   u_char current_next_indicator                 :1;
+#else
+   u_char current_next_indicator                 :1;
+   u_char version_number                         :5;
+   u_char                                        :2;
+#endif
+   u_char section_number                         :8;
+   u_char last_section_number                    :8;
+   u_char original_network_id_hi                 :8;
+   u_char original_network_id_lo                 :8;
+   u_char                                        :8;
+} sdt_t;
+
+#define SDT_DESCR_LEN 5
+
+typedef struct {
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :6;
+   u_char eit_schedule_flag                      :1;
+   u_char eit_present_following_flag             :1;
+   u_char running_status                         :3;
+   u_char free_ca_mode                           :1;
+   u_char descriptors_loop_length_hi             :4;
+#else
+   u_char eit_present_following_flag             :1;
+   u_char eit_schedule_flag                      :1;
+   u_char                                        :6;
+   u_char descriptors_loop_length_hi             :4;
+   u_char free_ca_mode                           :1;
+   u_char running_status                         :3;
+#endif
+   u_char descriptors_loop_length_lo             :8;
+} sdt_descr_t;
+
+/*
+ *
+ *    3) Event Information Table (EIT):
+ * 
+ *       - the EIT contains data concerning events or programmes such as event
+ *         name, start time, duration, etc.; - the use of different descriptors
+ *         allows the transmission of different kinds of event information e.g.
+ *         for different service types.
+ *
+ */
+
+#define EIT_LEN 14
+
+typedef struct {
+   u_char table_id                               :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1;
+   u_char                                        :3;
+   u_char section_length_hi                      :4;
+#else
+   u_char section_length_hi                      :4;
+   u_char                                        :3;
+   u_char section_syntax_indicator               :1;
+#endif
+   u_char section_length_lo                      :8;
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :2;
+   u_char version_number                         :5;
+   u_char current_next_indicator                 :1;
+#else
+   u_char current_next_indicator                 :1;
+   u_char version_number                         :5;
+   u_char                                        :2;
+#endif
+   u_char section_number                         :8;
+   u_char last_section_number                    :8;
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+   u_char original_network_id_hi                 :8;
+   u_char original_network_id_lo                 :8;
+   u_char segment_last_section_number            :8;
+   u_char segment_last_table_id                  :8;
+} eit_t;
+
+#define EIT_EVENT_LEN 12
+
+typedef struct {
+   u_char event_id_hi                            :8;
+   u_char event_id_lo                            :8;
+   u_char mjd_hi                                 :8;
+   u_char mjd_lo                                 :8;
+   u_char start_time_h                           :8;
+   u_char start_time_m                           :8;
+   u_char start_time_s                           :8;
+   u_char duration_h                             :8;
+   u_char duration_m                             :8;
+   u_char duration_s                             :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char running_status                         :3;
+   u_char free_ca_mode                           :1;
+   u_char descriptors_loop_length_hi             :4;
+#else
+   u_char descriptors_loop_length_hi             :4;
+   u_char free_ca_mode                           :1;
+   u_char running_status                         :3;
+#endif
+   u_char descriptors_loop_length_lo             :8;
+} eit_event_t;
+
+/*
+ *
+ *    4) Running Status Table (RST):
+ *
+ *       - the RST gives the status of an event (running/not running). The RST
+ *         updates this information and allows timely automatic switching to
+ *         events.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    5) Time and Date Table (TDT):
+ *
+ *       - the TDT gives information relating to the present time and date.
+ *         This information is given in a separate table due to the frequent
+ *         updating of this information.
+ *
+ */
+
+#define TDT_LEN 8
+
+typedef struct {
+   u_char table_id                               :8; 
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char section_syntax_indicator               :1;
+   u_char                                        :3;
+   u_char section_length_hi                      :4;
+#else
+   u_char section_length_hi                      :4;
+   u_char                                        :3;
+   u_char section_syntax_indicator               :1;
+#endif
+   u_char section_length_lo                      :8;
+   u_char utc_mjd_hi                             :8;
+   u_char utc_mjd_lo                             :8;
+   u_char utc_time_h                             :8;
+   u_char utc_time_m                             :8;
+   u_char utc_time_s                             :8;
+} tdt_t;
+
+/*
+ *
+ *    6) Time Offset Table (TOT):
+ *
+ *       - the TOT gives information relating to the present time and date and
+ *         local time offset. This information is given in a separate table due
+ *         to the frequent updating of the time information.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    7) Stuffing Table (ST):
+ *
+ *       - the ST is used to invalidate existing sections, for example at
+ *         delivery system boundaries.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    8) Selection Information Table (SIT):
+ *
+ *       - the SIT is used only in "partial" (i.e. recorded) bitstreams. It
+ *         carries a summary of the SI information required to describe the
+ *         streams in the partial bitstream.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    9) Discontinuity Information Table (DIT):
+ *
+ *       - the DIT is used only in "partial" (i.e. recorded) bitstreams.
+ *         It is inserted where the SI information in the partial bitstream may
+ *         be discontinuous. Where applicable the use of descriptors allows a
+ *         flexible approach to the organization of the tables and allows for
+ *         future compatible extensions.
+ *
+ */
+    /* TO BE DONE */
+/*
+ *
+ *    The following describes the different descriptors that can be used within
+ *    the SI.
+ *
+ *    The following semantics apply to all the descriptors defined in this
+ *    subclause:
+ *
+ *    descriptor_tag: The descriptor tag is an 8-bit field which identifies
+ *                    each descriptor. Those values with MPEG-2 normative
+ *                    meaning are described in ISO/IEC 13818-1. The values of
+ *                    descriptor_tag are defined in 'libsi.h'
+ *    descriptor_length: The descriptor length is an 8-bit field specifying the
+ *                       total number of bytes of the data portion of the
+ *                       descriptor following the byte defining the value of
+ *                       this field.
+ *
+ */
+
+#define DESCR_GEN_LEN 2
+typedef struct descr_gen_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_gen_t;
+#define CastGenericDescriptor(x) ((descr_gen_t *)(x))
+
+#define GetDescriptorTag(x) (((descr_gen_t *) x)->descriptor_tag)
+#define GetDescriptorLength(x) (((descr_gen_t *) x)->descriptor_length+DESCR_GEN_LEN)
+
+
+/* 0x0A iso_639_language_descriptor */
+
+#define DESCR_ISO_639_LANGUAGE_LEN 5
+typedef struct descr_iso_639_language_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+} descr_iso_639_language_t;
+#define CastIso639LanguageDescriptor(x) ((descr_iso_639_language_t *)(x))
+
+
+/* 0x40 network_name_descriptor */
+
+#define DESCR_NETWORK_NAME_LEN XX
+typedef struct descr_network_name_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_network_name_t;
+#define CastNetworkNameDescriptor(x) ((descr_network_name_t *)(x))
+
+
+/* 0x41 service_list_descriptor */
+
+#define DESCR_SERVICE_LIST_LEN XX
+typedef struct descr_service_list_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_service_list_t;
+#define CastServiceListDescriptor(x) ((descr_service_list_t *)(x))
+
+
+/* 0x42 stuffing_descriptor */
+
+#define DESCR_STUFFING_LEN XX
+typedef struct descr_stuffing_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_stuffing_t;
+#define CastStuffingDescriptor(x) ((descr_stuffing_t *)(x))
+
+
+/* 0x43 satellite_delivery_system_descriptor */
+
+#define DESCR_SATELLITE_DELIVERY_SYSTEM_LEN 13
+typedef struct descr_satellite_delivery_system_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char frequency1                             :8;
+   u_char frequency2                             :8;
+   u_char frequency3                             :8;
+   u_char frequency4                             :8;
+   u_char orbital_position1                      :8;
+   u_char orbital_position2                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char modulation                             :5;
+   u_char polarization                           :2;
+   u_char west_east_flag                         :1;
+#else
+   u_char west_east_flag                         :1;
+   u_char polarization                           :2;
+   u_char modulation                             :5;
+#endif
+   u_char symbol_rate1                           :8;
+   u_char symbol_rate2                           :8;
+   u_char symbol_rate3                           :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char symbol_rate4                           :4;
+   u_char fec_inner                              :4;
+#else
+   u_char fec_inner                              :4;
+   u_char symbol_rate4                           :4;
+#endif
+} descr_satellite_delivery_system_t;
+#define CastSatelliteDeliverySystemDescriptor(x) ((descr_satellite_delivery_system_t *)(x))
+
+
+/* 0x44 cable_delivery_system_descriptor */
+
+#define DESCR_CABLE_DELIVERY_SYSTEM_LEN 13
+typedef struct descr_cable_delivery_system_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char frequency1                             :8;
+   u_char frequency2                             :8;
+   u_char frequency3                             :8;
+   u_char frequency4                             :8;
+   u_char reserved1                              :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char reserved2                              :4;
+   u_char fec_outer                              :4;
+#else
+   u_char fec_outer                              :4;
+   u_char reserved2                              :4;
+#endif
+   u_char modulation                             :8;
+   u_char symbol_rate1                           :8;
+   u_char symbol_rate2                           :8;
+   u_char symbol_rate3                           :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char symbol_rate4                           :4;
+   u_char fec_inner                              :4;
+#else
+   u_char fec_inner                              :4;
+   u_char symbol_rate4                           :4;
+#endif
+} descr_cable_delivery_system_t;
+#define CastCableDeliverySystemDescriptor(x) ((descr_cable_delivery_system_t *)(x))
+
+
+/* 0x45 vbi_data_descriptor */
+
+#define DESCR_VBI_DATA_LEN XX
+typedef struct descr_vbi_data_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_vbi_data_t;
+#define CastVbiDataDescriptor(x) ((descr_vbi_data_t *)(x))
+
+
+/* 0x46 vbi_teletext_descriptor */
+
+#define DESCR_VBI_TELETEXT_LEN XX
+typedef struct descr_vbi_teletext_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_vbi_teletext_t;
+#define CastVbiDescriptor(x) ((descr_vbi_teletext_t *)(x))
+
+
+/* 0x47 bouquet_name_descriptor */
+
+#define DESCR_BOUQUET_NAME_LEN 2
+typedef struct descr_bouquet_name_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_bouquet_name_t;
+#define CastBouquetNameDescriptor(x) ((descr_bouquet_name_t *)(x))
+
+
+/* 0x48 service_descriptor */
+
+#define DESCR_SERVICE_LEN  4
+typedef struct descr_service_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char service_type                           :8;
+   u_char provider_name_length                   :8;
+} descr_service_t;
+#define CastServiceDescriptor(x) ((descr_service_t *)(x))
+
+
+/* 0x49 country_availability_descriptor */
+
+#define DESCR_COUNTRY_AVAILABILITY_LEN 3
+typedef struct descr_country_availability_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char country_availability_flag              :1;
+   u_char reserved                               :7;
+#else
+   u_char reserved                               :7;
+   u_char country_availability_flag              :1;
+#endif
+} descr_country_availability_t;
+#define CastCountryAvailabilityDescriptor(x) ((descr_country_availability_t *)(x))
+
+
+/* 0x4A linkage_descriptor */
+
+#define DESCR_LINKAGE_LEN 9
+typedef struct descr_linkage_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+   u_char original_network_id_hi                 :8; 
+   u_char original_network_id_lo                 :8; 
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+   u_char linkage_type                           :8;
+} descr_linkage_t;
+#define CastLinkageDescriptor(x) ((descr_linkage_t *)(x))
+
+
+/* 0x4B nvod_reference_descriptor */
+
+#define DESCR_NVOD_REFERENCE_LEN 2
+typedef struct descr_nvod_reference_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_nvod_reference_t;
+#define CastNvodReferenceDescriptor(x) ((descr_nvod_reference_t *)(x))
+
+#define ITEM_NVOD_REFERENCE_LEN 6
+typedef struct item_nvod_reference_struct {
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+   u_char original_network_id_hi                 :8; 
+   u_char original_network_id_lo                 :8; 
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+} item_nvod_reference_t;
+#define CastNvodReferenceItem(x) ((item_nvod_reference_t *)(x))
+
+
+
+/* 0x4C time_shifted_service_descriptor */
+
+#define DESCR_TIME_SHIFTED_SERVICE_LEN 4
+typedef struct descr_time_shifted_service_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char reference_service_id_hi                :8;
+   u_char reference_service_id_lo                :8;
+} descr_time_shifted_service_t;
+#define CastTimeShiftedServiceDescriptor(x) ((descr_time_shifted_service_t *)(x))
+
+
+/* 0x4D short_event_descriptor */
+
+#define DESCR_SHORT_EVENT_LEN 6
+typedef struct descr_short_event_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char event_name_length                      :8;
+} descr_short_event_t;
+#define CastShortEventDescriptor(x) ((descr_short_event_t *)(x))
+
+
+/* 0x4E extended_event_descriptor */
+
+#define DESCR_EXTENDED_EVENT_LEN 7
+typedef struct descr_extended_event_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char descriptor_number                      :4;
+   u_char last_descriptor_number                 :4;
+#else
+   u_char last_descriptor_number                 :4;
+   u_char descriptor_number                      :4;
+#endif
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char length_of_items                        :8;
+} descr_extended_event_t;
+#define CastExtendedEventDescriptor(x) ((descr_extended_event_t *)(x))
+
+#define ITEM_EXTENDED_EVENT_LEN 1
+typedef struct item_extended_event_struct {
+   u_char item_description_length               :8;
+} item_extended_event_t;
+#define CastExtendedEventItem(x) ((item_extended_event_t *)(x))
+
+
+/* 0x4F time_shifted_event_descriptor */
+
+#define DESCR_TIME_SHIFTED_EVENT_LEN 6
+typedef struct descr_time_shifted_event_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char reference_service_id_hi                :8;
+   u_char reference_service_id_lo                :8;
+   u_char reference_event_id_hi                  :8;
+   u_char reference_event_id_lo                  :8;
+} descr_time_shifted_event_t;
+#define CastTimeShiftedEventDescriptor(x) ((descr_time_shifted_event_t *)(x))
+
+
+/* 0x50 component_descriptor */
+
+#define DESCR_COMPONENT_LEN  8
+typedef struct descr_component_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char reserved                               :4;
+   u_char stream_content                         :4;
+#else
+   u_char stream_content                         :4;
+   u_char reserved                               :4;
+#endif
+   u_char component_type                         :8;
+   u_char component_tag                          :8;
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+} descr_component_t;
+#define CastComponentDescriptor(x) ((descr_component_t *)(x))
+
+
+/* 0x51 mosaic_descriptor */
+
+#define DESCR_MOSAIC_LEN XX
+typedef struct descr_mosaic_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_mosaic_t;
+#define CastMosaicDescriptor(x) ((descr_mosaic_t *)(x))
+
+
+/* 0x52 stream_identifier_descriptor */
+
+#define DESCR_STREAM_IDENTIFIER_LEN 3
+typedef struct descr_stream_identifier_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char component_tag                          :8;
+} descr_stream_identifier_t;
+#define CastStreamIdentifierDescriptor(x) ((descr_stream_identifier_t *)(x))
+
+
+/* 0x53 ca_identifier_descriptor */
+
+#define DESCR_CA_IDENTIFIER_LEN 2
+typedef struct descr_ca_identifier_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_ca_identifier_t;
+#define CastCaIdentifierDescriptor(x) ((descr_ca_identifier_t *)(x))
+
+
+/* 0x54 content_descriptor */
+
+#define DESCR_CONTENT_LEN 2
+typedef struct descr_content_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_content_t;
+#define CastContentDescriptor(x) ((descr_content_t *)(x))
+
+typedef struct nibble_content_struct {
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char content_nibble_level_1                 :4;
+   u_char content_nibble_level_2                 :4;
+   u_char user_nibble_1                          :4;
+   u_char user_nibble_2                          :4;
+#else
+   u_char user_nibble_2                          :4;
+   u_char user_nibble_1                          :4;
+   u_char content_nibble_level_2                 :4;
+   u_char content_nibble_level_1                 :4;
+#endif
+} nibble_content_t;
+#define CastContentNibble(x) ((nibble_content_t *)(x))
+
+
+/* 0x55 parental_rating_descriptor */
+
+#define DESCR_PARENTAL_RATING_LEN 2
+typedef struct descr_parental_rating_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+} descr_parental_rating_t;
+#define CastParentalRatingDescriptor(x) ((descr_parental_rating_t *)(x))
+
+#define PARENTAL_RATING_LEN 4
+typedef struct parental_rating_struct {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char rating                                 :8;
+} parental_rating_t;
+#define CastParentalRating(x) ((parental_rating_t *)(x))
+
+
+/* 0x56 teletext_descriptor */
+
+#define DESCR_TELETEXT_LEN XX
+typedef struct descr_teletext_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_teletext_t;
+#define CastTeletextDescriptor(x) ((descr_teletext_t *)(x))
+
+
+/* 0x57 telephone_descriptor */
+
+#define DESCR_TELEPHONE_LEN XX
+typedef struct descr_telephone_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_telephone_t;
+#define CastTelephoneDescriptor(x) ((descr_telephone_t *)(x))
+
+
+/* 0x58 local_time_offset_descriptor */
+
+#define DESCR_LOCAL_TIME_OFFSET_LEN XX
+typedef struct descr_local_time_offset_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_local_time_offset_t;
+#define CastLocalTimeOffsetDescriptor(x) ((descr_local_time_offset_t *)(x))
+
+
+/* 0x59 subtitling_descriptor */
+
+#define DESCR_SUBTITLING_LEN XX
+typedef struct descr_subtitling_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_subtitling_t;
+#define CastSubtitlingDescriptor(x) ((descr_subtitling_t *)(x))
+
+
+/* 0x5A terrestrial_delivery_system_descriptor */
+
+#define DESCR_TERRESTRIAL_DELIVERY_SYSTEM_LEN XX
+typedef struct descr_terrestrial_delivery_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_terrestrial_delivery_system_t;
+#define CastTerrestrialDeliverySystemDescriptor(x) ((descr_terrestrial_delivery_system_t *)(x))
+
+
+/* 0x5B multilingual_network_name_descriptor */
+
+#define DESCR_MULTILINGUAL_NETWORK_NAME_LEN XX
+typedef struct descr_multilingual_network_name_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_multilingual_network_name_t;
+#define CastMultilingualNetworkNameDescriptor(x) ((descr_multilingual_network_name_t *)(x))
+
+
+/* 0x5C multilingual_bouquet_name_descriptor */
+
+#define DESCR_MULTILINGUAL_BOUQUET_NAME_LEN XX
+typedef struct descr_multilingual_bouquet_name_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_multilingual_bouquet_name_t;
+#define CastMultilingualBouquetNameDescriptor(x) ((descr_multilingual_bouquet_name_t *)(x))
+
+
+/* 0x5D multilingual_service_name_descriptor */
+
+#define DESCR_MULTILINGUAL_SERVICE_NAME_LEN XX
+typedef struct descr_multilingual_service_name_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_multilingual_service_name_t;
+#define CastMultilingualServiceNameDescriptor(x) ((descr_multilingual_service_name_t *)(x))
+
+
+/* 0x5E multilingual_component_descriptor */
+
+#define DESCR_MULTILINGUAL_COMPONENT_LEN XX
+typedef struct descr_multilingual_component_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_multilingual_component_t;
+#define CastMultilingualComponentDescriptor(x) ((descr_multilingual_component_t *)(x))
+
+
+/* 0x5F private_data_specifier_descriptor */
+
+#define DESCR_PRIVATE_DATA_SPECIFIER_LEN XX
+typedef struct descr_private_data_specifier_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_private_data_specifier_t;
+#define CastPrivateDataSpecifierDescriptor(x) ((descr_private_data_specifier_t *)(x))
+
+
+/* 0x60 service_move_descriptor */
+
+#define DESCR_SERVICE_MOVE_LEN XX
+typedef struct descr_service_move_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_service_move_t;
+#define CastServiceMoveDescriptor(x) ((descr_service_move_t *)(x))
+
+
+/* 0x61 short_smoothing_buffer_descriptor */
+
+#define DESCR_SHORT_SMOOTHING_BUFFER_LEN XX
+typedef struct descr_short_smoothing_buffer_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_short_smoothing_buffer_t;
+#define CastShortSmoothingBufferDescriptor(x) ((descr_short_smoothing_buffer_t *)(x))
+
+
+/* 0x62 frequency_list_descriptor */
+
+#define DESCR_FREQUENCY_LIST_LEN XX
+typedef struct descr_frequency_list_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_frequency_list_t;
+#define CastFrequencyListDescriptor(x) ((descr_frequency_list_t *)(x))
+
+
+/* 0x63 partial_transport_stream_descriptor */
+
+#define DESCR_PARTIAL_TRANSPORT_STREAM_LEN XX
+typedef struct descr_partial_transport_stream_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_partial_transport_stream_t;
+#define CastPartialDescriptor(x) ((descr_partial_transport_stream_t *)(x))
+
+
+/* 0x64 data_broadcast_descriptor */
+
+#define DESCR_DATA_BROADCAST_LEN XX
+typedef struct descr_data_broadcast_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_data_broadcast_t;
+#define CastDataBroadcastDescriptor(x) ((descr_data_broadcast_t *)(x))
+
+
+/* 0x65 ca_system_descriptor */
+
+#define DESCR_CA_SYSTEM_LEN XX
+typedef struct descr_ca_system_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_ca_system_t;
+#define CastCaSystemDescriptor(x) ((descr_ca_system_t *)(x))
+
+
+/* 0x66 data_broadcast_id_descriptor */
+
+#define DESCR_DATA_BROADCAST_ID_LEN XX
+typedef struct descr_data_broadcast_id_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_data_broadcast_id_t;
+#define CastDataBroadcastIdDescriptor(x) ((descr_data_broadcast_id_t *)(x))
+
+
+/* 0x67 transport_stream_descriptor */
+
+#define DESCR_TRANSPORT_STREAM_LEN XX
+typedef struct descr_transport_stream_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_transport_stream_t;
+#define CastTransportStreamDescriptor(x) ((descr_transport_stream_t *)(x))
+
+
+/* 0x68 dsng_descriptor */
+
+#define DESCR_DSNG_LEN XX
+typedef struct descr_dsng_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_dsng_t;
+#define CastDsngDescriptor(x) ((descr_dsng_t *)(x))
+
+
+/* 0x69 pdc_descriptor */
+
+#define DESCR_PDC_LEN XX
+typedef struct descr_pdc_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_pdc_t;
+#define CastPdcDescriptor(x) ((descr_pdc_t *)(x))
+
+
+/* 0x6A ac3_descriptor */
+
+#define DESCR_AC3_LEN XX
+typedef struct descr_ac3_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_ac3_t;
+#define CastAc3Descriptor(x) ((descr_ac3_t *)(x))
+
+
+/* 0x6B ancillary_data_descriptor */
+
+#define DESCR_ANCILLARY_DATA_LEN 3
+typedef struct descr_ancillary_data_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char ancillary_data_identifier              :8;
+} descr_ancillary_data_t;
+#define CastAncillaryDataDescriptor(x) ((descr_ancillary_data_t *)(x))
+
+
+/* 0x6C cell_list_descriptor */
+
+#define DESCR_CELL_LIST_LEN XX
+typedef struct descr_cell_list_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_cell_list_t;
+#define CastCellListDescriptor(x) ((descr_cell_list_t *)(x))
+
+
+/* 0x6D cell_frequency_link_descriptor */
+
+#define DESCR_CELL_FREQUENCY_LINK_LEN XX
+typedef struct descr_cell_frequency_link_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_cell_frequency_link_t;
+#define CastCellFrequencyLinkDescriptor(x) ((descr_cell_frequency_link_t *)(x))
+
+
+/* 0x6E announcement_support_descriptor */
+
+#define DESCR_ANNOUNCEMENT_SUPPORT_LEN XX
+typedef struct descr_announcement_support_struct {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+} descr_announcement_support_t;
+#define CastAnnouncementSupportDescriptor(x) ((descr_announcement_support_t *)(x))
+
+#endif