Ticket #5530: csat-eit.diff

mythtv/libs/libmythtv/mpeg/csatcaraibesdescriptors.cpp

@@ +1 @@
+#include "mpegdescriptors.h"
+#include "csatcaraibesdescriptors.h"
+
+/****************** Schedule *******************************/
+
+void CSatCaraibesChannelsDescriptor::Parse(void)
+{
+    const unsigned char * p = _data+2;
+
+    for (uint i = DescriptorLength();i >= 4;)
+    {
+        uint key = p[0] << 8 + p[1];
+        /* MSBit of LSByte seems to be 1 when it is a radio
+         * and MSByte seems to be 0 always
+         */
+
+        uint index = p[3] << 8 + p[4];
+        channels_indexes.insert(key, index);
+        i -= 4;
+        p += 4;
+    }
+}

mythtv/libs/libmythtv/mpeg/csatcaraibesdescriptors.h

@@ +1 @@
+// -*- Mode: c++ -*-
+#ifndef _CSATCAR_DESCRIPTORS_H_
+#define _CSATCAR_DESCRIPTORS_H_
+
+#include <stdint.h>
+#include <inttypes.h>
+
+#include <qstring.h>
+#include <qdatetime.h>
+
+#include "dvbdescriptors.h"
+
+class CSatCaraibesChannelsDescriptor : public MPEGDescriptor
+{
+    public:
+        CSatCaraibesChannelsDescriptor(const unsigned char* data) : MPEGDescriptor(data)
+        {
+            assert(DescriptorID::csat_channels_ind == DescriptorTag());
+            Parse();
+        }
+
+        void Parse(void);
+        const QMap<uint,uint>& GetIndexes() const
+        {
+            return channels_indexes;
+        }
+
+    private:
+        /* Maps a Program ID to an index used by the EIT */
+        QMap<uint,uint> channels_indexes;
+};
+
+#endif // _CSATCAR_DESCRIPTORS_H_

mythtv/libs/libmythtv/mpeg/csatcaraibestables.cpp

