Version 1.3.0vdr-1.3.0

- Changed thread handling to make it work with NPTL ("Native Posix Thread Library").
  Thanks to Jon Burgess, Andreas Schultz, Werner Fink and Stefan Huelswitt.
- The cThread class now accepts a 'Description' parameter, which is used to log
  the beginning and end of the thread, together with its process and thread id.
  For descriptions that need additional parameters you can use the function
  cThread::SetDescription(), which accepts 'printf()' like arguments.
  Existing plugins that use threads should be changed to use this functionality
  instead of explicit 'dsyslog()' calls inside their Action() function in order
  to support logging the thread ids.
- Added "Slovak Link" and "Czech Link" to 'ca.conf' (thanks to Emil Petersky).
  However, 'ca.conf' is now pretty much obsolete due to the automatic CA handling.
- Mutexes are now created with PTHREAD_MUTEX_ERRORCHECK_NP, which makes the
  'lockingTid' stuff obsolete (thanks to Stefan Huelswitt).
- Changed font handling to allow language specific character sets.
- Adopted the small font character set from the "Elchi" patch (originally
  provided by Alessio Sangalli).
- Greek language texts now use iso8859-7 character set (thanks to Dimitrios
  Dimitrakos).
- Rearranged section data handling, so that the actual data handling can be done
  separately, even from within plugins.
- The EPG data structures have been moved from eit.[hc] to epg.[hc] and have been
  adapted to the general VDR coding style. Plugins that use these data structures
  may need to change some function names (which should be obvious).
  The name 'subtitle' has been changed to 'shortText' to avoid clashes with actual
  subtitles that are part of a movie. The name 'extendedDescription' has been
  shortened to 'description'.
- Replaced 'libdtv' with 'libsi' (thanks to Marcel Wiesweg), which is thread
  safe and can be used by multiple section filters simultaneously.
- Added 'cRwLock' to 'thread.[hc]'. Note that all plugin Makefiles need to
  define _GNU_SOURCE for this to work (see the example plugin Makefiles and
  'newplugin').
- Fixed a problem with crc32 in SI handling on 64bit systems (thanks to Pedro
  Miguel Sequeira de Justo Teixeira for reporting this one).
- Fixed an alignment problem in CAM access on 64bit systems  (thanks to Pedro
  Miguel Sequeira de Justo Teixeira for reporting this one).
- Added 'StreamType' setting to CAM communication, which is important for
  Aston/SECA CAMs (thanks to Antonino Sergi).
- Now the CA descriptors are sent to the CAM in the 'program' or 'ES level'
  sections, depending on where they are found in the PMT (thanks to Hans-Peter
  Raschke for reporting this one). This should make SkyCrypt CAMs work.
- Now using the 'version number' of EPG events to avoid unnecessary work.
- Channel data is now automatically derived from the DVB data stream (inspired
  by the 'autopid' patch from Andreas Schultz).
- The current channel is now automatically re-tuned if the PIDs or other settings
  change. If a recording is going on on a channel that has a change in its
  settings, the recording will be stopped and immediately restarted to use the
  new channel settings.
- EPG events now use the complete channel ID with NID, TID and SID.
- Channel names in 'channels.conf' can now have a short form, as provided
  by some tv stations (see man vdr(5)). Currently channels that provide short
  names in addition to long ones are listed in the OSD as "short,long name",
  as in "RTL,RTL Television". The short names will be used explicitly later.
- The Ca parameter in 'channels.conf' has been extended and now contains all the
  CA system ids for the given channel. When switching to a channel VDR now tests
  for a device that provides one of these CA system ids. The devices automatically
  get their supported ids from the CI handler.
- The values in 'ca.conf' are currently without any real meaning. Whether or not
  a channel with conditional access can be received is now determined automatically
  by evaluating its CA descriptors and comparing them to the CA system ids
  provided by the installed CAM. Only the special values 1-16 are used to assign
  a channel to a particular device.
- Increased the maximum number of possible OSD colors to 256.
- Limited the line length in the EPG bugfix report, which appears to fix a buffer
  overflow that caused a crash when cleaning up the EPG data (at 05:00 in the
  morning).

11 files changed, 4741 insertions, 0 deletions

