frodovdr/vdr
1
0
Fork 0
mirror of https://github.com/vdr-projects/vdr.git synced 2025-03-01 10:50:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
vdr/libsi/si.h
Klaus Schmidinger a592125294 Version 1.5.2 
- Updated the Finnish OSD texts (thanks to Rolf Ahrenberg).
- Fixed handling user activity for shutdown, which I had messed when adopting Udo's
  original patch (thanks to Udo Richter).
- Added Turkish language texts (thanks to Oktay Yolgeçen).
- Added missing rules for generating iso8859-13 font to Makefile.
- 'libsi' now converts the incoming strings into the system's character set
  according to the DVB standard. The system's character set is determined from
  the LANG environment variable. If no recognizable setting can be found, no
  conversion will take place. Note that currently only the strings received from the
  SI data stream are converted, there have not been any changes regarding displaying
  UTF-8 characters on the OSD, yet - this will follow in one of the next steps.
  With this conversion, it should now be safe to run VDR on a UTF-8 file system,
  because all incoming characters are converted to UTF-8. This will most likely
  result in wrong characters being displayed on the OSD (because there UTF-8 is
  not known, yet), but the file names should be ok (haven't tested this myself,
  though, because I don't do UTF-8 - so please be very careful when testing!).
  There's one piece of bad news here: the German pay-tv broadcaster Premiere
  apparently encodes all EPG strings as ISO8859-1, but fails to correctly mark
  these strings as such. Therefore 'libsi' (following the DVB standard) considers
  the strings to be encoded in the default ISO6937 and converts them to whatever
  the system's character set is. This, of course, results in wrong umlauts.
  On its old transponder, the ProSieben/SAT.1 channels also had their EPG data
  wrongly encoded, but apparently on the new transponder they started broadcasting
  on this month, they got it right.
2007-04-22 18:00:00 +02:00

497 lines
20 KiB
C++
Raw Blame History

/***************************************************************************
* 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.17 2007/04/22 13:32:09 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_last = 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
TableIdPremiereCIT = 0xA0 //premiere content 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,
ScramblingDescriptorTag = 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 (EN 300 468) v 1.7.1
DefaultAuthorityDescriptorTag = 0x73,
RelatedContentDescriptorTag = 0x74,
TVAIdDescriptorTag = 0x75,
ContentIdentifierDescriptorTag = 0x76,
TimeSliceFecIdentifierDescriptorTag = 0x77,
ECMRepetitionRateDescriptorTag = 0x78,
S2SatelliteDeliverySystemDescriptorTag = 0x79,
EnhancedAC3DescriptorTag = 0x7A,
DTSDescriptorTag = 0x7B,
AACDescriptorTag = 0x7C,
ExtensionDescriptorTag = 0x7F,
// 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,
// Premiere private Descriptor Tags
PremiereContentTransmissionDescriptorTag = 0xF2,
//a descriptor currently unimplemented in this library
//the actual value 0xFF is "forbidden" according to the spec.
UnimplementedDescriptorTag = 0xFF
};
enum DescriptorTagDomain { SI, MHP, PCIT };
enum RunningStatus { RunningStatusUndefined = 0,
RunningStatusNotRunning = 1,
RunningStatusStartsInAFewSeconds = 2,
RunningStatusPausing = 3,
RunningStatusRunning = 4
};
enum LinkageType { LinkageTypeInformationService = 0x01,
LinkageTypeEPGService = 0x02,
LinkageTypeCaReplacementService = 0x03,
LinkageTypeTSContainingCompleteNetworkBouquetSi = 0x04,
LinkageTypeServiceReplacementService = 0x05,
LinkageTypeDataBroadcastService = 0x06,
LinkageTypeRCSMap = 0x07,
LinkageTypeMobileHandover = 0x08,
LinkageTypeSystemSoftwareUpdateService = 0x09,
LinkageTypeTSContainingSsuBatOrNit = 0x0A
};
enum AudioType { AudioTypeUndefined = 0x00,
AudioTypeCleanEffects = 0x01,
AudioTypeHearingImpaired = 0x02,
AudioTypeVisualImpairedCommentary = 0x03
};
/* 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, int size, bool doCopy=true);
CharArray getData() { return data; }
//returns the valid flag which indicates if data is all right or errors have been encountered
bool isValid() { return data.isValid(); }
virtual int getLength() = 0;
protected:
CharArray data;
//is protected - not used for sections
template <class T> friend class StructureLoop;
void setData(CharArray &d);
//returns whether the given offset fits within the limits of the actual data
//The valid flag will be set accordingly
bool checkSize(int offset);
};
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 isCRCValid();
//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() {}
int getTableIdExtension() const;
bool getCurrentNextIndicator() const;
int getVersionNumber() const;
int getSectionNumber() const;
int getLastSectionNumber() const;
bool moreThanOneSection() const { return getLastSectionNumber()>0; }
static int getTableIdExtension(const unsigned char *d);
};
class VariableLengthPart : public Object {
public:
//never forget to call this
void setData(CharArray d, int l) { Object::setData(d); checkSize(l); length=l; }
//convenience method
void setDataAndOffset(CharArray d, int l, int &offset) { Object::setData(d); checkSize(l); length=l; offset+=l; }
virtual int getLength() { return length; }
private:
int length;
};
class LoopElement : public Object {
};
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.
//if returnUnimplemetedDescriptor==true:
// Never returns null - maybe the UnimplementedDescriptor.
//if returnUnimplemetedDescriptor==false:
// Never returns the UnimplementedDescriptor - maybe null
static Descriptor *getDescriptor(CharArray d, DescriptorTagDomain domain, bool returnUnimplemetedDescriptor);
};
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;
friend class ExtendedEventDescriptors;
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)
bool getNext(T &obj, Iterator &it)
{
if (!isValid() || it.i >= getLength())
return false;
CharArray d=data;
d.addOffset(it.i);
T ret;
ret.setData(d);
ret.CheckParse();
if (!checkSize(ret.getLength()))
return false;
it.i+=ret.getLength();
obj=ret;
return true;
}
T* getNextAsPointer(Iterator &it)
{
if (!isValid() || it.i >= getLength())
return 0;
CharArray d=data;
d.addOffset(it.i);
T *ret=new T();
ret->setData(d);
ret->CheckParse();
if (!checkSize(ret->getLength()))
return 0;
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 returnUnimplemetedDescriptor==true:
// an UnimplementedDescriptor may be returned if the next matching descriptor is unimplemented,
// 0 will be returned if and only if no matching descriptor is found.
//if returnUnimplemetedDescriptor==false:
// if 0 is returned, either no descriptor with the given tag was found,
// or descriptors were found, but the descriptor type is not implemented
//In either case, a return value of 0 indicates that no further calls to this method
//with the iterator shall be made.
Descriptor *getNext(Iterator &it, DescriptorTag tag, bool returnUnimplemetedDescriptor=false);
//return the next descriptor with one of the given tags, or 0 if not available.
//if returnUnimplemetedDescriptor==true:
// returns 0 if and only if no descriptor with one of the given tags was found.
// The UnimplementedDescriptor may be returned.
//if returnUnimplemetedDescriptor==false:
// if 0 is returned, either no descriptor with one of the given tags was found,
// or descriptors were found, but none of them are implemented.
// The UnimplementedDescriptor will never be returned.
//In either case, a return value of 0 indicates that no further calls to this method
//with the iterator shall be made.
Descriptor *getNext(Iterator &it, DescriptorTag *tags, int arrayLength, bool returnUnimplemetedDescriptor=false);
//returns the number of descriptors in this loop
int getNumberOfDescriptors();
//writes the tags of the descriptors in this loop in the array,
// which must at least have the size getNumberOfDescriptors().
//The number of descriptors, i.e. getNumberOfDescriptors(), is returned.
// You can specify the array type (Descriptor tags are 8 Bit,
// you might e.g. choose a char, short, int or DescriptorTag array)
template <typename T> int getDescriptorTags(T *tags)
{
const unsigned char *p=data.getData();
const unsigned char *end=p+getLength();
int count=0;
while (p < end) {
tags[count++]=(T)Descriptor::getDescriptorTag(p);
p+=Descriptor::getLength(p);
}
return count;
}
protected:
Descriptor *createDescriptor(int &i, bool returnUnimplemetedDescriptor);
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() { return getLength()/sizeof(T); }
T operator[](const 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);
}
return 0; // just to avoid a compiler warning
}
T getNext(Iterator &it) const
{
T ret=operator[](it.i);
it.i+=sizeof(T);
return ret;
}
bool hasNext(Iterator &it) { return isValid() && (getLength() > it.i); }
};
class MHP_DescriptorLoop : public DescriptorLoop {
public:
MHP_DescriptorLoop() { domain=MHP; }
};
//Premiere Content Information Table
class PCIT_DescriptorLoop : public DescriptorLoop {
public:
PCIT_DescriptorLoop() { domain=PCIT; }
};
//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
//getText 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.
//The emphasis marks 0x86 and 0x87 are still available.
char *getText(char *buffer, int size);
//The same semantics as for getText(char*) apply.
//The short version of the text according to ETSI TR 101 211 (chapter 4.6)
//will be written into the shortVersion buffer (which should, therefore, have the same
//length as buffer). If no shortVersion is available, shortVersion will contain
//an empty string.
//The emphasis marks 0x86 and 0x87 are still available in buffer, but not in shortVersion.
char *getText(char *buffer, char *shortVersion, int sizeBuffer, int sizeShortVersion);
protected:
virtual void Parse() {}
void decodeText(char *buffer, int size);
void decodeText(char *buffer, char *shortVersion, int sizeBuffer, int sizeShortVersion);
};
// Call this function to set the system character table. CharacterTable is a string
// like "iso8859-15" or "utf-8" (case insensitive).
// Returns true if the character table was recognized.
bool SetSystemCharacterTable(const char *CharacterTable);
} //end of namespace
#endif //LIBSI_SI_H
Reference in New Issue View Git Blame Copy Permalink