@@ +1 @@
+#include "csatcaraibesdescriptors.h"
+#include "csatcaraibestables.h"
+
+/************** Channels *********************************/
+
+void CSatCaraibesChannelsTable::Parse()
+{
+    int pos = 0;
+
+    /* FIXME: There is for sure a clean way to do this
+       Lookup a 00 01 sequence*
+    */
+
+    while ((pos<SectionLength()) && ((psipdata()[pos]!=0) || (psipdata()[pos+1]!=1))) pos++;
+
+    assert(pos<SectionLength());
+
+    /* skip 4 bytes */
+    pos += 4;
+    while (pos<SectionLength()) {
+        _ptrs.push_back(psipdata()[pos]*256+psipdata()[pos+1]);
+        pos += 14;
+    }
+}
+
+/******************* Schedule ******************************/
+
+void CSatCaraibesScheduleTable::Parse()
+{
+    uint nb_titles, i;
+    unsigned char * pos;
+
+    /* Skip section length */
+    nb_titles = psipdata()[1];
+    pos = psipdata() + 2;
+    for (i = 0;i < nb_titles;i++) {
+        _ptrs.push_back(pos);
+        /* Skip titles */
+        pos += *pos+1;
+        /* Skip 4 bytes per showing */
+        pos += ((*pos >> 4) & 0x07)*4;
+    }
+}
+
+void CSatCaraibesScheduleTable::GetSchedules(vector<CSatCaraibesSchedule>& schedules) const
+{
+    QDateTime date = QDateTime::currentDateTime();
+    QDate today = QDate::currentDate();
+
+    for (uint i = 0;i < NbSchedules();i++) {
+        const unsigned char * p = _ptrs[i];
+        CSatCaraibesSchedule schedule;
+        uint j;
+
+        schedule.title = QString::fromLatin1((const char *) (p+1), *p);
+        p += p[0];
+        /* 0x85 at the end means incomplete, so add dots */
+        if (*p==0x85)
+            schedule.title.append("...");
+        p++;
+        if (*p & 0x80) schedule.key = 0;
+        else schedule.key = Section() << 12 + (_ptrs[i]-psipdata());
+        /* Get corresponding showings */
+        j = (*p & 0x70) >> 4;
+        schedule.duration = ( (p[0] & 0x0F)*256 + p[1] ) * 60;
+        schedule.theme = (p[2] >> 4) & 0x0F;
+        p += 3;
+        for (;j > 0;j--) {
+            CSatCaraibesShowing s;
+
+            s.channel_index = *p & 0x7F;
+            p++;
+            s.Start = QDateTime(today).addDays(*p >> 3)
+                .addSecs(((p[0] & 0x07)*256+p[1])*60);
+            schedule.showings.push_back(s);
+        }
+        schedules.push_back(schedule);
+    }
+}
+ 
+/******************* Summaries *******************************/
+
+uint CSatCaraibesSummaryTable::TitleKey() const
+{
+    uint sched_off = (psipdata()[0] &0x0F)*256+psipdata()[1];
+    uint sched_sect = psipdata()[5];
+    return (sched_off + sched_sect << 12);
+}
+
+/* FIXME: this is a bit crude. Eg \0x0a chars are used
+   to break lines, we should escape them
+   Also there is sometimes a second part of the summary
+   that we do not use here
+*/
+QString CSatCaraibesSummaryTable::toString() const
+{
+    uint len = psipdata()[8];
+  
+    return QString::fromLatin1((const char*)(psipdata()+15), len);
+}
+
+/******************* Themes **************************/
+
+static MythCategoryType ConvertTheme(const QString& str)
+{
+    if (str == "CINEMA") return string_to_myth_category_type("movies");
+    if (str == "SPORT") return string_to_myth_category_type("sports");
+    if (str == "SERIE") return string_to_myth_category_type("series");
+    return kCategoryNone;
+}
+
+void CSatCaraibesThemesTable::GetThemes(vector<CSatCaraibesTheme>& v) const
+{
+    CSatCaraibesTheme t;
+    /* Points on themes string */
+    const unsigned char * p = psipdata() + 0x109;
+    for (int i = 9;i < 0x100;i += 0x10) {
+        /* A zero length is possible */
+        if (psipdata()[i] & 0x7F) {
+            t.theme = QString::fromAscii((const char *)p, psipdata()[i] & 0x7F);
+            t.category = ConvertTheme(t.theme);
+            p += psipdata()[i] & 0x7F;
+        } else {
+            t.theme = QString::null;
+            t.category = kCategoryNone;
+        }
+        v.push_back(t);
+    }
+}
+
+/************** Information table ******************/
+
+void CSatCaraibesInformationTable::AddSummary(const CSatCaraibesSummaryTable& t)
+{
+    summaries.insert(t.TitleKey(), t.toString());
+}
+
+bool CSatCaraibesInformationTable::HasScheduleSection(uint section) const
+{
+    for (uint i = 0; i < sections.size();i++)
+        if (section == sections[i]) return true;
+    return false;
+}
+
+void CSatCaraibesInformationTable::AddSchedules(const CSatCaraibesScheduleTable& t)
+{
+    if (!HasScheduleSection(t.Section())) {
+        /* Record section */
+        sections.push_back(t.Section());
+        /* Get all schedules */
+        t.GetSchedules(schedules);
+        nb_sections = t.LastSection()+1;
+    }
+}
+
+void CSatCaraibesInformationTable::AddChannelsInfo(const BouquetAssociationTable * bat)
+{
+    for (uint i = 0; i < bat->NBTransports();i++)
+    {
+        desc_list_t desc =
+            MPEGDescriptor::Parse(bat->TransportDescriptors(i),
+                                  bat->TransportDescriptorsLoopLength(i));
+        const unsigned char * private_data =
+            MPEGDescriptor::Find(desc, DescriptorID::private_data_specifier);
+
+        /* Check if this looks like CanalSat private table
+           Canal+ is 0x000000c0
+        */
+        if (!private_data || (MPEGDescriptor(private_data).DescriptorLength()!=4)
+            || ((uint32_t)*(private_data+4)!=0x000000c0))
+            continue;
+        private_data = MPEGDescriptor::Find(desc, DescriptorID::csat_channels_ind);
+        if (private_data) {
+            CSatCaraibesChannelsDescriptor csat(private_data);
+
+            const QMap<uint,uint>& indexes = csat.GetIndexes();
+            CSatCaraibesChannelInfo info;
+            QMap<uint,uint>::const_iterator it = indexes.begin();
+
+            info.tsid = bat->TSID(i);
+            info.orignetworkid = bat->OriginalNetworkID(i);
+            VERBOSE(VB_SIPARSER,QString("TSID %1 OrigNetworkid %2").arg(info.tsid).arg(info.orignetworkid));
+            for (;it != indexes.end();it++) {
+                info.serviceid = it.key();
+                channels.insert(it.data(), info);
+                VERBOSE(VB_SIPARSER,
+                        QString("Index %1 Serviceid %2").arg(it.data()).arg(it.key()));
+            }
+        }
+    }
+}