diff --git a/libsi/Makefile b/libsi/Makefile
new file mode 100644
index 0000000..613fbee
--- /dev/null
+++ b/libsi/Makefile
@@ -0,0 +1,52 @@
+#
+# Makefile for a libsi
+#
+# $Id: Makefile 1.2 2003/12/13 10:41:39 kls Exp $
+
+### The C++ compiler and options:
+
+CXX      ?= g++
+CXXFLAGS ?= -O2 -g -Wall -Woverloaded-virtual
+AR = ar
+ARFLAGS = ru
+RANLIB = ranlib
+
+### The directory environment:
+
+INCLUDES +=
+
+DEFINES +=
+
+LIBS +=
+
+### The object files (add further files here):
+
+OBJS = util.o si.o section.o descriptor.o
+
+### Implicit rules:
+
+%.o: %.c
+	$(CXX) $(CXXFLAGS) -c $(DEFINES) $(INCLUDES) $<
+
+# Dependencies:
+
+MAKEDEP = g++ -MM -MG
+DEPFILE = .dependencies
+$(DEPFILE): Makefile
+	@$(MAKEDEP) $(DEFINES) $(INCLUDES) $(OBJS:%.o=%.c) > $@
+
+-include $(DEPFILE)
+
+### Targets:
+
+all: libsi.a
+
+libsi.a : $(OBJS)
+	$(AR) $(ARFLAGS) $@ $(OBJS)
+
+clean:
+	@-rm -f $(OBJS) $(DEPFILE) *.a *.so *.tgz core* *~
+
+dist:
+	tar cvzf libsi.tar.gz -C .. libsi/util.c libsi/si.c libsi/section.c libsi/descriptor.c \
+   libsi/util.h libsi/si.h libsi/section.h libsi/descriptor.h libsi/headers.h libsi/Makefile libsi/gendescr.pl
diff --git a/libsi/descriptor.c b/libsi/descriptor.c
new file mode 100644
index 0000000..433d680
--- /dev/null
+++ b/libsi/descriptor.c
@@ -0,0 +1,635 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: descriptor.c 1.2 2003/12/13 10:42:05 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#include <string.h>
+#include "descriptor.h"
+
+namespace SI {
+
+void ShortEventDescriptor::Parse() {
+   unsigned int offset=0;
+   const descr_short_event *s;
+   data.setPointerAndOffset<const descr_short_event>(s, offset);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+   name.setDataAndOffset(data+offset, s->event_name_length, offset);
+   const descr_short_event_mid *mid;
+   data.setPointerAndOffset<const descr_short_event_mid>(mid, offset);
+   text.setData(data+offset, mid->text_length);
+}
+
+int ExtendedEventDescriptor::getDescriptorNumber() {
+   return s->descriptor_number;
+}
+
+int ExtendedEventDescriptor::getLastDescriptorNumber() {
+   return s->last_descriptor_number;
+}
+
+void ExtendedEventDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_extended_event>(s, offset);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+   itemLoop.setDataAndOffset(data+offset, s->length_of_items, offset);
+   const descr_extended_event_mid *mid;
+   data.setPointerAndOffset<const descr_extended_event_mid>(mid, offset);
+   text.setData(data+offset, mid->text_length);
+}
+
+void ExtendedEventDescriptor::Item::Parse() {
+   unsigned int offset=0;
+   const item_extended_event *first;
+   data.setPointerAndOffset<const item_extended_event>(first, offset);
+   itemDescription.setDataAndOffset(data+offset, first->item_description_length, offset);
+   const item_extended_event_mid *mid;
+   data.setPointerAndOffset<const item_extended_event_mid>(mid, offset);
+   item.setData(data+offset, mid->item_length);
+}
+
+int ExtendedEventDescriptors::getTextLength() {
+   int ret=0;
+   for (int i=0;i<length;i++) {
+      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
+      if (!d)
+         continue;
+      ret+=d->text.getLength()+1; //plus a blank
+      ExtendedEventDescriptor::Item item;
+      for (Loop::Iterator it; d->itemLoop.hasNext(it);   ) {
+         item=d->itemLoop.getNext(it);
+         ret+=item.item.getLength();
+         ret+=item.itemDescription.getLength();
+         ret+=2; //the blanks
+      }
+   }
+   return ret;
+}
+
+//is there a case where this function does not return the same as getTextLength?
+int ExtendedEventDescriptors::getMaximumTextLength() {
+   int ret=0;
+   for (int i=0;i<length;i++) {
+      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
+      if (!d)
+         continue;
+      ret+=d->text.getLength()+1; //plus a blank
+      ret+=d->itemLoop.getLength();
+   }
+   return ret;
+}
+
+char *ExtendedEventDescriptors::getText() {
+   char *text=new char[getMaximumTextLength()];
+   return getText(text);
+}
+
+//appends the Strings of every Descriptor in the group
+char *ExtendedEventDescriptors::getText(char *buffer) {
+   int index=0, len;
+   char tempbuf[256];
+   for (int i=0;i<length;i++) {
+      ExtendedEventDescriptor *d=(ExtendedEventDescriptor *)array[i];
+      if (!d)
+         continue;
+      d->text.getText(tempbuf);
+      len=strlen(tempbuf);
+      if (len) {
+         memcpy(buffer+index, tempbuf, len);
+         index+=len;
+      }
+
+      ExtendedEventDescriptor::Item item;
+      for (Loop::Iterator it; d->itemLoop.hasNext(it);   ) {
+         item=d->itemLoop.getNext(it);
+
+         item.item.getText(tempbuf);
+         len=strlen(tempbuf);
+         if (len) {
+            memcpy(buffer+index, tempbuf, len);
+            index+=len;
+         }
+
+         item.itemDescription.getText(tempbuf);
+         len=strlen(tempbuf);
+         if (len) {
+            memcpy(buffer+index, tempbuf, len);
+            index+=len;
+         }
+      }
+   }
+   buffer[index]='\0';
+   return buffer;
+}
+
+int TimeShiftedEventDescriptor::getReferenceServiceId() const {
+   return HILO(s->reference_service_id);
+}
+
+int TimeShiftedEventDescriptor::getReferenceEventId() const {
+   return HILO(s->reference_event_id);
+}
+
+void TimeShiftedEventDescriptor::Parse() {
+   s=data.getData<const descr_time_shifted_event>();
+}
+
+void ContentDescriptor::Parse() {
+   //this descriptor is only a header and a loop
+   nibbleLoop.setData(data+sizeof(SectionHeader), getLength()-sizeof(SectionHeader));
+}
+
+int ContentDescriptor::Nibble::getContentNibbleLevel1() const {
+   return s->content_nibble_level_1;
+}
+
+int ContentDescriptor::Nibble::getContentNibbleLevel2() const {
+   return s->content_nibble_level_2;
+}
+
+int ContentDescriptor::Nibble::getUserNibble1() const {
+   return s->user_nibble_1;
+}
+
+int ContentDescriptor::Nibble::getUserNibble2() const {
+   return s->user_nibble_2;
+}
+
+void ContentDescriptor::Nibble::Parse() {
+   s=data.getData<const nibble_content>();
+}
+
+void ParentalRatingDescriptor::Parse() {
+   //this descriptor is only a header and a loop
+   ratingLoop.setData(data+sizeof(SectionHeader), getLength()-sizeof(SectionHeader));
+}
+
+int ParentalRatingDescriptor::Rating::getRating() const {
+   return s->rating;
+}
+
+void ParentalRatingDescriptor::Rating::Parse() {
+   s=data.getData<const parental_rating>();
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+}
+
+int CaDescriptor::getCaType() const {
+   return HILO(s->CA_type);
+}
+
+int CaDescriptor::getCaPid() const {
+   return HILO(s->CA_PID);
+}
+
+void CaDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_ca>(s, offset);
+   privateData.assign(data.getData(offset), getLength()-offset);
+}
+
+int StreamIdentifierDescriptor::getComponentTag() const {
+   return s->component_tag;
+}
+
+void StreamIdentifierDescriptor::Parse() {
+   s=data.getData<const descr_stream_identifier>();
+}
+
+void NetworkNameDescriptor::Parse() {
+   name.setData(data+sizeof(descr_network_name), getLength()-sizeof(descr_network_name));
+}
+
+void CaIdentifierDescriptor::Parse() {
+   identifiers.setData(data+sizeof(descr_ca_identifier), getLength()-sizeof(descr_ca_identifier));
+}
+
+int CarouselIdentifierDescriptor::getCarouselId() const {
+   return (HILO(s->carousel_id_hi) << 16) | HILO(s->carousel_id_lo);
+}
+
+int CarouselIdentifierDescriptor::getFormatId() const {
+   return s->FormatId;
+}
+
+void CarouselIdentifierDescriptor::Parse() {
+   s=data.getData<const descr_carousel_identifier>();
+}
+
+void ServiceListDescriptor::Parse() {
+   serviceLoop.setData(data+sizeof(descr_service_list), getLength()-sizeof(descr_service_list));
+}
+
+int ServiceListDescriptor::Service::getServiceId() const {
+   return HILO(s->service_id);
+}
+
+int ServiceListDescriptor::Service::getServiceType() const {
+   return s->service_type;
+}
+
+void ServiceListDescriptor::Service::Parse() {
+   s=data.getData<const descr_service_list_loop>();
+}
+
+int SatelliteDeliverySystemDescriptor::getFrequency() const {
+   return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
+}
+
+int SatelliteDeliverySystemDescriptor::getOrbitalPosition() const {
+   return HILO(s->orbital_position);
+}
+
+int SatelliteDeliverySystemDescriptor::getWestEastFlag() const {
+   return s->west_east_flag;
+}
+
+int SatelliteDeliverySystemDescriptor::getPolarization() const {
+   return s->polarization;
+}
+
+int SatelliteDeliverySystemDescriptor::getModulation() const {
+   return s->modulation;
+}
+
+int SatelliteDeliverySystemDescriptor::getSymbolRate() const {
+   return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2;
+}
+
+int SatelliteDeliverySystemDescriptor::getFecInner() const {
+   return s->fec_inner;
+}
+
+void SatelliteDeliverySystemDescriptor::Parse() {
+   s=data.getData<const descr_satellite_delivery_system>();
+}
+
+int CableDeliverySystemDescriptor::getFrequency() const {
+   return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
+}
+
+int CableDeliverySystemDescriptor::getFecOuter() const {
+   return s->fec_outer;
+}
+
+int CableDeliverySystemDescriptor::getModulation() const {
+   return s->modulation;
+}
+
+int CableDeliverySystemDescriptor::getSymbolRate() const {
+   return (HILO(s->symbol_rate_hi) << 12) | (s->symbol_rate_lo_1 << 4) | s->symbol_rate_lo_2;
+}
+
+int CableDeliverySystemDescriptor::getFecInner() const {
+   return s->fec_inner;
+}
+
+void CableDeliverySystemDescriptor::Parse() {
+   s=data.getData<const descr_cable_delivery_system>();
+}
+
+int TerrestrialDeliverySystemDescriptor::getFrequency() const {
+   return (HILO(s->frequency_hi) << 16) | HILO(s->frequency_lo);
+}
+
+int TerrestrialDeliverySystemDescriptor::getBandwidth() const {
+   return s->bandwidth;
+}
+
+int TerrestrialDeliverySystemDescriptor::getConstellation() const {
+   return s->constellation;
+}
+
+int TerrestrialDeliverySystemDescriptor::getHierarchy() const {
+   return s->hierarchy;
+}
+
+int TerrestrialDeliverySystemDescriptor::getCodeRateHP() const {
+   return s->code_rate_HP;
+}
+
+int TerrestrialDeliverySystemDescriptor::getCodeRateLP() const {
+   return s->code_rate_LP;
+}
+
+int TerrestrialDeliverySystemDescriptor::getGuardInterval() const {
+   return s->guard_interval;
+}
+
+int TerrestrialDeliverySystemDescriptor::getTransmissionMode() const {
+   return s->transmission_mode;
+}
+
+bool TerrestrialDeliverySystemDescriptor::getOtherFrequency() const {
+   return s->other_frequency_flag;
+}
+
+void TerrestrialDeliverySystemDescriptor::Parse() {
+   s=data.getData<const descr_terrestrial_delivery>();
+}
+
+int ServiceDescriptor::getServiceType() const {
+   return s->service_type;
+}
+
+void ServiceDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_service>(s, offset);
+   providerName.setDataAndOffset(data+offset, s->provider_name_length, offset);
+   const descr_service_mid *mid;
+   data.setPointerAndOffset<const descr_service_mid>(mid, offset);
+   serviceName.setData(data+offset, mid->service_name_length);
+}
+
+void NVODReferenceDescriptor::Parse() {
+   serviceLoop.setData(data+sizeof(descr_nvod_reference), getLength()-sizeof(descr_nvod_reference));
+}
+
+int NVODReferenceDescriptor::Service::getTransportStream() const {
+   return HILO(s->transport_stream_id);
+}
+
+int NVODReferenceDescriptor::Service::getOriginalNetworkId() const {
+   return HILO(s->original_network_id);
+}
+
+int NVODReferenceDescriptor::Service::getServiceId() const {
+   return HILO(s->service_id);
+}
+
+void NVODReferenceDescriptor::Service::Parse() {
+   s=data.getData<const item_nvod_reference>();
+}
+
+int TimeShiftedServiceDescriptor::getReferenceServiceId() const {
+   return HILO(s->reference_service_id);
+}
+
+void TimeShiftedServiceDescriptor::Parse() {
+   s=data.getData<const descr_time_shifted_service>();
+}
+
+int ComponentDescriptor::getStreamContent() const {
+   return s->stream_content;
+}
+
+int ComponentDescriptor::getComponentType() const {
+   return s->component_type;
+}
+
+int ComponentDescriptor::getComponentTag() const {
+   return s->component_tag;
+}
+
+void ComponentDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_component>(s, offset);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+   description.setData(data+offset, getLength()-offset);
+}
+
+void SubtitlingDescriptor::Parse() {
+   subtitlingLoop.setData(data+sizeof(descr_subtitling), getLength()-sizeof(descr_subtitling));
+}
+
+int SubtitlingDescriptor::Subtitling::getSubtitlingType() const {
+   return s->subtitling_type;
+}
+
+int SubtitlingDescriptor::Subtitling::getCompositionPageId() const {
+   return HILO(s->composition_page_id);
+}
+
+int SubtitlingDescriptor::Subtitling::getAncillaryPageId() const {
+   return HILO(s->ancillary_page_id);
+}
+
+void SubtitlingDescriptor::Subtitling::Parse() {
+   s=data.getData<const item_subtitling>();
+}
+
+int ServiceMoveDescriptor::getNewOriginalNetworkId() const {
+   return HILO(s->new_original_network_id);
+}
+
+int ServiceMoveDescriptor::getNewTransportStreamId() const {
+   return HILO(s->new_transport_stream_id);
+}
+
+int ServiceMoveDescriptor::getNewServiceId() const {
+   return HILO(s->new_service_id);
+}
+
+void ServiceMoveDescriptor::Parse() {
+   s=data.getData<const descr_service_move>();
+}
+
+int FrequencyListDescriptor::getCodingType() const {
+   return s->coding_type;
+}
+
+void FrequencyListDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_frequency_list>(s, offset);
+   frequencies.setData(data+offset, getLength()-offset);
+}
+
+void ServiceIdentifierDescriptor::Parse() {
+   textualServiceIdentifier.setData(data+sizeof(descr_service_identifier), getLength()-sizeof(descr_service_identifier));
+}
+
+void MultilingualNameDescriptor::Parse() {
+   nameLoop.setData(data+sizeof(descr_multilingual_network_name), getLength()-sizeof(descr_multilingual_network_name));
+}
+
+void MultilingualNameDescriptor::Name::Parse() {
+   unsigned int offset=0;
+   const entry_multilingual_name *s;
+   data.setPointerAndOffset<const entry_multilingual_name>(s, offset);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+   name.setData(data+offset, s->text_length);
+}
+
+int MultilingualComponentDescriptor::getComponentTag() const {
+   return s->component_tag;
+}
+
+void MultilingualComponentDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_multilingual_component>(s, offset);
+   nameLoop.setData(data+sizeof(descr_multilingual_component), getLength()-sizeof(descr_multilingual_component));
+}
+
+void MultilingualServiceNameDescriptor::Parse() {
+   nameLoop.setData(data+sizeof(descr_multilingual_network_name), getLength()-sizeof(descr_multilingual_network_name));
+}
+
+void MultilingualServiceNameDescriptor::Name::Parse() {
+   unsigned int offset=0;
+   const entry_multilingual_name *s;
+   data.setPointerAndOffset<const entry_multilingual_name>(s, offset);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+   providerName.setDataAndOffset(data+offset, s->text_length, offset);
+   const entry_multilingual_service_name_mid *mid;
+   data.setPointerAndOffset<const entry_multilingual_service_name_mid>(mid, offset);
+   name.setData(data+offset, mid->service_name_length);
+}
+
+void ApplicationSignallingDescriptor::Parse() {
+   entryLoop.setData(data+sizeof(descr_application_signalling), getLength()-sizeof(descr_application_signalling));
+}
+
+int ApplicationSignallingDescriptor::ApplicationEntryDescriptor::getApplicationType() const {
+   return HILO(s->application_type);
+}
+
+int ApplicationSignallingDescriptor::ApplicationEntryDescriptor::getAITVersionNumber() const {
+   return s->AIT_version_number;
+}
+
+void ApplicationSignallingDescriptor::ApplicationEntryDescriptor::Parse() {
+   s=data.getData<const application_signalling_entry>();
+}
+
+bool MHP_ApplicationDescriptor::isServiceBound() const {
+   return s->service_bound_flag;
+}
+
+int MHP_ApplicationDescriptor::getVisibility() const {
+   return s->visibility;
+}
+
+int MHP_ApplicationDescriptor::getApplicationPriority() const {
+   return s->application_priority;
+}
+
+void MHP_ApplicationDescriptor::Parse() {
+   unsigned int offset=0;
+   const descr_application *dapp;
+   data.setPointerAndOffset<const descr_application>(dapp, offset);
+   profileLoop.setDataAndOffset(data+offset, dapp->application_profiles_length, offset);
+   data.setPointerAndOffset<const descr_application_end>(s, offset);
+   transportProtocolLabels.setData(data+offset, getLength()-offset);
+}
+
+int MHP_ApplicationDescriptor::Profile::getApplicationProfile() const {
+      return HILO(s->application_profile);
+}
+
+int MHP_ApplicationDescriptor::Profile::getVersionMajor() const {
+      return s->version_major;
+}
+
+int MHP_ApplicationDescriptor::Profile::getVersionMinor() const {
+      return s->version_minor;
+}
+
+int MHP_ApplicationDescriptor::Profile::getVersionMicro() const {
+      return s->version_micro;
+}
+
+void MHP_ApplicationDescriptor::Profile::Parse() {
+   s=data.getData<application_profile_entry>();
+}
+
+void MHP_ApplicationNameDescriptor::Parse() {
+   nameLoop.setData(data+sizeof(descr_application_name), getLength()-sizeof(descr_application_name));
+}
+
+void MHP_ApplicationNameDescriptor::NameEntry::Parse() {
+   const descr_application_name_entry *s;
+   s=data.getData<const descr_application_name_entry>();
+   name.setData(data+sizeof(descr_application_name_entry), s->application_name_length);
+   languageCode[0]=s->lang_code1;
+   languageCode[1]=s->lang_code2;
+   languageCode[2]=s->lang_code3;
+}
+
+int MHP_TransportProtocolDescriptor::getProtocolId() const {
+   return HILO(s->protocol_id);
+}
+
+int MHP_TransportProtocolDescriptor::getProtocolLabel() const {
+   return s->transport_protocol_label;
+}
+
+bool MHP_TransportProtocolDescriptor::isRemote() const {
+   return remote;
+}
+
+int MHP_TransportProtocolDescriptor::getComponentTag() const {
+   return componentTag;
+}
+
+void MHP_TransportProtocolDescriptor::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const descr_transport_protocol>(s, offset);
+   if (getProtocolId() == ObjectCarousel) {
+      const transport_via_oc *oc;
+      data.setPointerAndOffset<const transport_via_oc>(oc, offset);
+      remote=oc->remote;
+      if (remote) {
+         const transport_via_oc_remote_end *rem;
+         data.setPointerAndOffset<const transport_via_oc_remote_end>(rem, offset);
+         componentTag=rem->component_tag;
+      } else {
+         const transport_via_oc_end *rem;
+         data.setPointerAndOffset<const transport_via_oc_end>(rem, offset);
+         componentTag=rem->component_tag;
+      }
+   } else { //unimplemented
+      remote=false;
+      componentTag=-1;
+   }
+}
+
+void MHP_DVBJApplicationDescriptor::Parse() {
+   applicationLoop.setData(data+sizeof(descr_dvbj_application), getLength()-sizeof(descr_dvbj_application));
+}
+
+void MHP_DVBJApplicationDescriptor::ApplicationEntry::Parse() {
+   const descr_dvbj_application_entry *entry=data.getData<const descr_dvbj_application_entry>();
+   parameter.setData(data+sizeof(descr_dvbj_application_entry), entry->parameter_length);
+}
+
+void MHP_DVBJApplicationLocationDescriptor::Parse() {
+   unsigned int offset=0;
+   const descr_dvbj_application_location *first;
+   data.setPointerAndOffset<const descr_dvbj_application_location>(first, offset);
+   baseDirectory.setDataAndOffset(data+offset, first->base_directory_length, offset);
+   const descr_dvbj_application_location_mid *mid;
+   data.setPointerAndOffset<const descr_dvbj_application_location_mid>(mid, offset);
+   classPath.setDataAndOffset(data+offset, mid->classpath_extension_length, offset);
+   initialClass.setData(data+offset, getLength()-offset);
+}
+
+int MHP_ApplicationIconsDescriptor::getIconFlags() const {
+   return HILO(s->icon_flags);
+}
+
+void MHP_ApplicationIconsDescriptor::Parse() {
+   unsigned int offset=0;
+   const descr_application_icons_descriptor *first;
+   data.setPointerAndOffset<const descr_application_icons_descriptor>(first, offset);
+   iconLocator.setDataAndOffset(data+offset, first->icon_locator_length, offset);
+   data.setPointerAndOffset<const descr_application_icons_descriptor_end>(s, offset);
+}
+
+} //end of namespace
diff --git a/libsi/descriptor.h b/libsi/descriptor.h
new file mode 100644
index 0000000..9abe1f0
--- /dev/null
+++ b/libsi/descriptor.h
@@ -0,0 +1,477 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: descriptor.h 1.2 2003/12/13 10:42:08 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef LIBSI_DESCRIPTOR_H
+#define LIBSI_DESCRIPTOR_H
+
+#include "si.h"
+#include "headers.h"
+
+namespace SI {
+
+class ShortEventDescriptor : public Descriptor {
+public:
+   char languageCode[3];
+   String name; //name of the event
+   String text; //short description
+protected:
+   virtual void Parse();
+};
+
+class ExtendedEventDescriptor : public GroupDescriptor {
+public:
+   class Item : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(item_extended_event)+sizeof(item_extended_event_mid)+item.getLength()+itemDescription.getLength(); }
+      String item;
+      String itemDescription;
+   protected:
+      virtual void Parse();
+   };
+   char languageCode[3];
+   int getDescriptorNumber();
+   int getLastDescriptorNumber();
+   StructureLoop<Item> itemLoop;
+   String text;
+protected:
+   virtual void Parse();
+private:
+   const descr_extended_event *s;
+};
+
+class ExtendedEventDescriptors : public DescriptorGroup {
+public:
+     //don't use
+   int getTextLength();
+     //really fast
+   int getMaximumTextLength();
+   //same semantics as with SI::String
+   char *getText();
+   //buffer must at least be getTextLength(), getMaximumTextLength() is a good choice
+   char *getText(char *buffer);
+};
+
+class TimeShiftedEventDescriptor : public Descriptor {
+public:
+   int getReferenceServiceId() const;
+   int getReferenceEventId() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_time_shifted_event *s;
+};
+
+class ContentDescriptor : public Descriptor {
+public:
+   class Nibble : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(nibble_content); }
+      int getContentNibbleLevel1() const;
+      int getContentNibbleLevel2() const;
+      int getUserNibble1() const;
+      int getUserNibble2() const;
+   protected:
+      virtual void Parse();
+   private:
+      const nibble_content *s;
+   };
+   StructureLoop<Nibble> nibbleLoop;
+protected:
+   virtual void Parse();
+};
+
+class ParentalRatingDescriptor : public Descriptor {
+public:
+   class Rating : public LoopElement {
+   public:
+      char languageCode[3];
+      int getRating() const;
+      virtual int getLength() { return sizeof(parental_rating); }
+   protected:
+      virtual void Parse();
+   private:
+      const parental_rating *s;
+   };
+   StructureLoop<Rating> ratingLoop;
+protected:
+   virtual void Parse();
+};
+
+class CaDescriptor : public Descriptor {
+public:
+   int getCaType() const;
+   int getCaPid() const;
+   CharArray privateData;
+protected:
+   virtual void Parse();
+private:
+   const descr_ca *s;
+};
+
+class StreamIdentifierDescriptor : public Descriptor {
+public:
+   int getComponentTag() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_stream_identifier *s;
+};
+
+class NetworkNameDescriptor : public Descriptor {
+public:
+   String name;
+protected:
+   virtual void Parse();
+};
+
+class CaIdentifierDescriptor : public Descriptor {
+public:
+   TypeLoop<SixteenBit> identifiers;
+protected:
+   virtual void Parse();
+};
+
+class CarouselIdentifierDescriptor : public Descriptor {
+public:
+   int getCarouselId() const;
+   int getFormatId() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_carousel_identifier *s;
+};
+
+class BouquetNameDescriptor : public NetworkNameDescriptor {
+};
+
+class ServiceListDescriptor : public Descriptor {
+public:
+   class Service : public LoopElement {
+   public:
+      int getServiceId() const;
+      int getServiceType() const;
+   virtual int getLength() { return sizeof(descr_service_list_loop); }
+   protected:
+      virtual void Parse();
+   private:
+      const descr_service_list_loop *s;
+   };
+   StructureLoop<Service> serviceLoop;
+protected:
+   virtual void Parse();
+};
+
+class SatelliteDeliverySystemDescriptor : public Descriptor {
+public:
+   int getFrequency() const;
+   int getOrbitalPosition() const;
+   int getWestEastFlag() const;
+   int getPolarization() const;
+   int getModulation() const;
+   int getSymbolRate() const;
+   int getFecInner() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_satellite_delivery_system *s;
+};
+
+class CableDeliverySystemDescriptor : public Descriptor {
+public:
+   int getFrequency() const;
+   int getFecOuter() const;
+   int getModulation() const;
+   int getSymbolRate() const;
+   int getFecInner() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_cable_delivery_system *s;
+};
+
+class TerrestrialDeliverySystemDescriptor : public Descriptor {
+public:
+   int getFrequency() const;
+   int getBandwidth() const;
+   int getConstellation() const;
+   int getHierarchy() const;
+   int getCodeRateHP() const;
+   int getCodeRateLP() const;
+   int getGuardInterval() const;
+   int getTransmissionMode() const;
+   bool getOtherFrequency() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_terrestrial_delivery *s;
+};
+
+class ServiceDescriptor : public Descriptor {
+public:
+   int getServiceType() const;
+   String serviceName;
+   String providerName;
+protected:
+   virtual void Parse();
+private:
+   const descr_service *s;
+};
+
+class NVODReferenceDescriptor : public Descriptor {
+public:
+   class Service : public LoopElement {
+   public:
+      int getTransportStream() const;
+      int getOriginalNetworkId() const;
+      int getServiceId() const;
+      virtual int getLength() { return sizeof(item_nvod_reference); }
+   protected:
+      virtual void Parse();
+   private:
+      const item_nvod_reference *s;
+   };
+   StructureLoop<Service> serviceLoop;
+protected:
+   virtual void Parse();
+};
+
+class TimeShiftedServiceDescriptor : public Descriptor {
+public:
+   int getReferenceServiceId() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_time_shifted_service *s;
+};
+
+class ComponentDescriptor : public Descriptor {
+public:
+   int getStreamContent() const;
+   int getComponentType() const;
+   int getComponentTag() const;
+   char languageCode[3];
+   String description;
+protected:
+   virtual void Parse();
+private:
+   const descr_component *s;
+};
+
+class SubtitlingDescriptor : public Descriptor {
+public:
+   class Subtitling : public Descriptor {
+   public:
+      int getSubtitlingType() const;
+      int getCompositionPageId() const;
+      int getAncillaryPageId() const;
+      virtual int getLength() { return sizeof(item_nvod_reference); }
+   protected:
+      virtual void Parse();
+   private:
+      const item_subtitling *s;
+   };
+   StructureLoop<Subtitling> subtitlingLoop;
+protected:
+   virtual void Parse();
+};
+
+class ServiceMoveDescriptor : public Descriptor {
+public:
+   int getNewOriginalNetworkId() const;
+   int getNewTransportStreamId() const;
+   int getNewServiceId() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_service_move *s;
+};
+
+class FrequencyListDescriptor : public Descriptor {
+public:
+   int getCodingType() const;
+   TypeLoop<ThirtyTwoBit> frequencies;
+protected:
+   virtual void Parse();
+private:
+   const descr_frequency_list *s;
+};
+
+class ServiceIdentifierDescriptor : public Descriptor {
+public:
+   String textualServiceIdentifier;
+protected:
+   virtual void Parse();
+};
+
+//abstract base class
+class MultilingualNameDescriptor : public Descriptor {
+public:
+   class Name : public LoopElement {
+   public:
+      char languageCode[3];
+      String name;
+      virtual int getLength() { return sizeof(entry_multilingual_name)+name.getLength(); }
+   protected:
+      virtual void Parse();
+   };
+   StructureLoop<Name> nameLoop;
+protected:
+   virtual void Parse();
+};
+
+class MultilingualNetworkNameDescriptor : public MultilingualNameDescriptor {
+   //inherits nameLoop from MultilingualNameDescriptor
+};
+
+class MultilingualBouquetNameDescriptor : public MultilingualNameDescriptor {
+   //inherits nameLoop from MultilingualNameDescriptor
+};
+
+class MultilingualComponentDescriptor : public MultilingualNameDescriptor {
+public:
+   int getComponentTag() const;
+   //inherits nameLoop from MultilingualNameDescriptor
+protected:
+   virtual void Parse();
+private:
+   const descr_multilingual_component *s;
+};
+
+class MultilingualServiceNameDescriptor : public Descriptor {
+public:
+   class Name : public MultilingualNameDescriptor::Name {
+   public:
+      virtual int getLength() { return sizeof(entry_multilingual_name)+providerName.getLength()+sizeof(entry_multilingual_service_name_mid)+name.getLength(); }
+      String providerName;
+      //inherits name, meaning: service name;
+   protected:
+      virtual void Parse();
+   };
+   StructureLoop<Name> nameLoop;
+protected:
+   virtual void Parse();
+};
+
+//a descriptor currently unimplemented in this library
+class UnimplementedDescriptor : public Descriptor {
+protected:
+   virtual void Parse() {}
+};
+
+class ApplicationSignallingDescriptor : public Descriptor {
+public:
+   class ApplicationEntryDescriptor : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(application_signalling_entry); }
+      int getApplicationType() const;
+      int getAITVersionNumber() const;
+   protected:
+      virtual void Parse();
+   private:
+      const application_signalling_entry *s;
+   };
+   StructureLoop<ApplicationEntryDescriptor> entryLoop;
+protected:
+   virtual void Parse();
+};
+
+class MHP_ApplicationDescriptor : public Descriptor {
+public:
+   class Profile : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(application_profile_entry); }
+      int getApplicationProfile() const;
+      int getVersionMajor() const;
+      int getVersionMinor() const;
+      int getVersionMicro() const;
+   private:
+      const application_profile_entry *s;
+   protected:
+      virtual void Parse();
+   };
+   StructureLoop<Profile> profileLoop;
+   bool isServiceBound() const;
+   int getVisibility() const;
+   int getApplicationPriority() const;
+   TypeLoop<EightBit> transportProtocolLabels;
+private:
+   const descr_application_end *s;
+protected:
+   virtual void Parse();
+};
+
+class MHP_ApplicationNameDescriptor : public Descriptor {
+public:
+   class NameEntry : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(descr_application_name_entry)+name.getLength(); }
+      char languageCode[3];
+      String name;
+   protected:
+      virtual void Parse();
+   };
+   StructureLoop<NameEntry> nameLoop;
+protected:
+   virtual void Parse();
+};
+
+class MHP_TransportProtocolDescriptor : public Descriptor {
+public:
+   enum Protocol { ObjectCarousel = 0x01, IPviaDVB = 0x02, HTTPoverInteractionChannel = 0x03 };
+   int getProtocolId() const;
+   int getProtocolLabel() const;
+   bool isRemote() const;
+   int getComponentTag() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_transport_protocol *s;
+   bool remote;
+   int componentTag;
+};
+
+class MHP_DVBJApplicationDescriptor : public Descriptor {
+public:
+   class ApplicationEntry : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(descr_dvbj_application_entry)+parameter.getLength(); }
+      String parameter;
+   protected:
+      virtual void Parse();
+   };
+   StructureLoop<ApplicationEntry> applicationLoop;
+protected:
+   virtual void Parse();
+};
+
+class MHP_DVBJApplicationLocationDescriptor : public Descriptor {
+public:
+   String baseDirectory;
+   String classPath;
+   String initialClass;
+protected:
+   virtual void Parse();
+};
+
+class MHP_ApplicationIconsDescriptor : public Descriptor {
+public:
+   String iconLocator;
+   int getIconFlags() const;
+protected:
+   virtual void Parse();
+private:
+   const descr_application_icons_descriptor_end *s;
+};
+
+} //end of namespace
+
+#endif //LIBSI_TABLE_H
diff --git a/libsi/gendescr.pl b/libsi/gendescr.pl
new file mode 100755
index 0000000..e2b206f
--- /dev/null
+++ b/libsi/gendescr.pl
@@ -0,0 +1,83 @@
+#!/usr/bin/perl
+
+# $Id: gendescr.pl 1.2 2003/12/13 10:40:53 kls Exp $
+
+print "Name (ohne ...Descriptor):";
+$name=<STDIN>;
+$name =~ s/\n$//;
+$inner = ($name =~ s/ä$//);
+$name .= "Descriptor" unless ($inner);
+
+print "Struct:";
+$struct=<STDIN>;
+$struct =~ s/\n$//;
+
+mm:
+$index=0;
+$which=1;
+print "Variablen:";
+while ( <STDIN> ) {
+   if (/ä/) {
+      goto vv;
+   } elsif (/ü/) {
+      $which=1;
+      next;
+   }
+   $eingabe=$_;
+   $eingabe =~ s/(.{75,120} )/\1\n/g;
+   $eingabe =~ s/\n$//;
+   if ($which) {
+      $members[$index]=$eingabe;
+   } else {
+      $members_comments[$index]=$eingabe;
+      $index++;
+      print "Jep!\n";
+   }
+   $which= (! $which);
+}
+
+vv:
+$filename_h="tempdescr.h";
+$filename_c="tempdescr.c";
+schreib();
+
+sub schreib {
+   print "Danke.\n";
+   open(OUTPUT_H, ">>".$filename_h) or die "Could not open file!!";
+   open(OUTPUT_C, ">>".$filename_c) or die "Could not open file!!";
+
+   if ($inner) {
+      $offset="   ";
+   } else {
+      $offset="";
+   }
+   print(OUTPUT_H $offset."class ".$name);
+   if ($inner) {
+      print(OUTPUT_H " : public LoopElement {\n".$offset."public:");
+   } else {
+      print(OUTPUT_H " : public Descriptor {\n".$offset."public:");
+   }
+   #for ($i=0; $i<=$#vars;$i++) {
+   #   print (OUTPUT "/*\n".$vars_comments[$i]." */\n".$vars[$i].";\n\n\n");
+   #}
+   for ($i=0; $i<=$#members;$i++) {
+      print (OUTPUT_H "\n".$offset."   int get".$members[$i]."() const;");
+   }
+   print(OUTPUT_H "\n".$offset."virtual int getLength() { return sizeof(".$struct."); }") if ($inner);
+
+   print(OUTPUT_H "\n".$offset."protected:\n".$offset."   virtual void Parse();");
+   print(OUTPUT_H "\n".$offset."private:\n".$offset."   const ".$struct." *s;") if ($struct ne "");
+   print(OUTPUT_H "\n".$offset."};\n\n");
+   for ($i=0; $i<=$#members_comments;$i++) {
+      print (OUTPUT_C "int ".$name."::get".$members[$i]."() const {\n");
+      if ($members_comments[$i] =~ /^(.+)_hi$/) {
+         $varbase=$1;
+         print (OUTPUT_C "   return HILO(s->".$varbase.");\n}\n\n");
+      } else {
+         print (OUTPUT_C "   return s->".$members_comments[$i].";\n}\n\n");
+      }
+   }
+   print (OUTPUT_C "void ".$name."::Parse() {\n}\n\n");
+   print (OUTPUT_C "\n\n\n");
+   exit;
+}
diff --git a/libsi/headers.h b/libsi/headers.h
new file mode 100644
index 0000000..d5c1199
--- /dev/null
+++ b/libsi/headers.h
@@ -0,0 +1,1669 @@
+/***************************************************************************
+ *                                                                         *
+ *   (C) 2001-03 Rolf Hakenes <hakenes@hippomi.de>, under the              *
+ *               GNU GPL with contribution of Oleg Assovski,               *
+ *               www.satmania.com                                          *
+ *               Adapted and extended by Marcel Wiesweg                    *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: headers.h 1.2 2003/12/13 10:43:26 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef LIBSI_HEADERS_H
+#define LIBSI_HEADERS_H
+
+#include <endian.h>
+
+namespace SI {
+
+typedef unsigned char u_char;
+
+struct SectionHeader {
+   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;
+};
+
+struct ExtendedSectionHeader {
+   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 table_id_extension_hi                  :8;
+   u_char table_id_extension_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;
+};
+
+struct DescriptorHeader {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/*
+ *
+ *    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
+
+struct pat {
+   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;
+};
+
+#define PAT_PROG_LEN 4
+
+struct pat_prog {
+   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)*/
+};
+
+/*
+ *
+ *    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.
+ *
+ */
+#define CAT_LEN 8
+
+struct cat {
+   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 reserved_1                             :8;
+   u_char reserved_2                             :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;
+};
+
+/*
+ *
+ *    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
+
+struct pmt {
+   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
+};
+
+#define PMT_INFO_LEN 5
+
+struct pmt_info {
+   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
+};
+
+/*
+ *
+ *    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
+
+struct nit {
+   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 */
+};
+
+#define SIZE_NIT_MID 2
+
+struct nit_mid {                                 // 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;
+};
+
+#define SIZE_NIT_END 4
+
+struct nit_end {
+   long CRC;
+};
+
+#define NIT_TS_LEN 6
+
+struct ni_ts {
+   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  */
+};
+
+/*
+ *
+ *    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.
+ *
+ */
+/* SEE NIT (It has the same structure but has different allowed descriptors) */
+/*
+ *
+ *    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
+
+struct sdt {
+   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;
+};
+
+#define GetSDTTransportStreamId(x) (HILO(((sdt_t *) x)->transport_stream_id))
+#define GetSDTOriginalNetworkId(x) (HILO(((sdt_t *) x)->original_network_id))
+
+#define SDT_DESCR_LEN 5
+
+struct sdt_descr {
+   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;
+};
+
+/*
+ *
+ *    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
+
+struct eit {
+   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;
+};
+
+#define EIT_EVENT_LEN 12
+
+struct eit_event {
+   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;
+};
+
+/*
+ *
+ *    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.
+ *
+ */
+
+struct rst {
+   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;
+};
+
+struct rst_info {
+   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 event_id_hi                            :8;
+   u_char event_id_lo                            :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :5;
+   u_char running_status                         :3;
+#else
+   u_char running_status                         :3;
+   u_char                                        :5;
+#endif
+};
+
+/*
+ *
+ *    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
+
+struct tdt {
+   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;
+};
+
+/*
+ *
+ *    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.
+ *
+ */
+#define TOT_LEN 10
+
+struct tot {
+   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;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4;
+   u_char descriptors_loop_length_hi             :4;
+#else
+   u_char descriptors_loop_length_hi             :4;
+   u_char                                        :4;
+#endif
+   u_char descriptors_loop_length_lo             :8;
+};
+
+/*
+ *
+ *    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 */
+
+/*
+ *
+ *    3) Application Information Table (AIT):
+ *
+ *       - the AIT contains data concerning MHP application broadcast by a service.
+ *
+ */
+
+#define AIT_LEN 10
+
+struct ait {
+   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 application_type_hi                    :8;
+   u_char application_type_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 common_descriptors_length_hi           :4;
+#else
+   u_char common_descriptors_length_hi           :4;
+   u_char                                        :4;
+#endif
+   u_char common_descriptors_length_lo           :8;
+};
+
+#define SIZE_AIT_MID 2
+
+struct ait_mid {                                 // after descriptors
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4;
+   u_char application_loop_length_hi             :4;
+#else
+   u_char application_loop_length_hi             :4;
+   u_char                                        :4;
+#endif
+   u_char application_loop_length_lo             :8;
+};
+
+#define SIZE_AIT_END 4
+
+struct ait_end {
+   long CRC;
+};
+
+#define AIT_APP_LEN 9
+
+struct ait_app {
+   //how to deal with 32 bit fields?
+
+   u_char organisation_id_hi_hi                  :8;
+   u_char organisation_id_hi_lo                  :8;
+   u_char organisation_id_lo_hi                  :8;
+   u_char organisation_id_lo_lo                  :8;
+
+   //long organisation_id                          :32;
+   u_char application_id_hi                      :8;
+   u_char application_id_lo                      :8;
+   u_char application_control_code               :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :4;
+   u_char application_descriptors_length_hi      :4;
+#else
+   u_char application_descriptors_length_hi      :4;
+   u_char                                        :4;
+#endif
+   u_char application_descriptors_length_lo      :8;
+   /* descriptors  */
+};
+
+/*
+ *
+ *    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
+struct descr_gen {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define GetDescriptorTag(x) (((descr_gen_t *) x)->descriptor_tag)
+#define GetDescriptorLength(x) (((descr_gen_t *) x)->descriptor_length+DESCR_GEN_LEN)
+
+/* 0x09 ca_descriptor */
+
+#define DESCR_CA_LEN 6
+struct descr_ca {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char CA_type_hi                             :8;
+   u_char CA_type_lo                             :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char reserved                               :3;
+   u_char CA_PID_hi                              :5;
+#else
+   u_char CA_PID_hi                              :5;
+   u_char reserved                               :3;
+#endif
+   u_char CA_PID_lo                              :8;
+};
+
+/* 0x0A iso_639_language_descriptor */
+
+#define DESCR_ISO_639_LANGUAGE_LEN 5
+struct descr_iso_639_language {
+   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;
+};
+
+/* 0x13 carousel_identifier_descriptor */
+
+#define DESCR_CAROUSEL_IDENTIFIER_LEN 7
+struct descr_carousel_identifier {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char carousel_id_hi_hi                      :8;
+   u_char carousel_id_hi_lo                      :8;
+   u_char carousel_id_lo_hi                      :8;
+   u_char carousel_id_lo_lo                      :8;
+   u_char FormatId                               :8;
+   /* FormatSpecifier follows */
+};
+
+/* 0x40 network_name_descriptor */
+
+#define DESCR_NETWORK_NAME_LEN 2
+struct descr_network_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/* 0x41 service_list_descriptor */
+
+#define DESCR_SERVICE_LIST_LEN 2
+struct descr_service_list {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define DESCR_SERVICE_LIST_LOOP_LEN 3
+struct descr_service_list_loop {
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+   u_char service_type                           :8;
+};
+
+/* 0x42 stuffing_descriptor */
+
+#define DESCR_STUFFING_LEN XX
+struct descr_stuffing {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x43 satellite_delivery_system_descriptor */
+
+#define DESCR_SATELLITE_DELIVERY_SYSTEM_LEN 13
+struct descr_satellite_delivery_system {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char frequency_hi_hi                        :8;
+   u_char frequency_hi_lo                        :8;
+   u_char frequency_lo_hi                        :8;
+   u_char frequency_lo_lo                        :8;
+   u_char orbital_position_hi                    :8;
+   u_char orbital_position_lo                    :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char west_east_flag                         :1;
+   u_char polarization                           :2;
+   u_char modulation                             :5;
+#else
+   u_char modulation                             :5;
+   u_char polarization                           :2;
+   u_char west_east_flag                         :1;
+#endif
+   u_char symbol_rate_hi_hi                      :8;
+   u_char symbol_rate_hi_lo                      :8;
+   u_char symbol_rate_lo_1                       :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char symbol_rate_lo_2                       :4;
+   u_char fec_inner                              :4;
+#else
+   u_char fec_inner                              :4;
+   u_char symbol_rate_lo_2                       :4;
+#endif
+};
+
+/* 0x44 cable_delivery_system_descriptor */
+
+#define DESCR_CABLE_DELIVERY_SYSTEM_LEN 13
+struct descr_cable_delivery_system {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char frequency_hi_hi                        :8;
+   u_char frequency_hi_lo                        :8;
+   u_char frequency_lo_hi                        :8;
+   u_char frequency_lo_lo                        :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_rate_hi_hi                      :8;
+   u_char symbol_rate_hi_lo                      :8;
+   u_char symbol_rate_lo_1                       :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char symbol_rate_lo_2                       :4;
+   u_char fec_inner                              :4;
+#else
+   u_char fec_inner                              :4;
+   u_char symbol_rate_lo_2                       :4;
+#endif
+};
+
+/* 0x45 vbi_data_descriptor */
+
+#define DESCR_VBI_DATA_LEN XX
+struct descr_vbi_data {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x46 vbi_teletext_descriptor */
+
+#define DESCR_VBI_TELETEXT_LEN XX
+struct descr_vbi_teletext {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x47 bouquet_name_descriptor */
+
+#define DESCR_BOUQUET_NAME_LEN 2
+struct descr_bouquet_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/* 0x48 service_descriptor */
+
+#define DESCR_SERVICE_LEN  4
+struct descr_service {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char service_type                           :8;
+   u_char provider_name_length                   :8;
+};
+
+struct descr_service_mid {
+   u_char service_name_length                   :8;
+};
+
+/* 0x49 country_availability_descriptor */
+
+#define DESCR_COUNTRY_AVAILABILITY_LEN 3
+struct descr_country_availability {
+   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
+};
+
+/* 0x4A linkage_descriptor */
+
+#define DESCR_LINKAGE_LEN 9
+struct descr_linkage {
+   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;
+};
+
+/* 0x4B nvod_reference_descriptor */
+
+#define DESCR_NVOD_REFERENCE_LEN 2
+struct descr_nvod_reference {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define ITEM_NVOD_REFERENCE_LEN 6
+struct item_nvod_reference {
+   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;
+};
+
+/* 0x4C time_shifted_service_descriptor */
+
+#define DESCR_TIME_SHIFTED_SERVICE_LEN 4
+struct descr_time_shifted_service {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char reference_service_id_hi                :8;
+   u_char reference_service_id_lo                :8;
+};
+
+/* 0x4D short_event_descriptor */
+
+#define DESCR_SHORT_EVENT_LEN 6
+struct descr_short_event {
+   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;
+};
+
+struct descr_short_event_mid {
+   u_char text_length                      :8;
+};
+
+/* 0x4E extended_event_descriptor */
+
+#define DESCR_EXTENDED_EVENT_LEN 7
+struct descr_extended_event {
+   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;
+};
+
+struct descr_extended_event_mid {
+   u_char text_length                            :8;
+};
+
+#define ITEM_EXTENDED_EVENT_LEN 1
+struct item_extended_event {
+   u_char item_description_length                :8;
+};
+
+struct item_extended_event_mid {
+   u_char item_length                            :8;
+};
+
+/* 0x4F time_shifted_event_descriptor */
+
+#define DESCR_TIME_SHIFTED_EVENT_LEN 6
+struct descr_time_shifted_event {
+   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;
+};
+
+/* 0x50 component_descriptor */
+
+#define DESCR_COMPONENT_LEN  8
+struct descr_component {
+   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;
+};
+
+/* 0x51 mosaic_descriptor */
+
+#define DESCR_MOSAIC_LEN XX
+struct descr_mosaic {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x52 stream_identifier_descriptor */
+
+#define DESCR_STREAM_IDENTIFIER_LEN 3
+struct descr_stream_identifier {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char component_tag                          :8;
+};
+
+/* 0x53 ca_identifier_descriptor */
+
+#define DESCR_CA_IDENTIFIER_LEN 2
+struct descr_ca_identifier {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/* 0x54 content_descriptor */
+
+#define DESCR_CONTENT_LEN 2
+struct descr_content {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+struct nibble_content {
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char content_nibble_level_1                 :4;
+   u_char content_nibble_level_2                 :4;
+#else
+   u_char content_nibble_level_2                 :4;
+   u_char content_nibble_level_1                 :4;
+#endif
+#if BYTE_ORDER == BIG_ENDIAN
+   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;
+#endif
+};
+
+/* 0x55 parental_rating_descriptor */
+
+#define DESCR_PARENTAL_RATING_LEN 2
+struct descr_parental_rating {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define PARENTAL_RATING_LEN 4
+struct parental_rating {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char rating                                 :8;
+};
+
+/* 0x56 teletext_descriptor */
+
+#define DESCR_TELETEXT_LEN 2
+struct descr_teletext {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define ITEM_TELETEXT_LEN 5
+struct item_teletext {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char type                                   :5;
+   u_char magazine_number                        :3;
+#else
+   u_char magazine_number                        :3;
+   u_char type                                   :5;
+#endif
+   u_char page_number                            :8;
+};
+
+/* 0x57 telephone_descriptor */
+
+#define DESCR_TELEPHONE_LEN XX
+struct descr_telephone {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x58 local_time_offset_descriptor */
+
+#define DESCR_LOCAL_TIME_OFFSET_LEN 2
+struct descr_local_time_offset {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define LOCAL_TIME_OFFSET_ENTRY_LEN 15
+struct local_time_offset_entry {
+   u_char country_code1                          :8;
+   u_char country_code2                          :8;
+   u_char country_code3                          :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char country_region_id                      :6;
+   u_char                                        :1;
+   u_char local_time_offset_polarity             :1;
+#else
+   u_char local_time_offset_polarity             :1;
+   u_char                                        :1;
+   u_char country_region_id                      :6;
+#endif
+   u_char local_time_offset_h                    :8;
+   u_char local_time_offset_m                    :8;
+   u_char time_of_change_mjd_hi                  :8;
+   u_char time_of_change_mjd_lo                  :8;
+   u_char time_of_change_time_h                  :8;
+   u_char time_of_change_time_m                  :8;
+   u_char time_of_change_time_s                  :8;
+   u_char next_time_offset_h                     :8;
+   u_char next_time_offset_m                     :8;
+};
+
+/* 0x59 subtitling_descriptor */
+
+#define DESCR_SUBTITLING_LEN 2
+struct descr_subtitling {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define ITEM_SUBTITLING_LEN 8
+struct item_subtitling {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char subtitling_type                        :8;
+   u_char composition_page_id_hi                 :8;
+   u_char composition_page_id_lo                 :8;
+   u_char ancillary_page_id_hi                   :8;
+   u_char ancillary_page_id_lo                   :8;
+};
+
+/* 0x5A terrestrial_delivery_system_descriptor */
+
+#define DESCR_TERRESTRIAL_DELIVERY_SYSTEM_LEN XX
+struct descr_terrestrial_delivery {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char frequency_hi_hi                        :8;
+   u_char frequency_hi_lo                        :8;
+   u_char frequency_lo_hi                        :8;
+   u_char frequency_lo_lo                        :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char bandwidth                              :3;
+   u_char reserved1                              :5;
+#else
+   u_char reserved1                              :5;
+   u_char bandwidth                              :3;
+#endif
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char constellation                          :2;
+   u_char hierarchy                              :3;
+   u_char code_rate_HP                           :3;
+#else
+   u_char code_rate_HP                           :3;
+   u_char hierarchy                              :3;
+   u_char constellation                          :2;
+#endif
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char code_rate_LP                           :3;
+   u_char guard_interval                         :2;
+   u_char transmission_mode                      :2;
+   u_char other_frequency_flag                   :1;
+#else
+   u_char other_frequency_flag                   :1;
+   u_char transmission_mode                      :2;
+   u_char guard_interval                         :2;
+   u_char code_rate_LP                           :3;
+#endif
+   u_char reserver2                              :8;
+   u_char reserver3                              :8;
+   u_char reserver4                              :8;
+   u_char reserver5                              :8;
+};
+
+/* 0x5B multilingual_network_name_descriptor */
+
+#define DESCR_MULTILINGUAL_NETWORK_NAME_LEN XX
+struct descr_multilingual_network_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+struct entry_multilingual_name {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char text_length                            :8;
+};
+
+/* 0x5C multilingual_bouquet_name_descriptor */
+
+#define DESCR_MULTILINGUAL_BOUQUET_NAME_LEN XX
+struct descr_multilingual_bouquet_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/* 0x5D multilingual_service_name_descriptor */
+
+#define DESCR_MULTILINGUAL_SERVICE_NAME_LEN XX
+struct descr_multilingual_service_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+struct entry_multilingual_service_name_mid {
+   u_char service_name_length                    :8;
+};
+
+/* 0x5E multilingual_component_descriptor */
+
+#define DESCR_MULTILINGUAL_COMPONENT_LEN XX
+struct descr_multilingual_component {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char component_tag                          :8;
+};
+
+/* 0x5F private_data_specifier_descriptor */
+
+#define DESCR_PRIVATE_DATA_SPECIFIER_LEN XX
+struct descr_private_data_specifier {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x60 service_move_descriptor */
+
+#define DESCR_SERVICE_MOVE_LEN XX
+struct descr_service_move {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char new_original_network_id_hi             :8;
+   u_char new_original_network_id_lo             :8;
+   u_char new_transport_stream_id_hi             :8;
+   u_char new_transport_stream_id_lo             :8;
+   u_char new_service_id_hi                      :8;
+   u_char new_service_id_lo                      :8;
+};
+
+/* 0x61 short_smoothing_buffer_descriptor */
+
+#define DESCR_SHORT_SMOOTHING_BUFFER_LEN XX
+struct descr_short_smoothing_buffer {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x62 frequency_list_descriptor */
+
+#define DESCR_FREQUENCY_LIST_LEN XX
+struct descr_frequency_list {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :6;
+   u_char coding_type                            :2;
+#else
+   u_char coding_type                            :2;
+   u_char                                        :6;
+#endif
+};
+
+/* 0x63 partial_transport_stream_descriptor */
+
+#define DESCR_PARTIAL_TRANSPORT_STREAM_LEN XX
+struct descr_partial_transport_stream {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x64 data_broadcast_descriptor */
+
+#define DESCR_DATA_BROADCAST_LEN XX
+struct descr_data_broadcast {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x65 ca_system_descriptor */
+
+#define DESCR_CA_SYSTEM_LEN XX
+struct descr_ca_system {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x66 data_broadcast_id_descriptor */
+
+#define DESCR_DATA_BROADCAST_ID_LEN XX
+struct descr_data_broadcast_id {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x67 transport_stream_descriptor */
+
+#define DESCR_TRANSPORT_STREAM_LEN XX
+struct descr_transport_stream {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x68 dsng_descriptor */
+
+#define DESCR_DSNG_LEN XX
+struct descr_dsng {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x69 pdc_descriptor */
+
+#define DESCR_PDC_LEN XX
+struct descr_pdc {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x6A ac3_descriptor */
+
+#define DESCR_AC3_LEN 3
+struct descr_ac3 {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char ac3_type_flag                          :1;
+   u_char bsid_flag                              :1;
+   u_char mainid_flag                            :1;
+   u_char asvc_flag                              :1;
+   u_char reserved                               :4;
+#else
+   u_char reserved                               :4;
+   u_char asvc_flag                              :1;
+   u_char mainid_flag                            :1;
+   u_char bsid_flag                              :1;
+   u_char ac3_type_flag                          :1;
+#endif
+   u_char ac3_type                               :8;
+   u_char bsid                                   :8;
+   u_char mainid                                 :8;
+   u_char asvc                                   :8;
+};
+
+/* 0x6B ancillary_data_descriptor */
+
+#define DESCR_ANCILLARY_DATA_LEN 3
+struct descr_ancillary_data {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char ancillary_data_identifier              :8;
+};
+
+/* 0x6C cell_list_descriptor */
+
+#define DESCR_CELL_LIST_LEN XX
+struct descr_cell_list {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x6D cell_frequency_link_descriptor */
+
+#define DESCR_CELL_FREQUENCY_LINK_LEN XX
+struct descr_cell_frequency_link {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x6E announcement_support_descriptor */
+
+#define DESCR_ANNOUNCEMENT_SUPPORT_LEN XX
+struct descr_announcement_support {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   /* TBD */
+};
+
+/* 0x6F application_signalling_descriptor */
+
+#define DESCR_APPLICATION_SIGNALLING_LEN 2
+struct descr_application_signalling {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define APPLICATION_SIGNALLING_ENTRY_LEN 3
+struct application_signalling_entry {
+   u_char application_type_hi                    :8;
+   u_char application_type_lo                    :8;
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char                                        :3;
+   u_char AIT_version_number                     :5;
+#else
+   u_char AIT_version_number                     :5;
+   u_char                                        :3;
+#endif
+};
+
+/* 0x71 service_identifier_descriptor (ETSI TS 102 812, MHP) */
+
+struct descr_service_identifier {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+/* MHP 0x00 application_descriptor */
+
+#define DESCR_APPLICATION_LEN 3
+
+struct descr_application {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char application_profiles_length            :8;
+};
+
+#define DESCR_APPLICATION_END_LEN 2
+
+struct descr_application_end {
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char service_bound_flag                     :1;
+   u_char visibility                             :2;
+   u_char                                        :5;
+#else
+   u_char                                        :5;
+   u_char visibility                             :2;
+   u_char service_bound_flag                     :1;
+#endif
+   u_char application_priority                   :8;
+/*now follow 8bit transport_protocol_label fields to the end */
+};
+
+#define APPLICATION_PROFILE_ENTRY_LEN 5
+
+struct application_profile_entry {
+   u_char application_profile_hi                 :8;
+   u_char application_profile_lo                 :8;
+   u_char version_major                          :8;
+   u_char version_minor                          :8;
+   u_char version_micro                          :8;
+};
+
+/* MHP 0x01 application_name_desriptor */
+
+#define DESCR_APPLICATION_NAME_LEN 2
+
+struct descr_application_name {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define APPLICATION_NAME_ENTRY_LEN 4
+
+struct descr_application_name_entry {
+   u_char lang_code1                             :8;
+   u_char lang_code2                             :8;
+   u_char lang_code3                             :8;
+   u_char application_name_length                :8;
+   /* application name string */
+};
+
+/* MHP 0x02 transport_protocol_descriptor */
+
+#define DESCR_TRANSPORT_PROTOCOL_LEN 5
+
+struct descr_transport_protocol {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char protocol_id_hi                         :8;
+   u_char protocol_id_lo                         :8;
+   u_char transport_protocol_label               :8;
+   /* protocol_id-specific selector bytes follow */
+};
+
+#define TRANSPORT_VIA_OC_LEN 1
+
+struct transport_via_oc {
+#if BYTE_ORDER == BIG_ENDIAN
+   u_char remote                                 :1;
+   u_char                                        :7;
+#else
+   u_char                                        :7;
+   u_char remote                                 :1;
+#endif
+};
+
+//if remote is true, transport_via_oc_remote_end_t follows,
+// else transport_via_oc_end_t.
+
+#define TRANSPORT_VIA_OC_REMOTE_END_LEN 7
+
+struct transport_via_oc_remote_end {
+   u_char original_network_id_hi                 :8;
+   u_char original_network_id_lo                 :8;
+   u_char transport_stream_id_hi                 :8;
+   u_char transport_stream_id_lo                 :8;
+   u_char service_id_hi                          :8;
+   u_char service_id_lo                          :8;
+   u_char component_tag                          :8;
+};
+
+#define TRANSPORT_VIA_OC_END_LEN 1
+
+struct transport_via_oc_end {
+   u_char component_tag                          :8;
+};
+
+/* 0x03 dvb_j_application_descriptor() */
+
+#define DESCR_DVBJ_APPLICATION_LEN 2
+
+struct descr_dvbj_application {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+};
+
+#define DESCR_DVBJ_APPLICATION_ENTRY_LEN 1
+
+struct descr_dvbj_application_entry {
+   u_char parameter_length                       :8;
+   /* parameter string */
+};
+
+/* 0x04 dvb_j_application_location_descriptor */
+
+#define DESCR_DVBJ_APPLICATION_LOCATION_LEN 3
+
+struct descr_dvbj_application_location {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char base_directory_length                  :8;
+   /* base directory string */
+};
+
+#define DESCR_DVBJ_APPLICATION_LOCATION_MID_LEN 1
+
+struct descr_dvbj_application_location_mid {
+   u_char classpath_extension_length                  :8;
+};
+
+/* 0x0B application_icons_descriptor */
+
+#define DESCR_APPLICATION_ICONS_LEN 3
+
+struct descr_application_icons_descriptor {
+   u_char descriptor_tag                         :8;
+   u_char descriptor_length                      :8;
+   u_char icon_locator_length                    :8;
+   /* icon locator */
+};
+
+#define DESCR_APPLICATION_ICONS_END_LEN 2
+
+struct descr_application_icons_descriptor_end {
+   u_char icon_flags_hi                          :8;
+   u_char icon_flags_lo                          :8;
+};
+
+} //end of namespace
+
+#endif //LIBSI_HEADERS_H
diff --git a/libsi/section.c b/libsi/section.c
new file mode 100644
index 0000000..0de2a57
--- /dev/null
+++ b/libsi/section.c
@@ -0,0 +1,328 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: section.c 1.2 2003/12/13 10:42:14 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#include "section.h"
+#include <stdio.h>
+
+namespace SI {
+
+/*********************** PAT ***********************/
+
+void PAT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const pat>(s, offset);
+   associationLoop.setData(data+offset, getLength()-offset-4);
+}
+
+int PAT::getTransportStreamId() const {
+   return HILO(s->transport_stream_id);
+}
+
+int PAT::Association::getServiceId() const {
+   return HILO(s->program_number);
+}
+
+int PAT::Association::getPid() const {
+   return HILO(s->network_pid);
+}
+
+void PAT::Association::Parse() {
+   s=data.getData<pat_prog>();
+}
+
+/*********************** CAT ***********************/
+
+void CAT::Parse() {
+   loop.setData(data+sizeof(cat), getLength()-sizeof(cat)-4);
+}
+
+/*********************** PMT ***********************/
+
+void PMT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const pmt>(s, offset);
+   commonDescriptors.setDataAndOffset(data+offset, HILO(s->program_info_length), offset);
+   streamLoop.setData(data+offset, getLength()-offset-4);
+}
+
+int PMT::getServiceId() const {
+   return HILO(s->program_number);
+}
+
+int PMT::getPCRPid() const {
+   return HILO(s->PCR_PID);
+}
+
+int PMT::Stream::getPid() const {
+   return HILO(s->elementary_PID);
+}
+
+int PMT::Stream::getStreamType() const {
+   return s->stream_type;
+}
+
+void PMT::Stream::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const pmt_info>(s, offset);
+   streamDescriptors.setData(data+offset, HILO(s->ES_info_length));
+}
+
+/*********************** NIT ***********************/
+
+int NIT::getNetworkId() const {
+   return HILO(s->network_id);
+}
+
+void NIT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const nit>(s, offset);
+   commonDescriptors.setDataAndOffset(data+offset, HILO(s->network_descriptor_length), offset);
+   const nit_mid *mid;
+   data.setPointerAndOffset<const nit_mid>(mid, offset);
+   transportStreamLoop.setData(data+offset, HILO(mid->transport_stream_loop_length));
+}
+
+int NIT::TransportStream::getTransportStreamId() const {
+   return HILO(s->transport_stream_id);
+}
+
+int NIT::TransportStream::getOriginalNetworkId() const {
+   return HILO(s->original_network_id);
+}
+
+void NIT::TransportStream::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const ni_ts>(s, offset);
+   transportStreamDescriptors.setData(data+offset, HILO(s->transport_descriptors_length));
+}
+
+/*********************** SDT ***********************/
+
+void SDT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const sdt>(s, offset);
+   serviceLoop.setData(data+offset, getLength()-offset-4); //4 is for CRC
+}
+
+int SDT::getTransportStreamId() const {
+   return HILO(s->transport_stream_id);
+}
+
+int SDT::getOriginalNetworkId() const {
+   return HILO(s->original_network_id);
+}
+
+int SDT::Service::getServiceId() const {
+   return HILO(s->service_id);
+}
+
+int SDT::Service::getEITscheduleFlag() const {
+   return s->eit_schedule_flag;
+}
+
+int SDT::Service::getEITpresentFollowingFlag() const {
+   return s->eit_present_following_flag;
+}
+
+RunningStatus SDT::Service::getRunningStatus() const {
+   return (RunningStatus)s->running_status;
+}
+
+int SDT::Service::getFreeCaMode() const {
+   return s->free_ca_mode;
+}
+
+void SDT::Service::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const sdt_descr>(s, offset);
+   serviceDescriptors.setData(data+offset, HILO(s->descriptors_loop_length));
+}
+
+/*********************** EIT ***********************/
+
+int EIT::getServiceId() const {
+   return HILO(s->service_id);
+}
+
+int EIT::getTransportStreamId() const {
+   return HILO(s->transport_stream_id);
+}
+
+int EIT::getOriginalNetworkId() const {
+   return HILO(s->original_network_id);
+}
+
+bool EIT::isPresentFollowing() const {
+   return getTableId() == TableIdEIT_presentFollowing || getTableId() == TableIdEIT_presentFollowing_other;
+}
+
+bool EIT::isActualTS() const {
+   return
+       (getTableId() ==TableIdEIT_presentFollowing)
+    || (TableIdEIT_schedule_first <= getTableId() && getTableId() <= TableIdEIT_schedule_last);
+}
+
+void EIT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const eit>(s, offset);
+   //printf("%d %d %d %d %d\n", getServiceId(), getTransportStreamId(), getOriginalNetworkId(), isPresentFollowing(), isActualTS());
+   eventLoop.setData(data+offset, getLength()-offset-4); //4 is for CRC
+}
+
+time_t EIT::Event::getStartTime() const {
+   return DVBTime::getTime(s->mjd_hi, s->mjd_lo, s->start_time_h, s->start_time_m, s->start_time_s);
+}
+
+time_t EIT::Event::getDuration() const {
+   return DVBTime::getDuration(s->duration_h, s->duration_m, s->duration_s);
+}
+
+int EIT::Event::getEventId() const {
+   return HILO(s->event_id);
+}
+
+int EIT::Event::getMJD() const {
+   return HILO(s->mjd);
+}
+
+int EIT::Event::getStartTimeHour() const {
+   return DVBTime::bcdToDec(s->start_time_h);
+}
+
+int EIT::Event::getStartTimeMinute() const {
+   return DVBTime::bcdToDec(s->start_time_m);
+}
+
+int EIT::Event::getStartTimeSecond() const {
+   return DVBTime::bcdToDec(s->start_time_s);
+}
+
+int EIT::Event::getDurationHour() const {
+   return DVBTime::bcdToDec(s->duration_h);
+}
+
+int EIT::Event::getDurationMinute() const {
+   return DVBTime::bcdToDec(s->duration_m);
+}
+
+int EIT::Event::getDurationSecond() const {
+   return DVBTime::bcdToDec(s->duration_s);
+}
+
+RunningStatus EIT::Event::getRunningStatus() const {
+   return (RunningStatus)s->running_status;
+}
+
+int EIT::Event::getFreeCaMode() const {
+   return s->free_ca_mode;
+}
+
+void EIT::Event::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const eit_event>(s, offset);
+   //printf("%d %d %d\n", getStartTime(), getDuration(), getRunningStatus());
+   eventDescriptors.setData(data+offset, HILO(s->descriptors_loop_length));
+}
+
+/*********************** TDT ***********************/
+
+time_t TDT::getTime() const {
+   return DVBTime::getTime(s->utc_mjd_hi, s->utc_mjd_lo, s->utc_time_h, s->utc_time_m, s->utc_time_s);
+}
+
+void TDT::Parse() {
+   s=data.getData<const tdt>();
+}
+
+/*********************** TOT ***********************/
+
+time_t TOT::getTime() const {
+   return DVBTime::getTime(s->utc_mjd_hi, s->utc_mjd_lo, s->utc_time_h, s->utc_time_m, s->utc_time_s);
+}
+
+void TOT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const tot>(s, offset);
+   descriptorLoop.setData(data+offset, getLength()-offset-4);
+}
+
+/*********************** RST ***********************/
+
+void RST::Parse() {
+   unsigned int offset=0;
+   const rst *s;
+   data.setPointerAndOffset<const rst>(s, offset);
+   infoLoop.setData(data+offset, getLength()-offset);
+}
+
+int RST::RunningInfo::getTransportStreamId() const {
+   return HILO(s->transport_stream_id);
+}
+
+int RST::RunningInfo::getOriginalNetworkId() const {
+   return HILO(s->original_network_id);
+}
+
+int RST::RunningInfo::getServiceId() const {
+   return HILO(s->service_id);
+}
+
+int RST::RunningInfo::getEventId() const {
+   return HILO(s->event_id);
+}
+
+RunningStatus RST::RunningInfo::getRunningStatus() const {
+   return (RunningStatus)s->running_status;
+}
+
+void RST::RunningInfo::Parse() {
+   s=data.getData<const rst_info>();
+}
+
+/*********************** AIT ***********************/
+
+int AIT::getApplicationType() const {
+   return HILO(first->application_type);
+}
+
+int AIT::getAITVersion() const {
+   return first->version_number;
+}
+
+void AIT::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const ait>(first, offset);
+   commonDescriptors.setDataAndOffset(data+offset, HILO(first->common_descriptors_length), offset);
+   const ait_mid *mid;
+   data.setPointerAndOffset<const ait_mid>(mid, offset);
+   applicationLoop.setData(data+offset, HILO(mid->application_loop_length));
+}
+
+long AIT::Application::getOrganisationId() const {
+   return data.FourBytes(0);
+}
+
+int AIT::Application::getApplicationId() const {
+   return HILO(s->application_id);
+}
+
+int AIT::Application::getControlCode() const {
+   return s->application_control_code;
+}
+
+void AIT::Application::Parse() {
+   unsigned int offset=0;
+   data.setPointerAndOffset<const ait_app>(s, offset);
+   applicationDescriptors.setData(data+offset, HILO(s->application_descriptors_length));
+}
+
+} //end of namespace
diff --git a/libsi/section.h b/libsi/section.h
new file mode 100644
index 0000000..efca9bb
--- /dev/null
+++ b/libsi/section.h
@@ -0,0 +1,252 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: section.h 1.2 2003/12/13 10:42:15 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef LIBSI_SECTION_H
+#define LIBSI_SECTION_H
+
+#include <time.h>
+
+#include "si.h"
+#include "headers.h"
+
+namespace SI {
+
+class PAT : public NumberedSection {
+public:
+   PAT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   PAT() {}
+   class Association : public LoopElement {
+   public:
+      int getServiceId() const;
+      int getPid() const;
+      bool isNITPid() const { return getServiceId()==0; }
+      virtual int getLength() { return sizeof(pat_prog); }
+   protected:
+      virtual void Parse();
+   private:
+      const pat_prog *s;
+   };
+   int getTransportStreamId() const;
+   StructureLoop<Association> associationLoop;
+protected:
+   virtual void Parse();
+private:
+   const pat *s;
+};
+
+class CAT : public NumberedSection {
+public:
+   CAT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   CAT() {}
+   DescriptorLoop loop;
+protected:
+   virtual void Parse();
+};
+
+class PMT : public NumberedSection {
+public:
+   PMT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   PMT() {}
+   class Stream : public LoopElement {
+   public:
+      int getPid() const;
+      int getStreamType() const;
+      DescriptorLoop streamDescriptors;
+      virtual int getLength() { return sizeof(pmt_info)+streamDescriptors.getLength(); }
+   protected:
+      virtual void Parse();
+   private:
+      const pmt_info *s;
+   };
+   DescriptorLoop commonDescriptors;
+   StructureLoop<Stream> streamLoop;
+   int getServiceId() const;
+   int getPCRPid() const;
+protected:
+   virtual void Parse();
+private:
+   const pmt *s;
+};
+
+class NIT : public NumberedSection {
+public:
+   NIT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   NIT() {}
+   class TransportStream : public LoopElement {
+   public:
+      int getTransportStreamId() const;
+      int getOriginalNetworkId() const;
+      virtual int getLength() { return sizeof(ni_ts)+transportStreamDescriptors.getLength(); }
+      DescriptorLoop transportStreamDescriptors;
+   protected:
+      virtual void Parse();
+   private:
+      const ni_ts *s;
+   };
+   DescriptorLoop commonDescriptors;
+   StructureLoop<TransportStream> transportStreamLoop;
+   int getNetworkId() const;
+protected:
+   virtual void Parse();
+private:
+   const nit *s;
+};
+
+//BAT has the same structure as NIT but different allowed descriptors
+class BAT : public NIT {
+public:
+   BAT(const unsigned char *data, bool doCopy=true) : NIT(data, doCopy) {}
+   BAT() {}
+   int getBouquetId() const { return getNetworkId(); }
+};
+
+class SDT : public NumberedSection {
+public:
+   SDT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   SDT() {}
+   class Service : public LoopElement {
+   public:
+      int getServiceId() const;
+      int getEITscheduleFlag() const;
+      int getEITpresentFollowingFlag() const;
+      RunningStatus getRunningStatus() const;
+      int getFreeCaMode() const;
+      virtual int getLength() { return sizeof(sdt_descr)+serviceDescriptors.getLength(); }
+      DescriptorLoop serviceDescriptors;
+   protected:
+      virtual void Parse();
+   private:
+      const sdt_descr *s;
+   };
+   int getTransportStreamId() const;
+   int getOriginalNetworkId() const;
+   StructureLoop<Service> serviceLoop;
+protected:
+   virtual void Parse();
+private:
+   const sdt *s;
+};
+
+class EIT : public NumberedSection {
+public:
+   EIT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   EIT() {}
+   class Event : public LoopElement {
+   public:
+      int getEventId() const;
+      time_t getStartTime() const; //UTC
+      time_t getDuration() const;
+
+      int getMJD() const;
+      int getStartTimeHour() const; //UTC
+      int getStartTimeMinute() const; //UTC
+      int getStartTimeSecond() const; //UTC
+      int getDurationHour() const;
+      int getDurationMinute() const;
+      int getDurationSecond() const;
+      RunningStatus getRunningStatus() const;
+      int getFreeCaMode() const;
+
+      DescriptorLoop eventDescriptors;
+      virtual int getLength() { return sizeof(eit_event)+eventDescriptors.getLength(); }
+   protected:
+      virtual void Parse();
+   private:
+      const eit_event *s;
+   };
+   int getServiceId() const;
+   int getTransportStreamId() const;
+   int getOriginalNetworkId() const;
+   StructureLoop<Event> eventLoop;
+
+   //true if table conveys present/following information, false if it conveys schedule information
+   bool isPresentFollowing() const;
+   //true if table describes TS on which it is broadcast, false if it describes other TS
+   bool isActualTS() const;
+protected:
+   virtual void Parse();
+private:
+   const eit *s;
+};
+
+class TDT : public Section {
+public:
+   TDT(const unsigned char *data, bool doCopy=true) : Section(data, doCopy) {}
+   TDT() {}
+   time_t getTime() const; //UTC
+protected:
+   virtual void Parse();
+private:
+   const tdt *s;
+};
+
+class TOT : public CRCSection {
+public:
+   TOT(const unsigned char *data, bool doCopy=true) : CRCSection(data, doCopy) {}
+   TOT() {}
+   time_t getTime() const;
+   DescriptorLoop descriptorLoop;
+protected:
+   virtual void Parse();
+private:
+   const tot *s;
+};
+
+class RST : public Section {
+public:
+   RST(const unsigned char *data, bool doCopy=true) : Section(data, doCopy) {}
+   RST() {}
+   class RunningInfo : public LoopElement {
+   public:
+      int getTransportStreamId() const;
+      int getOriginalNetworkId() const;
+      int getServiceId() const;
+      int getEventId() const;
+      RunningStatus getRunningStatus() const;
+      virtual int getLength() { return sizeof(rst_info); }
+   protected:
+      virtual void Parse();
+   private:
+      const rst_info *s;
+   };
+   StructureLoop<RunningInfo> infoLoop;
+protected:
+   virtual void Parse();
+};
+
+class AIT : public NumberedSection {
+public:
+   AIT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}
+   AIT() {}
+   class Application : public LoopElement {
+   public:
+      virtual int getLength() { return sizeof(ait_app)+applicationDescriptors.getLength(); }
+      long getOrganisationId() const;
+      int getApplicationId() const;
+      int getControlCode() const;
+      MHP_DescriptorLoop applicationDescriptors;
+   protected:
+      virtual void Parse();
+      const ait_app *s;
+   };
+   MHP_DescriptorLoop commonDescriptors;
+   StructureLoop<Application> applicationLoop;
+   int getApplicationType() const;
+   int getAITVersion() const;
+protected:
+   const ait *first;
+   virtual void Parse();
+};
+
+} //end of namespace
+
+#endif //LIBSI_TABLE_H
diff --git a/libsi/si.c b/libsi/si.c
new file mode 100644
index 0000000..bcf519a
--- /dev/null
+++ b/libsi/si.c
@@ -0,0 +1,415 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: si.c 1.3 2004/01/04 14:26:53 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#include <string.h>
+#include "si.h"
+#include "descriptor.h"
+
+namespace SI {
+
+Object::Object() {
+}
+
+Object::Object(CharArray &d) : data(d) {
+}
+
+void Object::setData(const unsigned char*d, unsigned int size, bool doCopy) {
+   data.assign(d, size, doCopy);
+}
+
+void Object::setData(CharArray &d) {
+   data=d;
+}
+
+Section::Section(const unsigned char *data, bool doCopy) {
+   setData(data, getLength(data), doCopy);
+}
+
+TableId Section::getTableId() const {
+   return getTableId(data.getData());
+}
+
+int Section::getLength() {
+   return getLength(data.getData());
+}
+
+TableId Section::getTableId(const unsigned char *d) {
+   return (TableId)((const SectionHeader *)d)->table_id;
+}
+
+int Section::getLength(const unsigned char *d) {
+   return HILO(((const SectionHeader *)d)->section_length)+sizeof(SectionHeader);
+}
+
+bool CRCSection::isValid() {
+   return CRC32::isValid((const char *)data.getData(), getLength()/*, data.FourBytes(getLength()-4)*/);
+}
+
+bool CRCSection::CheckCRCAndParse() {
+   if (!isValid())
+      return false;
+   CheckParse();
+   return true;
+}
+
+bool NumberedSection::getCurrentNextIndicator() const {
+   return data.getData<ExtendedSectionHeader>()->current_next_indicator;
+}
+
+int NumberedSection::getVersionNumber() const {
+   return data.getData<ExtendedSectionHeader>()->version_number;
+}
+
+int NumberedSection::getSectionNumber() const {
+   return data.getData<ExtendedSectionHeader>()->section_number;
+}
+
+int NumberedSection::getLastSectionNumber() const {
+   return data.getData<ExtendedSectionHeader>()->last_section_number;
+}
+
+int Descriptor::getLength() {
+   return getLength(data.getData());
+}
+
+DescriptorTag Descriptor::getDescriptorTag() const {
+   return getDescriptorTag(data.getData());
+}
+
+int Descriptor::getLength(const unsigned char *d) {
+   return ((const DescriptorHeader*)d)->descriptor_length+sizeof(DescriptorHeader);
+}
+
+DescriptorTag Descriptor::getDescriptorTag(const unsigned char *d) {
+   return (DescriptorTag)((const DescriptorHeader*)d)->descriptor_tag;
+}
+
+Descriptor *DescriptorLoop::getNext(Iterator &it) {
+   if (it.i<getLength()) {
+      return createDescriptor(it.i);
+   }
+   return 0;
+}
+
+Descriptor *DescriptorLoop::getNext(Iterator &it, DescriptorTag tag, bool returnUnimplemetedDescriptor) {
+   Descriptor *d=0;
+   if (it.i<getLength()) {
+      const unsigned char *p=data.getData(it.i);
+      const unsigned char *end=p+getLength();
+      while (p < end) {
+         if (Descriptor::getDescriptorTag(p) == tag) {
+            d=createDescriptor(it.i);
+            break;
+         }
+         it.i+=Descriptor::getLength(p);
+         p+=Descriptor::getLength(p);
+      }
+   }
+   if (d && d->getDescriptorTag()==UnimplementedDescriptorTag)
+      return returnUnimplemetedDescriptor ? d : 0;
+   return d;
+}
+
+Descriptor *DescriptorLoop::getNext(Iterator &it, DescriptorTag *tags, int arrayLength, bool returnUnimplemetedDescriptor) {
+   Descriptor *d=0;
+   if (it.i<getLength()) {
+      const unsigned char *p=data.getData(it.i);
+      const unsigned char *end=p+getLength();
+      while (p < end) {
+         for (int u=0; u<arrayLength;u++)
+            if (Descriptor::getDescriptorTag(p) == tags[u]) {
+               d=createDescriptor(it.i);
+               break;
+            }
+         if (d)
+            break;
+         it.i+=Descriptor::getLength(p);
+         p+=Descriptor::getLength(p);
+      }
+   }
+   if (d && d->getDescriptorTag()==UnimplementedDescriptorTag)
+      return returnUnimplemetedDescriptor ? d : 0;
+   return d;
+}
+
+Descriptor *DescriptorLoop::createDescriptor(int &i) {
+   Descriptor *d=Descriptor::getDescriptor(data+i, domain);
+   i+=d->getLength();
+   d->CheckParse();
+   return d;
+}
+
+DescriptorGroup::DescriptorGroup(bool del) {
+   array=0;
+   length=0;
+   deleteOnDesctruction=del;
+}
+
+DescriptorGroup::~DescriptorGroup() {
+   if (deleteOnDesctruction)
+      Delete();
+   delete[] array;
+}
+
+void DescriptorGroup::Delete() {
+   for (int i=0;i<length;i++)
+      if (array[i]!=0) {
+         delete array[i];
+         array[i]=0;
+      }
+}
+
+void DescriptorGroup::Add(GroupDescriptor *d) {
+   if (!array) {
+      length=d->getLastDescriptorNumber()+1;
+      array=new GroupDescriptor*[length]; //numbering is zero-based
+      for (int i=0;i<length;i++)
+         array[i]=0;
+   } else if (length != d->getLastDescriptorNumber()+1)
+      return; //avoid crash in case of misuse
+   array[d->getDescriptorNumber()]=d;
+}
+
+bool DescriptorGroup::isComplete() {
+   for (int i=0;i<length;i++)
+      if (array[i]==0)
+         return false;
+   return true;
+}
+
+char *String::getText() {
+   if (getLength() < 0 || getLength() >4095)
+      return "text error";
+   char *data=new char(getLength()+1);
+   decodeText(data);
+   return data;
+}
+
+char *String::getText(char *buffer) {
+   if (getLength() < 0 || getLength() >4095) {
+      strncpy(buffer, "text error", getLength()+1);
+      return buffer;
+   }
+   decodeText(buffer);
+   return buffer;
+}
+
+//taken from libdtv, Copyright Rolf Hakenes <hakenes@hippomi.de>
+void String::decodeText(char *buffer) {
+   const unsigned char *from=data.getData(0);
+   char *to=buffer;
+
+   /* Disable detection of coding tables - libdtv doesn't do it either
+   if ( (0x01 <= *from) && (*from <= 0x1f) ) {
+      codeTable=*from
+   }
+   */
+
+   for (int i = 0; i < getLength(); i++) {
+      if (*from == 0)
+         break;
+      if (    ((' ' <= *from) && (*from <= '~'))
+           || (*from == '\n')
+           || ((0xA0 <= *from) && (*from <= 0xFF))
+         )
+         *to++ = *from;
+      else if (*from == 0x8A)
+         *to++ = '\n';
+      else if (*from == 0x86 || *from == 0x87) //&& !(GDT_NAME_DESCRIPTOR & type))
+         *to++ = *from;
+      from++;
+   }
+   *to = '\0';
+}
+
+Descriptor *Descriptor::getDescriptor(CharArray da, DescriptorTagDomain domain) {
+   Descriptor *d=0;
+   switch (domain) {
+   case SI:
+      switch ((DescriptorTag)da.getData<DescriptorHeader>()->descriptor_tag) {
+         case CaDescriptorTag:
+            d=new CaDescriptor();
+            break;
+         case CarouselIdentifierDescriptorTag:
+            d=new CarouselIdentifierDescriptor();
+            break;
+         case NetworkNameDescriptorTag:
+            d=new NetworkNameDescriptor();
+            break;
+         case ServiceListDescriptorTag:
+            d=new ServiceListDescriptor();
+            break;
+         case SatelliteDeliverySystemDescriptorTag:
+            d=new SatelliteDeliverySystemDescriptor();
+            break;
+         case CableDeliverySystemDescriptorTag:
+            d=new CableDeliverySystemDescriptor();
+            break;
+         case TerrestrialDeliverySystemDescriptorTag:
+            d=new TerrestrialDeliverySystemDescriptor();
+            break;
+         case BouquetNameDescriptorTag:
+            d=new BouquetNameDescriptor();
+            break;
+         case ServiceDescriptorTag:
+            d=new ServiceDescriptor();
+            break;
+         case NVODReferenceDescriptorTag:
+            d=new NVODReferenceDescriptor();
+            break;
+         case TimeShiftedServiceDescriptorTag:
+            d=new TimeShiftedServiceDescriptor();
+            break;
+         case ComponentDescriptorTag:
+            d=new ComponentDescriptor();
+            break;
+         case StreamIdentifierDescriptorTag:
+            d=new StreamIdentifierDescriptor();
+            break;
+         case SubtitlingDescriptorTag:
+            d=new SubtitlingDescriptor();
+            break;
+         case MultilingualNetworkNameDescriptorTag:
+            d=new MultilingualNetworkNameDescriptor();
+            break;
+         case MultilingualBouquetNameDescriptorTag:
+            d=new MultilingualBouquetNameDescriptor();
+            break;
+         case MultilingualServiceNameDescriptorTag:
+            d=new MultilingualServiceNameDescriptor();
+            break;
+         case MultilingualComponentDescriptorTag:
+            d=new MultilingualComponentDescriptor();
+            break;
+         case ServiceMoveDescriptorTag:
+            d=new ServiceMoveDescriptor();
+            break;
+         case FrequencyListDescriptorTag:
+            d=new FrequencyListDescriptor();
+            break;
+         case ServiceIdentifierDescriptorTag:
+            d=new ServiceIdentifierDescriptor();
+            break;
+         case CaIdentifierDescriptorTag:
+            d=new CaIdentifierDescriptor();
+            break;
+         case ShortEventDescriptorTag:
+            d=new ShortEventDescriptor();
+            break;
+         case ExtendedEventDescriptorTag:
+            d=new ExtendedEventDescriptor();
+            break;
+         case TimeShiftedEventDescriptorTag:
+            d=new TimeShiftedEventDescriptor();
+            break;
+         case ContentDescriptorTag:
+            d=new ContentDescriptor();
+            break;
+         case ParentalRatingDescriptorTag:
+            d=new ParentalRatingDescriptor();
+            break;
+         case ApplicationSignallingDescriptorTag:
+            d=new ApplicationSignallingDescriptor();
+            break;
+
+         //note that it is no problem to implement one
+         //of the unimplemented descriptors.
+
+         //defined in ISO-13818-1
+         case VideoStreamDescriptorTag:
+         case AudioStreamDescriptorTag:
+         case HierarchyDescriptorTag:
+         case RegistrationDescriptorTag:
+         case DataStreamAlignmentDescriptorTag:
+         case TargetBackgroundGridDescriptorTag:
+         case VideoWindowDescriptorTag:
+         case ISO639LanguageDescriptorTag:
+         case SystemClockDescriptorTag:
+         case MultiplexBufferUtilizationDescriptorTag:
+         case CopyrightDescriptorTag:
+         case MaximumBitrateDescriptorTag:
+         case PrivateDataIndicatorDescriptorTag:
+         case SmoothingBufferDescriptorTag:
+         case STDDescriptorTag:
+         case IBPDescriptorTag:
+
+         //defined in ETSI EN 300 468
+         case StuffingDescriptorTag:
+         case VBIDataDescriptorTag:
+         case VBITeletextDescriptorTag:
+         case CountryAvailabilityDescriptorTag:
+         case MocaicDescriptorTag:
+         case LinkageDescriptorTag:
+         case TeletextDescriptorTag:
+         case TelephoneDescriptorTag:
+         case LocalTimeOffsetDescriptorTag:
+         case PrivateDataSpecifierDescriptorTag:
+         case CellListDescriptorTag:
+         case CellFrequencyLinkDescriptorTag:
+         case ServiceAvailabilityDescriptorTag:
+         case ShortSmoothingBufferDescriptorTag:
+         case PartialTransportStreamDescriptorTag:
+         case DataBroadcastDescriptorTag:
+         case DataBroadcastIdDescriptorTag:
+         case CaSystemDescriptorTag:
+         case AC3DescriptorTag:
+         case DSNGDescriptorTag:
+         case PDCDescriptorTag:
+         case AncillaryDataDescriptorTag:
+         case AnnouncementSupportDescriptorTag:
+         case AdaptationFieldDataDescriptorTag:
+         case TransportStreamDescriptorTag:
+         default:
+            d=new UnimplementedDescriptor();
+            break;
+      }
+      break;
+   case MHP:
+      switch ((DescriptorTag)da.getData<DescriptorHeader>()->descriptor_tag) {
+      // They once again start with 0x00 (see page 234, MHP specification)
+         case MHP_ApplicationDescriptorTag:
+            d=new MHP_ApplicationDescriptor();
+            break;
+         case MHP_ApplicationNameDescriptorTag:
+            d=new MHP_ApplicationNameDescriptor();
+            break;
+         case MHP_TransportProtocolDescriptorTag:
+            d=new MHP_TransportProtocolDescriptor();
+            break;
+         case MHP_DVBJApplicationDescriptorTag:
+            d=new MHP_DVBJApplicationDescriptor();
+            break;
+         case MHP_DVBJApplicationLocationDescriptorTag:
+            d=new MHP_DVBJApplicationLocationDescriptor();
+            break;
+      // 0x05 - 0x0A is unimplemented this library
+         case MHP_ExternalApplicationAuthorisationDescriptorTag:
+         case MHP_IPv4RoutingDescriptorTag:
+         case MHP_IPv6RoutingDescriptorTag:
+         case MHP_DVBHTMLApplicationDescriptorTag:
+         case MHP_DVBHTMLApplicationLocationDescriptorTag:
+         case MHP_DVBHTMLApplicationBoundaryDescriptorTag:
+         case MHP_ApplicationIconsDescriptorTag:
+         case MHP_PrefetchDescriptorTag:
+         case MHP_DelegatedApplicationDescriptorTag:
+         case MHP_ApplicationStorageDescriptorTag:
+         default:
+            d=new UnimplementedDescriptor();
+            break;
+      }
+      break;
+   }
+   d->setData(da);
+   return d;
+}
+
+} //end of namespace
diff --git a/libsi/si.h b/libsi/si.h
new file mode 100644
index 0000000..31d17cb
--- /dev/null
+++ b/libsi/si.h
@@ -0,0 +1,392 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: si.h 1.3 2003/12/26 14:09:30 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef LIBSI_SI_H
+#define LIBSI_SI_H
+
+#include <stdint.h>
+
+#include "util.h"
+#include "headers.h"
+
+namespace SI {
+
+enum TableId { TableIdPAT = 0x00, //program association section
+               TableIdCAT = 0x01, //conditional access section
+               TableIdPMT = 0x02, //program map section
+               TableIdTSDT = 0x03,//transport stream description section
+               TableIdNIT = 0x40, //network information, actual network section
+               TableIdNIT_other  = 0x41, //network information section, other network
+               TableIdSDT = 0x42, //service description section
+               TableIdSDT_other  = 0x46,
+               TableIdBAT = 0x46, //bouquet association section
+               TableIdEIT_presentFollowing = 0x4E, //event information section
+               TableIdEIT_presentFollowing_other = 0x4F,
+               //range from 0x50 to 0x5F
+               TableIdEIT_schedule_first = 0x50,
+               TableIdEIT_schedule_last = 0x5F,
+               //range from 0x60 to 0x6F
+               TableIdEIT_schedule_Other_first = 0x60,
+               TableIdEIT_schedule_Other_fast = 0x6F,
+               TableIdTDT = 0x70, //time date section
+               TableIdRST = 0x71, //running status section
+               TableIdST  = 0x72, //stuffing section
+               TableIdTOT = 0x73, //time offset section
+               TableIdDIT = 0x7E, //discontinuity information section
+               TableIdSIT = 0x7F, //service information section
+               TableIdAIT = 0x74  //application information section
+             };
+
+
+enum DescriptorTag {
+  // defined by ISO/IEC 13818-1
+               VideoStreamDescriptorTag = 0x02,
+               AudioStreamDescriptorTag = 0x03,
+               HierarchyDescriptorTag = 0x04,
+               RegistrationDescriptorTag = 0x05,
+               DataStreamAlignmentDescriptorTag = 0x06,
+               TargetBackgroundGridDescriptorTag = 0x07,
+               VideoWindowDescriptorTag = 0x08,
+               CaDescriptorTag = 0x09,
+               ISO639LanguageDescriptorTag = 0x0A,
+               SystemClockDescriptorTag = 0x0B,
+               MultiplexBufferUtilizationDescriptorTag = 0x0C,
+               CopyrightDescriptorTag = 0x0D,
+               MaximumBitrateDescriptorTag = 0x0E,
+               PrivateDataIndicatorDescriptorTag = 0x0F,
+               SmoothingBufferDescriptorTag = 0x10,
+               STDDescriptorTag = 0x11,
+               IBPDescriptorTag = 0x12,
+  // defined by ISO-13818-6 (DSM-CC)
+               CarouselIdentifierDescriptorTag = 0x13,
+               // 0x14 - 0x3F  Reserved
+  // defined by ETSI (EN 300 468)
+               NetworkNameDescriptorTag = 0x40,
+               ServiceListDescriptorTag = 0x41,
+               StuffingDescriptorTag = 0x42,
+               SatelliteDeliverySystemDescriptorTag = 0x43,
+               CableDeliverySystemDescriptorTag = 0x44,
+               VBIDataDescriptorTag = 0x45,
+               VBITeletextDescriptorTag = 0x46,
+               BouquetNameDescriptorTag = 0x47,
+               ServiceDescriptorTag = 0x48,
+               CountryAvailabilityDescriptorTag = 0x49,
+               LinkageDescriptorTag = 0x4A,
+               NVODReferenceDescriptorTag = 0x4B,
+               TimeShiftedServiceDescriptorTag = 0x4C,
+               ShortEventDescriptorTag = 0x4D,
+               ExtendedEventDescriptorTag = 0x4E,
+               TimeShiftedEventDescriptorTag = 0x4F,
+               ComponentDescriptorTag = 0x50,
+               MocaicDescriptorTag = 0x51,
+               StreamIdentifierDescriptorTag = 0x52,
+               CaIdentifierDescriptorTag = 0x53,
+               ContentDescriptorTag = 0x54,
+               ParentalRatingDescriptorTag = 0x55,
+               TeletextDescriptorTag = 0x56,
+               TelephoneDescriptorTag = 0x57,
+               LocalTimeOffsetDescriptorTag = 0x58,
+               SubtitlingDescriptorTag = 0x59,
+               TerrestrialDeliverySystemDescriptorTag = 0x5A,
+               MultilingualNetworkNameDescriptorTag = 0x5B,
+               MultilingualBouquetNameDescriptorTag = 0x5C,
+               MultilingualServiceNameDescriptorTag = 0x5D,
+               MultilingualComponentDescriptorTag = 0x5E,
+               PrivateDataSpecifierDescriptorTag = 0x5F,
+               ServiceMoveDescriptorTag = 0x60,
+               ShortSmoothingBufferDescriptorTag = 0x61,
+               FrequencyListDescriptorTag = 0x62,
+               PartialTransportStreamDescriptorTag = 0x63,
+               DataBroadcastDescriptorTag = 0x64,
+               CaSystemDescriptorTag = 0x65,
+               DataBroadcastIdDescriptorTag = 0x66,
+               TransportStreamDescriptorTag = 0x67,
+               DSNGDescriptorTag = 0x68,
+               PDCDescriptorTag = 0x69,
+               AC3DescriptorTag = 0x6A,
+               AncillaryDataDescriptorTag = 0x6B,
+               CellListDescriptorTag = 0x6C,
+               CellFrequencyLinkDescriptorTag = 0x6D,
+               AnnouncementSupportDescriptorTag = 0x6E,
+               ApplicationSignallingDescriptorTag = 0x6F,
+               AdaptationFieldDataDescriptorTag = 0x70,
+               ServiceIdentifierDescriptorTag = 0x71,
+               ServiceAvailabilityDescriptorTag = 0x72,
+ // Defined by ETSI TS 102 812 (MHP)
+               // They once again start with 0x00 (see page 234, MHP specification)
+               MHP_ApplicationDescriptorTag = 0x00,
+               MHP_ApplicationNameDescriptorTag = 0x01,
+               MHP_TransportProtocolDescriptorTag = 0x02,
+               MHP_DVBJApplicationDescriptorTag = 0x03,
+               MHP_DVBJApplicationLocationDescriptorTag = 0x04,
+               // 0x05 - 0x0A is unimplemented this library
+               MHP_ExternalApplicationAuthorisationDescriptorTag = 0x05,
+               MHP_IPv4RoutingDescriptorTag = 0x06,
+               MHP_IPv6RoutingDescriptorTag = 0x07,
+               MHP_DVBHTMLApplicationDescriptorTag = 0x08,
+               MHP_DVBHTMLApplicationLocationDescriptorTag = 0x09,
+               MHP_DVBHTMLApplicationBoundaryDescriptorTag = 0x0A,
+               MHP_ApplicationIconsDescriptorTag = 0x0B,
+               MHP_PrefetchDescriptorTag = 0x0C,
+               MHP_DelegatedApplicationDescriptorTag = 0x0E,
+               MHP_ApplicationStorageDescriptorTag = 0x10,
+
+               //a descriptor currently unimplemented in this library
+               //the actual value 0xFF is "forbidden" according to the spec.
+               UnimplementedDescriptorTag = 0xFF
+};
+
+enum DescriptorTagDomain { SI, MHP };
+
+enum RunningStatus { RunningStatusUndefined = 0,
+                     RunningStatusNotRunning = 1,
+                     RunningStatusStartsInAFewSeconds = 2,
+                     RunningStatusPausing = 3,
+                     RunningStatusRunning = 4
+                   };
+
+/* Some principles:
+   - Objects that return references to other objects contained in their data must make sure
+     that the returned objects have been parsed.
+     (the Loop subclasses take care of that.)
+     Note that this does not apply to Loops and Strings (their are never returned by reference, BTW).
+*/
+
+class Object : public Parsable {
+public:
+   Object();
+   Object(CharArray &d);
+   //can only be called once since data is immutable
+   void setData(const unsigned char*data, unsigned int size, bool doCopy=true);
+   virtual int getLength() = 0;
+protected:
+   CharArray data;
+   //is protected - not used for sections
+   template <class T> friend class StructureLoop;
+   void setData(CharArray &d);
+};
+
+class Section : public Object {
+public:
+   //convenience: sets data and parses if doParse
+   Section(const unsigned char *data, bool doCopy=true);
+   Section() {}
+   TableId getTableId() const;
+   virtual int getLength();
+
+   static int getLength(const unsigned char *d);
+   static TableId getTableId(const unsigned char *d);
+};
+
+class CRCSection : public Section {
+public:
+   //convenience: sets data and parses if doParse
+   CRCSection(const unsigned char *data, bool doCopy=true) : Section(data, doCopy) {}
+   CRCSection() {}
+   bool isValid();
+   //convenience: isValid+CheckParse
+   bool CheckCRCAndParse();
+};
+
+/* A section which has the ExtendedSectionHeader
+   (section_syntax_indicator==1) */
+class NumberedSection : public CRCSection {
+public:
+   NumberedSection(const unsigned char *data, bool doCopy=true) : CRCSection(data, doCopy) {}
+   NumberedSection() {}
+   bool getCurrentNextIndicator() const;
+   int getVersionNumber() const;
+   int getSectionNumber() const;
+   int getLastSectionNumber() const;
+   bool moreThanOneSection()  const { return getLastSectionNumber()>1; }
+};
+
+class VariableLengthPart : public Object {
+public:
+   //never forget to call this
+   void setData(CharArray d, int l) { Object::setData(d); length=l; }
+   //convenience method
+   void setDataAndOffset(CharArray d, int l, unsigned int &offset) { Object::setData(d); length=l; offset+=l; }
+   virtual int getLength() { return length; }
+private:
+   int length;
+};
+
+class LoopElement : public Object {
+};
+
+class SubStructure : public LoopElement {
+};
+
+class Descriptor : public LoopElement {
+public:
+   virtual int getLength();
+   DescriptorTag getDescriptorTag() const;
+
+   static int getLength(const unsigned char *d);
+   static DescriptorTag getDescriptorTag(const unsigned char *d);
+protected:
+   friend class DescriptorLoop;
+   //returns a subclass of descriptor according to the data given.
+   //The object is allocated with new and must be delete'd.
+   //setData() will have been called, CheckParse() not.
+   //Never returns null - maybe the UnimplementedDescriptor.
+   static Descriptor *getDescriptor(CharArray d, DescriptorTagDomain domain);
+};
+
+class Loop : public VariableLengthPart {
+public:
+   class Iterator {
+   public:
+      Iterator() { i=0; }
+      void reset() { i=0; }
+   private:
+      template <class T> friend class StructureLoop;
+      friend class DescriptorLoop;
+      template <class T> friend class TypeLoop;
+      int i;
+   };
+protected:
+   virtual void Parse() {}
+};
+
+//contains LoopElements of one type only
+template <class T> class StructureLoop : public Loop {
+public:
+   //currently you must use a while-loop testing for hasNext()
+   //i must be 0 to get the first descriptor (with the first call)
+   T getNext(Iterator &it)
+      {
+         CharArray d=data;
+         d.addOffset(it.i);
+         T ret;
+         ret.setData(d);
+         ret.CheckParse();
+         it.i+=ret.getLength();
+         return ret;
+      }
+   T* getNextAsPointer(Iterator &it)
+      {
+         if (getLength() <= it.i)
+            return 0;
+         CharArray d=data;
+         d.addOffset(it.i);
+         T *ret=new T();
+         ret->setData(d);
+         ret->CheckParse();
+         it.i+=ret->getLength();
+         return ret;
+      }
+   bool hasNext(Iterator &it) { return getLength() > it.i; }
+};
+
+//contains descriptors of different types
+class DescriptorLoop : public Loop {
+public:
+   DescriptorLoop() { domain=SI; }
+   //i must be 0 to get the first descriptor (with the first call)
+   //All returned descriptors must be delete'd.
+   //returns null if no more descriptors available
+   Descriptor *getNext(Iterator &it);
+   //return the next descriptor with given tag, or 0 if not available.
+   //if the descriptor found is not implemented,
+   // an UnimplementedDescriptor will be returned if returnUnimplemetedDescriptor==true,
+   // 0 will be returned if returnUnimplemetedDescriptor==false
+   Descriptor *getNext(Iterator &it, DescriptorTag tag, bool returnUnimplemetedDescriptor=false);
+   //return the next descriptor with one of the given tags, or 0 if not available.
+   Descriptor *getNext(Iterator &it, DescriptorTag *tags, int arrayLength, bool returnUnimplemetedDescriptor=false);
+protected:
+   Descriptor *createDescriptor(int &i);
+   DescriptorTagDomain domain;
+};
+
+typedef uint8_t   EightBit;
+typedef uint16_t  SixteenBit;
+typedef uint32_t  ThirtyTwoBit;
+typedef uint64_t  SixtyFourBit;
+
+template <typename T> class TypeLoop : public Loop {
+public:
+   int getCount() const { return getLength()/sizeof(T); }
+   T operator[](const unsigned int index) const
+      {
+         switch (sizeof(T)) {
+         case 1:
+            return data[index];
+         case 2:
+            return data.TwoBytes(index);
+         case 4:
+            return data.FourBytes(index);
+         case 8:
+            return (SixtyFourBit(data.FourBytes(index)) << 32) | data.FourBytes(index+4);
+         }
+      }
+   T getNext(Iterator &it) const
+      {
+         T ret=operator[](it.i);
+         it.i+=sizeof(T);
+         return ret;
+      }
+   bool hasNext(Iterator &it) { return getLength() > it.i; }
+};
+
+class MHP_DescriptorLoop : public DescriptorLoop {
+public:
+   MHP_DescriptorLoop() { domain=MHP; }
+};
+
+//The content of the ExtendedEventDescriptor may be split over several
+//descriptors if the text is longer than 256 bytes.
+//The following classes provide base functionality to handle this case.
+class GroupDescriptor : public Descriptor {
+public:
+   virtual int getDescriptorNumber() = 0;
+   virtual int getLastDescriptorNumber() = 0;
+};
+
+class DescriptorGroup {
+public:
+   DescriptorGroup(bool deleteOnDesctruction=true);
+   ~DescriptorGroup();
+   void Add(GroupDescriptor *d);
+   void Delete();
+   int getLength() { return length; }
+   GroupDescriptor **getDescriptors() { return array; }
+   bool isComplete(); //if all descriptors have been added
+protected:
+   int length;
+   GroupDescriptor **array;
+   bool deleteOnDesctruction;
+};
+
+class String : public VariableLengthPart {
+public:
+   //A note to the length: getLength() returns the length of the raw data.
+   //The text may be shorter. Its length can be obtained with one of the
+   //above functions and strlen.
+
+   //returns text. Data is allocated with new and must be delete'd by the user.
+   char *getText();
+   //copies text into given buffer.
+   //a buffer of size getLength()+1 is guaranteed to be sufficiently large.
+   //In most descriptors the string length is an 8-bit field,
+   //so the maximum there is 256.
+   //returns the given buffer for convenience.
+   char * getText(char *buffer);
+protected:
+   virtual void Parse() {}
+   void decodeText(char *buffer);
+};
+
+} //end of namespace
+
+#endif //LIBSI_SI_H
diff --git a/libsi/util.c b/libsi/util.c
new file mode 100644
index 0000000..a2a6f0d
--- /dev/null
+++ b/libsi/util.c
@@ -0,0 +1,281 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg, Rolf Hakenes                *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: util.c 1.3 2003/12/22 14:03:03 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#include <string.h>
+#include "util.h"
+
+namespace SI {
+
+/*---------------------------- CharArray ----------------------------*/
+
+CharArray::CharArray() : data_(0), off(0) {
+}
+
+CharArray::~CharArray() {
+   if (!data_)
+      return;
+   if (--data_->count_ == 0)
+      delete data_;
+}
+
+CharArray::CharArray(const CharArray &f) : data_(f.data_), off(f.off) {
+   if (data_)
+      ++ data_->count_;
+}
+
+CharArray& CharArray::operator=(const CharArray &f) {
+    // DO NOT CHANGE THE ORDER OF THESE STATEMENTS!
+    // (This order properly handles self-assignment)
+    if (f.data_) {
+      ++ f.data_->count_;
+    }
+    if (data_) {
+      if (--data_->count_ == 0)
+         delete data_;
+    }
+    data_ = f.data_;
+    off = f.off;
+    return *this;
+}
+
+void CharArray::assign(const unsigned char*data, unsigned int size, bool doCopy) {
+    //immutable
+    if (!data_)
+      data_= doCopy ? (Data*)new DataOwnData() : (Data*)new DataForeignData();
+    // This method might need to change things in *data_
+    // Thus it first checks if this is the only pointer to *data_
+    if (data_->count_ > 1) {
+      Data* d = doCopy ? (Data*)new DataOwnData() : (Data*)new DataForeignData();
+      -- data_->count_;
+      data_ = d;
+    }
+    data_->assign(data, size);
+}
+
+bool CharArray::operator==(const char *string) const {
+   //here we can use strcmp, string is null-terminated.
+   if (!data_)
+      return false;
+   return data_->size ? (!strcmp((const char*)data_->data, string)) : string[0]==0;
+}
+
+bool CharArray::operator==(const CharArray &other) const {
+   if (!data_ || !other.data_)
+      return !(data_ || other.data_); //true if both empty
+
+   if (data_->size != other.data_->size)
+      return false;
+
+   //do _not_ use strcmp! Data is not necessarily null-terminated.
+   for (unsigned int i=0;i<data_->size;i++)
+      if (data_->data[i] != other.data_->data[i])
+         return false;
+   return true;
+}
+
+CharArray CharArray::operator+(const unsigned int offset) const {
+   CharArray f(*this);
+   f.off+=offset;
+   return f;
+}
+
+CharArray::Data::Data() : count_(1) {
+   size=0;
+   data=0;
+   /*
+   lockingPid = 0;
+   locked = 0;
+   pthread_mutex_init(&mutex, NULL);
+   */
+}
+
+CharArray::Data::~Data() {
+   /*
+   if (locked)
+      pthread_mutex_unlock(&mutex);
+   pthread_mutex_destroy(&mutex);
+   */
+}
+
+/*CharArray::Data::Data(const Data& d) : count_(1) {
+   size=0;
+   data=0;
+
+   lockingPid = 0;
+   locked = 0;
+   pthread_mutex_init(&mutex, NULL);
+}*/
+
+CharArray::DataOwnData::~DataOwnData() {
+   Delete();
+}
+
+void CharArray::DataOwnData::assign(const unsigned char*d, unsigned int s) {
+   Delete();
+   size=s;
+   unsigned char *newdata=new unsigned char[size];
+   memcpy(newdata, d, size);
+   data=newdata;
+}
+
+void CharArray::DataOwnData::Delete() {
+   delete[] data;
+}
+
+CharArray::DataForeignData::~DataForeignData() {
+   Delete();
+}
+
+void CharArray::DataForeignData::assign(const unsigned char*d, unsigned int s) {
+   size=s;
+   data=d;
+}
+
+void CharArray::DataForeignData::Delete() {
+   //do not delete!
+}
+
+/*
+void CharArray::Data::assign(unsigned int s) {
+   if (data)
+      delete[] data;
+   size=s;
+   if (size) { //new assignment may be zero length
+      data=new unsigned char[size];
+      memset(data, 0, size);
+   }
+}
+
+void CharArray::Data::Lock(void)
+{
+  if ( !pthread_equal(pthread_self(), lockingPid) || !locked) {
+     pthread_mutex_lock(&mutex);
+     lockingPid = pthread_self();
+     }
+  locked++;
+}
+
+void CharArray::Data::Unlock(void)
+{
+   if (!--locked) {
+     lockingPid = 0;
+     pthread_mutex_unlock(&mutex);
+   }
+}
+*/
+
+Parsable::Parsable() {
+   parsed=false;
+}
+
+void Parsable::CheckParse() {
+   if (!parsed) {
+      parsed=true;
+      Parse();
+   }
+}
+
+//taken and adapted from libdtv, (c) Rolf Hakenes and VDR, (c) Klaus Schmidinger
+time_t DVBTime::getTime(unsigned char date_hi, unsigned char date_lo, unsigned char time_hour, unsigned char time_minute, unsigned char time_second) {
+   u_int16_t mjd = date_hi << 8 | date_lo;
+   struct tm t;
+
+   t.tm_sec = bcdToDec(time_second);
+   t.tm_min = bcdToDec(time_minute);
+   t.tm_hour = bcdToDec(time_hour);
+
+   int k;
+   t.tm_year = (int) ((mjd - 15078.2) / 365.25);
+   t.tm_mon = (int) ((mjd - 14956.1 - (int)(t.tm_year * 365.25)) / 30.6001);
+   t.tm_mday = (int) (mjd - 14956 - (int)(t.tm_year * 365.25) - (int)(t.tm_mon * 30.6001));
+   k = (t.tm_mon == 14 || t.tm_mon == 15) ? 1 : 0;
+   t.tm_year = t.tm_year + k;
+   t.tm_mon = t.tm_mon - 1 - k * 12;
+   t.tm_mon--;
+
+   t.tm_isdst = -1;
+   t.tm_gmtoff = 0;
+
+   return timegm(&t);
+}
+
+time_t DVBTime::getDuration(unsigned char time_hour, unsigned char time_minute, unsigned char time_second) {
+   return
+     bcdToDec(time_second)
+   + bcdToDec(time_minute) * 60
+   + bcdToDec(time_hour) *3600;
+}
+
+//taken and adapted from libdtv, (c) Rolf Hakenes
+// CRC32 lookup table for polynomial 0x04c11db7
+u_int32_t CRC32::crc_table[256] = {
+   0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
+   0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
+   0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd, 0x4c11db70, 0x48d0c6c7,
+   0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+   0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3,
+   0x709f7b7a, 0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
+   0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58, 0xbaea46ef,
+   0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+   0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb,
+   0xceb42022, 0xca753d95, 0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
+   0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
+   0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+   0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x018aeb13, 0x054bf6a4,
+   0x0808d07d, 0x0cc9cdca, 0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
+   0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08,
+   0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+   0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc,
+   0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
+   0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a, 0xe0b41de7, 0xe4750050,
+   0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+   0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
+   0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
+   0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb, 0x4f040d56, 0x4bc510e1,
+   0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+   0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5,
+   0x3f9b762c, 0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
+   0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e, 0xf5ee4bb9,
+   0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+   0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd,
+   0xcda1f604, 0xc960ebb3, 0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
+   0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
+   0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+   0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2,
+   0x470cdd2b, 0x43cdc09c, 0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
+   0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e,
+   0x18197087, 0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
+   0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a,
+   0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
+   0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c, 0xe3a1cbc1, 0xe760d676,
+   0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+   0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
+   0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
+   0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4};
+
+u_int32_t CRC32::crc32 (const char *d, int len, u_int32_t crc)
+{
+   register int i;
+
+   for (i=0; i<len; i++)
+      crc = (crc << 8) ^ crc_table[((crc >> 24) ^ *d++) & 0xff];
+
+   return crc;
+}
+
+CRC32::CRC32(const char *d, int len, u_int32_t CRCvalue) {
+   data=d;
+   length=len;
+   value=CRCvalue;
+}
+
+} //end of namespace
diff --git a/libsi/util.h b/libsi/util.h
new file mode 100644
index 0000000..db01923
--- /dev/null
+++ b/libsi/util.h
@@ -0,0 +1,157 @@
+/***************************************************************************
+ *       Copyright (c) 2003 by Marcel Wiesweg                              *
+ *                                                                         *
+ *   This program 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 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   $Id: util.h 1.3 2003/12/22 14:07:41 kls Exp $
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef LIBSI_UTIL_H
+#define LIBSI_UTIL_H
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <pthread.h>
+#include <time.h>
+
+#define HILO(x) (x##_hi << 8 | x##_lo)
+#define BCD_TIME_TO_SECONDS(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)))
+
+namespace SI {
+
+//Holds an array of unsigned char which is deleted
+//when the last object pointing to it is deleted.
+//Optimized for use in libsi.
+class CharArray {
+public:
+   CharArray();
+
+   CharArray(const CharArray &source);
+   CharArray& operator=(const CharArray &source);
+   ~CharArray();
+
+   //can be called exactly once
+   void assign(const unsigned char*data, unsigned int size, bool doCopy=true);
+   //compares to a null-terminated string
+   bool operator==(const char *string) const;
+   //compares to another CharArray (data not necessarily null-terminated)
+   bool operator==(const CharArray &other) const;
+
+   //returns another CharArray with its offset incremented by offset
+   CharArray operator+(const unsigned int offset) const;
+
+   //access and convenience methods
+   const unsigned char* getData() const { return data_->data+off; }
+   const unsigned char* getData(int offset) const { return data_->data+offset+off; }
+   template <typename T> const T* getData() const { return (T*)(data_->data+off); }
+   template <typename T> const T* getData(int offset) const { return (T*)(data_->data+offset+off); }
+      //sets p to point to data+offset, increments offset
+   template <typename T> void setPointerAndOffset(const T* &p, unsigned int &offset) const { p=(T*)getData(offset); offset+=sizeof(T); }
+   unsigned char operator[](const unsigned int index) const { return data_->data ? data_->data[off+index] : 0; }
+   int getLength() const { return data_->size; }
+   u_int16_t TwoBytes(const unsigned int index) const { return data_->data ? data_->TwoBytes(off+index) : 0; }
+   u_int32_t FourBytes(const unsigned int index) const { return data_->data ? data_->FourBytes(off+index) : 0; }
+
+   void addOffset(unsigned int offset) { off+=offset; }
+private:
+   class Data {
+   public:
+      Data();
+      virtual ~Data();
+
+      virtual void assign(const unsigned char*data, unsigned int size) = 0;
+      virtual void Delete() = 0;
+
+      u_int16_t TwoBytes(const unsigned int index) const
+         { return (data[index] << 8) | data[index+1]; }
+      u_int32_t FourBytes(const unsigned int index) const
+         { return (data[index] << 24) | (data[index+1] << 16) | (data[index+2] << 8) | data[index+3]; }
+      /*#ifdef CHARARRAY_THREADSAFE
+      void Lock();
+      void Unlock();
+      #else
+      void Lock() {}
+      void Unlock() {}
+      #endif
+      Data(const Data& d);
+      void assign(unsigned int size);
+      */
+
+      const unsigned char*data;
+      unsigned int size;
+
+      unsigned count_;
+      // count_ is the number of CharArray objects that point at this
+      // count_ must be initialized to 1 by all constructors
+      // (it starts as 1 since it is pointed to by the CharArray object that created it)
+
+      /*
+      pthread_mutex_t mutex;
+      pid_t lockingPid;
+      pthread_t locked;
+      */
+   };
+   class DataOwnData : public Data {
+   public:
+      DataOwnData() {}
+      virtual ~DataOwnData();
+      virtual void assign(const unsigned char*data, unsigned int size);
+      virtual void Delete();
+   };
+   class DataForeignData : public Data {
+   public:
+      DataForeignData() {}
+      virtual ~DataForeignData();
+      virtual void assign(const unsigned char*data, unsigned int size);
+      virtual void Delete();
+   };
+   Data* data_;
+   unsigned int off;
+};
+
+
+
+//abstract base class
+class Parsable {
+public:
+   void CheckParse();
+protected:
+   Parsable();
+   virtual ~Parsable() {}
+   //actually parses given data.
+   virtual void Parse() = 0;
+private:
+   bool parsed;
+};
+
+//taken and adapted from libdtv, (c) Rolf Hakenes and VDR, (c) Klaus Schmidinger
+namespace DVBTime {
+time_t getTime(unsigned char date_hi, unsigned char date_lo, unsigned char timehr, unsigned char timemi, unsigned char timese);
+time_t getDuration(unsigned char timehr, unsigned char timemi, unsigned char timese);
+inline unsigned char bcdToDec(unsigned char b) { return ((b >> 4) & 0x0F) * 10 + (b & 0x0F); }
+};
+
+//taken and adapted from libdtv, (c) Rolf Hakenes
+class CRC32 {
+public:
+   CRC32(const char *d, int len, u_int32_t CRCvalue=0xFFFFFFFF);
+   bool isValid() { return crc32(data, length, value) == 0; }
+   static bool isValid(const char *d, int len, u_int32_t CRCvalue=0xFFFFFFFF) { return crc32(d, len, CRCvalue) == 0; }
+protected:
+   static u_int32_t crc_table[256];
+   static u_int32_t crc32 (const char *d, int len, u_int32_t CRCvalue);
+
+   const char *data;
+   int length;
+   u_int32_t value;
+};
+
+} //end of namespace
+
+#endif