mythtv/libs/libmythtv/mpeg/csatcaraibestables.h

@@ +1 @@
+// -*- Mode: c++ -*-
+#ifndef _CSATCARAIBES_TABLES_H_
+#define _CSATCARAIBES_TABLES_H_
+
+#include <qstring.h>
+#include <qmap.h>
+#include <stdint.h>  // uint32_t
+#include "mpegtables.h"
+#include "dvbdescriptors.h"
+#include "dvbtables.h"
+#include "mpegtables.h"
+
+/* Parses the channels table which contains the program number
+   in a certain order. The index in this table is used by
+   the other tables to refer to the channel (I dont know why
+   this indirection is needed, but well)
+   This class is not directly used to emit EIT events.
+*/
+
+class CSatCaraibesChannelsTable : public PSIPTable
+{
+    public:
+        CSatCaraibesChannelsTable(const PSIPTable & table) : PSIPTable(table)
+        {
+            if (IsValid()) Parse();
+        }
+
+        bool IsValid() const {
+            return TableID()==TableID::CSATCARAIBES_CHANNELS;
+        }
+        void Parse();
+        uint ChannelByIndex(uint index) const {
+            assert(index<_ptrs.size());
+            return _ptrs[index];
+        }
+        const vector<uint>& Channels() const {
+            return _ptrs;
+        }
+    private:
+        mutable vector<uint> _ptrs;
+};
+
+typedef struct CSatCaraibesShowing
+{
+        QDateTime Start;
+        uint channel_index;
+};
+
+typedef struct CSatCaraibesSchedule {
+        QString title;
+        uint duration; /* In minutes */
+        uint key; /* Key that links it to its summary; ==0 means no summary */
+        short unsigned int theme;
+        vector<CSatCaraibesShowing> showings;
+};
+
+class CSatCaraibesScheduleTable : public PSIPTable
+{
+    public:
+        CSatCaraibesScheduleTable(const PSIPTable& table) : PSIPTable(table)
+        {
+        }
+
+        void Parse();
+        bool IsValid() {
+            return TableID()==TableID::CSATCARAIBES_SCHED;
+        }
+        void GetSchedules(vector<CSatCaraibesSchedule>& schedules) const;
+        uint GetKey(uint i) const
+        {
+            return Section() << 12 + (_ptrs[i]-psipdata());
+        }
+        uint NbSchedules() const
+        {
+            return _ptrs.size();
+        }
+  
+    private:
+ 
+        mutable vector<const unsigned char *> _ptrs;
+};
+
+class CSatCaraibesSummaryTable : public PSIPTable
+{
+    public:
+        CSatCaraibesSummaryTable(const PSIPTable & table) : PSIPTable(table)
+        {
+        }
+
+        bool IsValid() {
+            return TableID()==TableID::CSATCARAIBES_SUMMARIES;
+        }
+        QString toString() const;
+        uint TitleKey() const;
+};
+
+typedef struct CSatCaraibesTheme {
+        QString theme;
+        MythCategoryType category;
+};
+
+class CSatCaraibesThemesTable : public PSIPTable
+{
+    public:
+        CSatCaraibesThemesTable(const PSIPTable & table) : PSIPTable(table)
+        {
+        }
+  
+        void GetThemes(vector<CSatCaraibesTheme>&) const;
+};
+
+/* This struct holds all the needed info to find the chanid
+   of the channel
+*/
+
+typedef struct CSatCaraibesChannelInfo {
+        uint tsid, orignetworkid, serviceid;
+};
+
+class CSatCaraibesInformationTable
+{
+    public:
+        CSatCaraibesInformationTable() {}
+
+        void Reset() {
+            themes.clear();
+            channels.clear();
+            summaries.clear();
+            schedules.clear();
+        }
+        bool HasThemes() const
+        {
+            return themes.empty();
+        }
+        bool HasChannels() const
+        {
+            return channels.empty();
+        }
+        void AddThemes(const CSatCaraibesThemesTable& t)
+        {
+            t.GetThemes(themes);
+        }
+        /*  void AddChannels(const CSatCaraibesChannelsTable& c) {
+            channels = c.Channels();
+            }*/
+        void AddSummary(const CSatCaraibesSummaryTable& s);
+        void AddSchedules(const CSatCaraibesScheduleTable& t);
+        bool HasSeenAllSchedules(void)
+        {
+            if (schedules.empty()) return false;
+            return (nb_sections == schedules.size());
+        }
+        bool HasScheduleSection(uint section) const;
+
+        /* Returns true when the channels, themes, and at least
+           one schedule and one summaries table has been gathered */
+        bool IsReady() const
+        {
+            /* Summaries can be empty */
+            return !(themes.empty() || channels.empty() ||
+                     schedules.empty());
+        }
+        uint NbSchedules() const
+        { return schedules.size(); }
+        const CSatCaraibesSchedule & GetSchedule(uint i) const
+        {
+            return schedules[i];
+        }
+        void AddChannelsInfo(const BouquetAssociationTable *);
+        const CSatCaraibesChannelInfo& GetChannelInfoFromIndex(uint index)
+        {
+            return channels[index];
+        }
+        /* Returns true if summary is found and then it points to it
+           else returns false */
+        bool GetSummary(uint i, QMap<uint,QString>::const_iterator& it) const
+        {
+            it = summaries.find(schedules[i].key);
+            return it!=summaries.end();
+        }
+
+    private:
+        mutable vector<CSatCaraibesTheme> themes;
+
+        /* Maps the index to the channel info */
+        mutable QMap<uint, CSatCaraibesChannelInfo> channels;
+        mutable vector<CSatCaraibesSchedule> schedules;
+        /* Maps the key (see summary) to the description */
+        mutable QMap<uint,QString> summaries;
+
+        /* Used to check if the sections have been seen */
+        mutable vector<uint> sections;
+        /* Number of sections needed to make up the whole schedules */
+        uint nb_sections;
+};
+
+#endif // _CSATCARAIBES_TABLES_H_

mythtv/libs/libmythtv/mpeg/dvbdescriptors.h

@@ -1812 +1812 @@
         QString toString() const { return QString("DVBContentIdentifierDescriptor(stub)"); }
 };
 
+/* Used by Canal+ (French Sat provider) in the BAT
+   For Canal+: data is 4 bytes, equal to 0x000000C0
+*/
+class DVBPrivateDataSpecifierDescriptor : public MPEGDescriptor
+{
+    public:
+        DVBPrivateDataSpecifierDescriptor(const unsigned char * data) : MPEGDescriptor(data)
+        {
+            assert(DescriptorID::private_data_specifier == DescriptorTag());
+        }
+};
 
 #endif

mythtv/libs/libmythtv/mpeg/dvbstreamdata.cpp

@@ -17 +16 @@
     : MPEGStreamData(desired_program, cacheTables),
       _desired_netid(desired_netid), _desired_tsid(desired_tsid),
       _dvb_eit_dishnet_long(false),
+      _dvb_eit_csatcaraibes(true),
       _nit_version(-2), _nito_version(-2)
 {
     SetVersionNIT(-1,0);
@@ -243 +245 @@
 
             return true;
         }
+        case TableID::BAT:
+        {
+            BouquetAssociationTable bat(psip);
+            /* For now we use the BAT only for Canal Satellite 
+             * Caraibes (French provider)
+             */
+            if (bat.BouquetName()=="CanalSatellite Caraibes") {
+                VERBOSE(VB_SIPARSER,"Bat processed to get channels info, CanalSat Caraibes");
+                _csat_info.AddChannelsInfo(&bat);
+            }
+            else VERBOSE(VB_SIPARSER,"BAT but not canalsat");
+            return true;
+        }
         case TableID::SDT:
         {
             uint tsid = psip.TableIDExtension();
@@ -370 +385 @@
         return true;
     }
 
+    if (CSATCARAIBES_EIT_PID1 == pid) {
+        switch (psip.TableID())
+        {
+            /*case TableID::CSATCARAIBES_CHANNELS:
+              if (_csat_info.HasChannels()) return true;
+              _csat_info.AddChannels(psip);*/
+            break;
+            case TableID::CSATCARAIBES_THEMES:
+                if (_csat_info.HasThemes()) return true;
+                _csat_info.AddThemes(psip);
+                break;
+            case TableID::CSATCARAIBES_SCHED:
+                if (_csat_info.HasSeenAllSchedules()) return true;
+                _csat_info.AddSchedules(psip);
+                break;
+            case TableID::CSATCARAIBES_SUMMARIES:
+            {
+                CSatCaraibesSummaryTable summary(psip);
+                if (!(summary.IsValid())) return false;
+                _csat_info.AddSummary(summary);
+                break;
+            }
+            default:
+                return false;
+        }
+        if (_eit_helper)
+            _eit_helper->AddEIT(&_csat_info);
+    }
     return false;
 }
 
@@ -416 +459 @@
             add_pids.push_back(DVB_DNLONG_EIT_PID);
         }
 
+        if (_dvb_eit_csatcaraibes &&
+            find(cur_pids.begin(), cur_pids.end(),
+                 (uint) CSATCARAIBES_EIT_PID1) == cur_pids.end())
+        {
+            add_pids.push_back(CSATCARAIBES_EIT_PID1);
+            VERBOSE(VB_EIT,"Added CSAT PID!");
+        }
+
         if (_desired_netid == PREMIERE_ONID &&
             find(cur_pids.begin(), cur_pids.end(),
                  (uint) PREMIERE_EIT_DIREKT_PID) == cur_pids.end())
@@ -451 +496 @@
             del_pids.push_back(DVB_DNLONG_EIT_PID);
         }
 
+        if (_dvb_eit_csatcaraibes &&
+            find(cur_pids.begin(), cur_pids.end(),
+                 (uint) CSATCARAIBES_EIT_PID1) == cur_pids.end())
+        {
+            del_pids.push_back(CSATCARAIBES_EIT_PID1);
+        }
         if (_desired_netid == PREMIERE_ONID &&
             find(cur_pids.begin(), cur_pids.end(),
                  (uint) PREMIERE_EIT_DIREKT_PID) != cur_pids.end())

mythtv/libs/libmythtv/mpeg/dvbstreamdata.h

@@ -4 +4 @@
 #define DVBSTREAMDATA_H_
 
 #include "mpegstreamdata.h"
+#include "csatcaraibestables.h"
 
 typedef NetworkInformationTable* nit_ptr_t;
 typedef vector<const NetworkInformationTable*>  nit_vec_t;
 typedef QMap<uint, nit_ptr_t>    nit_cache_t; // section->sdts
@@ -193 +191 @@
     
         /// Decode DishNet's long-term DVB EIT
         bool                      _dvb_eit_dishnet_long;
+        /// Decode Canal Satellite Caraibes DVB EIT
+        bool                        _dvb_eit_csatcaraibes;
         /// Tell us if the DVB service has EIT
         dvb_has_eit_t             _dvb_has_eit;
 
@@ -217 +217 @@
         sections_t                _nito_section_seen;
         sections_map_t            _sdto_section_seen;
 
+        // Canal Satellite Caraibes private information table
+        CSatCaraibesInformationTable _csat_info;
+
         // Caching
         nit_cache_t               _cached_nit;  // section -> sdt
         sdt_cache_t               _cached_sdts; // tsid+section -> sdt

mythtv/libs/libmythtv/mpeg/dvbtables.cpp

@@ -148 +148 @@
         return false;
 }
 
+void BouquetAssociationTable::Parse(void)
+{
+    const unsigned char * p = psipdata()+8;
+    uint looplen, len = (p[0] & 0x0F) << 8 + p[1]; // Name descriptor length
+    desc_list_t desc;
+    p += 2;
+    desc = MPEGDescriptor::ParseOnlyInclude(p, len, DescriptorID::bouquet_name);
+    if (desc.empty())
+        VERBOSE(VB_SIPARSER,"Curious: BAT without bouquet name!");
+    else
+        bouquet_name = QString::fromLatin1((const char*)(desc[0]+2),
+                                           MPEGDescriptor(desc[0]).DescriptorLength());
+    p += len;
+    looplen = (p[0] & 0x0F) << 8 + p[1];
+    p += 2; // Now point on first TS desc
+    while (looplen) {
+        _ptrs.push_back(p);    // Add first TS position
+        p += 4;                // Skip TS and network ID
+        len = (p[0] & 0x0F) << 8 + p[1];    // Get length of descriptors
+        p += 2;
+        looplen -= 6;
+        p += len;
+        looplen -= len;
+    }
+}
+
 void DVBEventInformationTable::Parse(void) const
 {
     _ptrs.clear();
@@ -177 +203 @@
     // Dish Network Long Term Future Event Information for all transports
     is_eit |= (TableID::DN_EITbego <= table_id &&
                TableID::DN_EITendo >= table_id);
+    // Canal Satellite long term EIT for all transports
+    is_eit |= (table_id == TableID::CSATCARAIBES_CHANNELS ||
+               table_id == TableID::CSATCARAIBES_THEMES ||
+               table_id == TableID::CSATCARAIBES_SCHED ||
+               table_id == TableID::CSATCARAIBES_SUMMARIES);
 
     return is_eit;
 }

mythtv/libs/libmythtv/mpeg/dvbtables.h

@@ -164 +164 @@
         mutable vector<const unsigned char*> _ptrs; // used to parse
 };
 
+/** \class BouquetAssociationTable
+ *  \brief Tells what channels can be found on each transponder
+ *  for one bouquet (a bunch of channels from one provider)
+ *  Note: French Provider Canal+ uses this to associate channels
+ *  with an index used in their proprietary EIT
+ */
+
+class BouquetAssociationTable : public PSIPTable
+{
+    public:
+        BouquetAssociationTable(const PSIPTable& table) : PSIPTable(table)
+        {
+            assert(TableID::BAT == TableID());
+            Parse();
+        }
+        ~BouquetAssociationTable() { ; }
+
+        // table_id                 8   0.0       0x4a
+        // section_syntax_indicator 1   1.0          1
+        // reserved_future_use      1   1.1          1
+        // reserved                 2   1.2          3
+        // section_length          12   1.4          0
+        // Bouquet ID              16   3.0          0
+        // reserved                 2   5.0          3
+        // version_number           5   5.2          0
+        // current_next_indicator   1   5.7          1
+        // section_number           8   6.0       0x00
+        // last_section_number      8   7.0       0x00
+        // reserved                 4   8         0x0d
+        // Bouquet descriptors len 12   8.4
+        // for (i=0;i<N;i++)
+        // Descriptor();
+        // reserved                4 10+N.0
+        // Transport stream loop len 12
+        // for (i=0;i<N;i++) {
+        //   transport_stream_id    16
+        //   original_network_id    16
+        //   reserved                4
+        //   transport descriptor len 12
+        //   for (j=0;j<N;j++)
+        //     Descriptor();
+        //  }
+        //  crc                     32
+        uint TSID(uint i) const
+        { return _ptrs[i][0] << 8 + _ptrs[i][1]; }
+
+        /// original_network_id    16   8.0
+        uint OriginalNetworkID(uint i) const
+        { return _ptrs[i][2] << 8 + _ptrs[i][3]; }
+
+        /* Returns a pointer to the first descriptor following
+           the TS and Network ID, and the loop length */
+        const unsigned char * TransportDescriptors(uint i) const
+        { return _ptrs[i]+6; }
+        uint TransportDescriptorsLoopLength(uint i) const
+        { return (_ptrs[i][4] &0x0F)<< 8 + _ptrs[i][5]; }
+        void Parse(void);
+        uint NBTransports() const
+        {
+            return _ptrs.size();
+        }
+        QString BouquetName() const
+        { return bouquet_name; }
+
+    private:
+        /* point on the transport descriptors */
+        mutable vector<const unsigned char*> _ptrs;
+        mutable QString bouquet_name;
+};
+
 class DiscontinuityInformationTable : public PSIPTable
 {
         DiscontinuityInformationTable(const PSIPTable& table) : PSIPTable(table)

mythtv/libs/libmythtv/mpeg/mpegdescriptors.h

@@ -123 +112 @@
 
             // ATSC
             atsc_stuffing               = 0x80,
+            /* Seems to be used also for user-defined
+               For CanalSat Caraibes this is used in
+               the BAT to provide channel indexes */
             audio_stream                = 0x81,
+            csat_channels_ind           = 0x81,
             caption_service             = 0x86,
             content_advisory            = 0x87,
 

mythtv/libs/libmythtv/mpeg/mpegtables.h

@@ -191 +191 @@
     PREMIERE_EIT_DIREKT_PID = 0x0b11,
     PREMIERE_EIT_SPORT_PID  = 0x0b12,
 
+    // Canal Sat longterm EIT is on pid 0x114 and 0x153
+    CSATCARAIBES_EIT_PID1 = 0x114,
+    //    CSATCARAIBES_EIT_PID2 = 0x153,
+
     ATSC_PSIP_PID = 0x1ffb,
 };
 
@@ -241 +245 @@
             DN_EITbego = 0x80, // always on pid 0x300
             DN_EITendo = 0xfe, // always on pid 0x300
 
+            // Canal Sat Caraibes Longterm EIT data
+            CSATCARAIBES_CHANNELS = 0x90, // always on pid 0x114
+            CSATCARAIBES_SCHED = 0x92,    // always on pid 0x114
+            CSATCARAIBES_SUMMARIES = 0x94, //always on pid 0x114
+            CSATCARAIBES_THEMES = 0x91,    //always on pid 0x114
+
             // ARIB
             ARIBbeg  = 0x80,
             ARIBend  = 0x8f,

mythtv/libs/libmythtv/mpeg/streamlisteners.h

@@ -31 +31 @@
 class DirectedChannelChangeSelectionCodeTable;
 
 class NetworkInformationTable;
+class BouquetAssociationTable;
 class ServiceDescriptionTable;
 class TimeDateTable;
 class DVBEventInformationTable;
@@ -143 +144 @@
     public:
         virtual void HandleEIT(const DVBEventInformationTable*) = 0;
         virtual void HandleEIT(const PremiereContentInformationTable*) = 0;
+        virtual void HandleBAT(const BouquetAssociationTable*)=0;
 };
 
 

mythtv/libs/libmythtv/dtvsignalmonitor.h

@@ -100 +105 @@
         void HandleTDT(const TimeDateTable*);
         void HandleNIT(const NetworkInformationTable*);
         void HandleSDT(uint, const ServiceDescriptionTable*);
+        void HandleBAT(const BouquetAssociationTable*);
 
         void IgnoreEncrypted(bool ignore) { ignore_encrypted = ignore; }
 

mythtv/libs/libmythtv/dtvsignalmonitor.cpp

@@ -469 +476 @@
         AddFlags(kDTVSigMon_CryptMatch);
 }
 
+void DTVSignalMonitor::HandleBAT(const BouquetAssociationTable * bat)
+{
+    VERBOSE(VB_SIPARSER,"BAT detected");
+  
+}
+
 ATSCStreamData *DTVSignalMonitor::GetATSCStreamData()
 {
     return dynamic_cast<ATSCStreamData*>(stream_data);

mythtv/libs/libmythtv/eithelper.h

@@ -53 +48 @@
 class ExtendedTextTable;
 class DVBEventInformationTable;
 class PremiereContentInformationTable;
+class CSatCaraibesInformationTable;
 
 class EITHelper
 {
@@ -77 +73 @@
                     const ExtendedTextTable     *ett);
         void AddEIT(const DVBEventInformationTable *eit);
         void AddEIT(const PremiereContentInformationTable *eit);
+        void AddEIT(CSatCaraibesInformationTable *eit);
 #else // if !USING_BACKEND
         void AddEIT(uint, uint, const EventInformationTable*) {}
         void AddETT(uint, uint, const ExtendedTextTable*) {}
         void AddEIT(const DVBEventInformationTable*) {}
         void AddEIT(const PremiereContentInformationTable*) {}
+        void AddEIT(const CSatCaraibesInformationTable*) {}
 #endif // !USING_BACKEND
 
         // EIT cache handling

mythtv/libs/libmythtv/eithelper.cpp

@@ -20 +19 @@
 #include "atsctables.h"
 #include "dvbtables.h"
 #include "premieretables.h"
+#include "csatcaraibestables.h"
 #include "dishdescriptors.h"
 #include "premieredescriptors.h"
 #include "util.h"
@@ -513 +512 @@
     }
 }
 
+// This function gets special eit data from the French provider
+// Canal Satellite Caraibes. It probably applies to this provider
+// in France. This EIT is available for all channels for 7-10 days                   
+void EITHelper::AddEIT(CSatCaraibesInformationTable *cit)
+{
+    QString title         = QString::null;
+    QString subtitle      = QString::null;
+    QString description   = QString::null;
+    QString category      = QString::null;
+    MythCategoryType category_type = kCategoryNone;
+    unsigned char subtitle_type=0, audio_props=0, video_props=0;
+    uint fix = fixup[ 601LL << 32 | 1 << 16 |  0 ] | EITFixUp::kFixGenericDVB;
+    if (!cit->IsReady()) {
+        VERBOSE(VB_EIT,LOC+"CSAT EIT NOT READY YET");
+        return;
+    }
+    for (uint i = 0;i < cit->NbSchedules();i++) {
+        const CSatCaraibesSchedule& schedule = cit->GetSchedule(i);
+        QString title = schedule.title;
+        const vector<CSatCaraibesShowing>& showings = schedule.showings;
+        QMap<uint, QString>::const_iterator sum;
+        bool sum_available = false;
+
+        if (schedule.key) {
+            /* If the summary is not there we go on with the next schedule */
+            if (!(cit->GetSummary(i, sum))) continue;
+            sum_available = true;
+        }
+        for (vector<CSatCaraibesShowing>::const_iterator it = showings.begin();
+             it != showings.end();it++) {
+            QDateTime starttime = (*it).Start;
+            //    EITFixUp::TimeFix(starttime);
+            QDateTime endtime   = starttime.addSecs(schedule.duration*60);
+            uint chanid;
+            DBEvent *event;
+            const CSatCaraibesChannelInfo& info = cit->GetChannelInfoFromIndex((*it).channel_index);
+            chanid = GetChanID(info.tsid,info.serviceid,info.orignetworkid);
+            VERBOSE(VB_EIT, LOC +
+                    QString("CSATCARAIBES EIT for NIT %1, TID %2, SID %3, "
+                            "T: %4, Start: %5, Dur: %6 Thm: %7, summ: %8")
+                    .arg(info.orignetworkid).arg(info.tsid).arg(info.serviceid)
+                    .arg(title).arg(starttime.toString()).arg(schedule.duration)
+                    .arg(schedule.theme).arg((sum_available ? *sum :"No summary")));
+      
+            if (!chanid)
+            {
+                VERBOSE(VB_EIT, LOC +
+                        QString("CSATCARAIBES EIT for NIT %1, TID %2, SID %3, "
+                                "title: %4. Channel not found!")
+                        .arg(info.orignetworkid).arg(info.tsid).arg(info.serviceid)
+                        .arg(title));
+                continue;
+            }
+      
+            /*      event = new DBEvent(chanid,
+                    title, QString::null, sum_available ? (*sum).value():"",
+                    category,  category_type,
+                    starttime, endtime, fix,
+                    subtitle_type,
+                    audio_props,
+                    video_props,
+                    "",  "");
+                    db_events.enqueue(event);*/
+        }
+    }
+}
 
 void EITHelper::PruneEITCache(uint timestamp)
 {
@@ -856 +907 @@
         fix[ 1094LL << 32 | 1 << 16 | 17028 ] = // NT1
         fix[ 1100LL << 32 | 1 << 16 |  8710 ] = // NRJ 12
         EITFixUp::kEFixForceISO8859_15;
+
+    // IntelSat 903 DVB-S french channels (CanalSat Caraibes)
+    // The original network id is the same as the previous one
+    // at least transport ids are different
+    // For now all channels are marked as needing fixup
+    fix[   601LL << 32 | 1 << 16 |  0 ] =
+        fix[ 602LL << 32 | 1 << 16 |  0 ] =
+        fix[ 603LL << 32 | 1 << 16 |  0 ] =
+        fix[ 604LL << 32 | 1 << 16 |  0 ] =
+        EITFixUp::kEFixForceISO8859_15;
 }
 
 static int calc_eit_utc_offset(void)