/*

  * PremiereEpg plugin to VDR (C++)

  *

  * (C) 2005 Stefan Huelswitt <s.huelswitt@gmx.de>

  *

  * This code is base on the commandline tool premiereepg2vdr

  * (C) 2004-2005 by Axel Katzur software@katzur.de

  * but has been rewritten from scratch

  *

  * This code 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.

  *

  * This code is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html

  */

 #include <vdr/plugin.h>

 #include <vdr/filter.h>

 #include <vdr/epg.h>

 #include <vdr/channels.h>

 #include <vdr/dvbdevice.h>

 #include <libsi/section.h>

 #include <libsi/descriptor.h>

 //#define DEBUG

 //#define DEBUG2

 #ifdef DEBUG

 #define d(x) { (x); }

 #else

 #define d(x) ; 

 #endif

 #ifdef DEBUG2

 #define d2(x) { (x); }

 #else

 #define d2(x) ; 

 #endif

 #define PMT_SCAN_TIMEOUT  10  // seconds

 #define PMT_SCAN_IDLE     300 // seconds

 static const char *VERSION        = "0.0.1";

 static const char *DESCRIPTION    = "Parse extended Premiere EPG data";

 // --- CIT ---------------------------------------------------------------------

 namespace SI {

 #define CIT_LEN 17

 struct cit {

    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 content_id_hi_hi                       :8;

    u_char content_id_hi_lo                       :8;

    u_char content_id_lo_hi                       :8;

    u_char content_id_lo_lo                       :8;

    u_char duration_h                             :8;

    u_char duration_m                             :8;

    u_char duration_s                             :8;

 #if BYTE_ORDER == BIG_ENDIAN

    u_char reserved                               :4;

    u_char descriptors_loop_length_hi             :4;

 #else

    u_char descriptors_loop_length_hi             :4;

    u_char reserved                               :4;

 #endif

    u_char descriptors_loop_length_lo             :8;

 };

 class CIT : public NumberedSection {

 public:

    CIT(const unsigned char *data, bool doCopy=true) : NumberedSection(data, doCopy) {}

    CIT() {}

    int getContentId(void) const;

    time_t getDuration(void) const;

    DescriptorLoop eventDescriptors;

 protected:

    virtual void Parse(void);

 private:

    const cit *s;

 };

 int CIT::getContentId(void) const {

    return (HILO(s->content_id_hi)<<16) | (HILO(s->content_id_lo));

 }

 time_t CIT::getDuration(void) const {

    return DVBTime::getDuration(s->duration_h,s->duration_m,s->duration_s);

 }

 void CIT::Parse(void) {

    unsigned int offset=0;

    data.setPointerAndOffset<const cit>(s, offset);

    eventDescriptors.setData(data+offset,HILO(s->descriptors_loop_length));

 }

 } // end of namespace

 // --- cDescrF2 ----------------------------------------------------------------

 class cDescrF2 {

 private:

   SI::Descriptor *d;

   SI::CharArray data;

   int idx, loop, nloop, index;

 public:

   cDescrF2(SI::Descriptor *D);

   int TransportStreamId(void) { return data.TwoBytes(2); }

   int OrgNetworkId(void)      { return data.TwoBytes(4); }

   int ServiceId(void)         { return data.TwoBytes(6); }

   void Start(void);

   bool Next(void);

   time_t StartTime(void);

   int Index(void) { return index; }

   };

 cDescrF2::cDescrF2(SI::Descriptor *D)

 {

   d=D;

   data=d->getData();

   Start();

 }

 void cDescrF2::Start(void)

 {

   idx=8; loop=0; nloop=-3; index=-1;

 }

 bool cDescrF2::Next(void)

 {

   loop+=3;

   if(loop>=nloop) {

     idx+=nloop+3;

     if(idx>=d->getLength()) return false;

     loop=0; nloop=data[idx+2];

     }

  index++;

  return true;

 }

 time_t cDescrF2::StartTime(void)

 {

   int off=idx+3+loop;

   return SI::DVBTime::getTime(data[idx+0],data[idx+1],data[off+0],data[off+1],data[off+2]);

 }

 // --- cFilterPremiereEpg ------------------------------------------------------

 class cFilterPremiereEpg : public cFilter {

 private:

   int pmtpid, pmtidx, pmtnext;

   //

   void NextPmt(void);

 protected:

   virtual void Process(u_short Pid, u_char Tid, const u_char *Data, int Length);

 public:

   cFilterPremiereEpg(void);

   virtual void SetStatus(bool On);

   void Trigger(void);

   };

 cFilterPremiereEpg::cFilterPremiereEpg(void)

 {

   Trigger();

   Set(0x00,0x00);

 }

 void cFilterPremiereEpg::Trigger(void)

 {

   d(printf("trigger\n"))

   pmtpid=0; pmtidx=0; pmtnext=0;

 }

 void cFilterPremiereEpg::SetStatus(bool On)

 {

   d(printf("setstatus %d\n",On))

   cFilter::SetStatus(On);

   Trigger();

 }

 void cFilterPremiereEpg::NextPmt(void)

 {

   Del(pmtpid,0x02);

   pmtpid=0;

   pmtidx++;

   d(printf("PMT next\n"))

 }

 void cFilterPremiereEpg::Process(u_short Pid, u_char Tid, const u_char *Data, int Length)

 {

   if(Pid==0 && Tid==SI::TableIdPAT) {

     int now=time(0);

     if(!pmtnext || now>pmtnext) {

       if(pmtpid) NextPmt();

       if(!pmtpid) {

         SI::PAT pat(Data,false);

         if(pat.CheckCRCAndParse()) {

           SI::PAT::Association assoc;

           int idx=0;

           for(SI::Loop::Iterator it; pat.associationLoop.getNext(assoc,it);) {

             if(!assoc.isNITPid()) {

               if(idx++==pmtidx) {

                 pmtpid=assoc.getPid();

                 Add(pmtpid,0x02);

                 pmtnext=now+PMT_SCAN_TIMEOUT;

                 d(printf("PMT pid now 0x%04x (idx=%d)\n",pmtpid,pmtidx))

                 break;

                 }

               }

             }

           if(!pmtpid) {

             pmtidx=0;

             pmtnext=now+PMT_SCAN_IDLE;

             d(printf("PMT scan idle\n"))

             }

           }

         }

       }

     }

   else if(pmtpid>0 && Pid==pmtpid && Tid==SI::TableIdPMT && Source() && Transponder()) {

     SI::PMT pmt(Data,false);

     if(pmt.CheckCRCAndParse()) {

       SI::PMT::Stream stream;

       for(SI::Loop::Iterator it; pmt.streamLoop.getNext(stream,it); ) {

         if(stream.getStreamType()==0x05) {

           SI::CharArray data=stream.getData();

           if((data[1]&0xE0)==0xE0 && (data[3]&0xF0)==0xF0) {

             bool prvData=false, usrData=false;

             SI::Descriptor *d;

             for(SI::Loop::Iterator it; (d=stream.streamDescriptors.getNext(it)); ) {

               switch(d->getDescriptorTag()) {

                 case SI::PrivateDataSpecifierDescriptorTag:

                   d(printf("prv: %d %08x\n",d->getLength(),d->getData().FourBytes(2)))

                   if(d->getLength()==6 && d->getData().FourBytes(2)==0x000000be)

                     prvData=true;

                   break;

                 case 0x90:

                   d(printf("usr: %d %08x\n",d->getLength(),d->getData().FourBytes(2)))

                   if(d->getLength()==6 && d->getData().FourBytes(2)==0x0000ffff)

                     usrData=true;

                   break;

                 default:

                   break;

                 }

               delete d;

               }

             if(prvData && usrData) {

               int pid=stream.getPid();

               d(printf("found citpid 0x%04x",pid))

               if(!Matches(pid,0xA0)) {

                 Add(pid,0xA0);

                 d(printf(" (added)"))

                 }

               d(printf("\n"))

               }

             }

           }

         }

       NextPmt(); pmtnext=0;

       }

     }

   else if(Tid==0xA0 && Source()) {

     SI::CIT cit(Data,false);

     if(cit.CheckCRCAndParse()) {

       cSchedulesLock SchedulesLock(true,10);

       cSchedules *Schedules=(cSchedules *)cSchedules::Schedules(SchedulesLock);

       if(Schedules) {

         int nCount=0;

         time_t firstTime=0;

         SI::Descriptor *d;

         int LanguagePreferenceShort=-1;

         int LanguagePreferenceExt=-1;

         bool UseExtendedEventDescriptor=false;

         SI::ExtendedEventDescriptors *ExtendedEventDescriptors=0;

         SI::ShortEventDescriptor *ShortEventDescriptor=0;

         for(SI::Loop::Iterator it; (d=cit.eventDescriptors.getNext(it)); ) {

           switch(d->getDescriptorTag()) {

             case 0xF2:

               if(nCount>=0) {

                 nCount++;

                 cDescrF2 f2(d);

                 if(f2.Next()) {

                   if(nCount==1) firstTime=f2.StartTime();

                   else {

                     time_t time=f2.StartTime();

                     if(firstTime<time-5*50 || firstTime>time+5*60)

                       nCount=-1;

                     }

                   }

                 }

               break;

             case SI::ExtendedEventDescriptorTag:

               {

               SI::ExtendedEventDescriptor *eed=(SI::ExtendedEventDescriptor *)d;

               if(I18nIsPreferredLanguage(Setup.EPGLanguages,I18nLanguageIndex(eed->languageCode), LanguagePreferenceExt) || !ExtendedEventDescriptors) {

                  delete ExtendedEventDescriptors;

                  ExtendedEventDescriptors=new SI::ExtendedEventDescriptors;

                  UseExtendedEventDescriptor=true;

                  }

               if(UseExtendedEventDescriptor) {

                  ExtendedEventDescriptors->Add(eed);

                  d=NULL; // so that it is not deleted

                  }

               if(eed->getDescriptorNumber()==eed->getLastDescriptorNumber())

                  UseExtendedEventDescriptor=false;

               }

               break;

             case SI::ShortEventDescriptorTag:

               {

               SI::ShortEventDescriptor *sed=(SI::ShortEventDescriptor *)d;

               if(I18nIsPreferredLanguage(Setup.EPGLanguages,I18nLanguageIndex(sed->languageCode), LanguagePreferenceShort) || !ShortEventDescriptor) {

                  delete ShortEventDescriptor;

                  ShortEventDescriptor=sed;

                  d=NULL; // so that it is not deleted

                  }

               }

               break;

             default:

               break;

             }

           delete d;

           }

         bool Modified=false;

         int optCount=0;

         for(SI::Loop::Iterator it; (d=cit.eventDescriptors.getNext(it)); ) {

           if(d->getDescriptorTag()==0xF2) {

             optCount++;

             cDescrF2 f2(d);

             tChannelID channelID(Source(),f2.OrgNetworkId(),f2.TransportStreamId(),f2.ServiceId());

             cChannel *channel=Channels.GetByChannelID(channelID,true);

             if(!channel) continue;

             cSchedule *pSchedule=(cSchedule *)Schedules->GetSchedule(channelID);

             if(!pSchedule) {

                pSchedule=new cSchedule(channelID);

                Schedules->Add(pSchedule);

                }

             for(f2.Start(); f2.Next();) {

               u_int16_t EventId=(cit.getContentId()<<4) | f2.Index();

               time_t StartTime=f2.StartTime();

               bool isOpt=false;

               if(f2.Index()==0 && nCount>1) isOpt=true;

               d2(printf("ch=%s id=%04x/%08x %d opt=%d/%d st=%s ",*channelID.ToString(),EventId,cit.getContentId(),f2.Index(),isOpt,optCount,stripspace(ctime(&StartTime))))

               if(StartTime+cit.getDuration()+Setup.EPGLinger*60<time(0)) {

                 d2(printf("(old)\n"))

                 continue;

                 }

               cEvent *pEvent=(cEvent *)pSchedule->GetEvent(EventId,StartTime);

               if(!pEvent) {

                  d2(printf("(new)\n"))

                  pEvent=pSchedule->AddEvent(new cEvent(channelID,EventId));

                  if(!pEvent) continue;

                  }

               else {

                  d2(printf("(upd)\n"))

                  pEvent->SetSeen();

                  if(pEvent->TableID()==0x00) continue;

                  if(Tid==pEvent->TableID() && pEvent->Version()==cit.getVersionNumber()) continue;

                  }

               pEvent->SetEventID(EventId);

               pEvent->SetTableID(Tid);

               pEvent->SetVersion(cit.getVersionNumber());

               pEvent->SetStartTime(StartTime);

               pEvent->SetDuration(cit.getDuration());

               if(ShortEventDescriptor) {

                 char buffer[256+32];

                 ShortEventDescriptor->name.getText(buffer,sizeof(buffer)-32);

                 if(isOpt) {

                   char o[32];

                   snprintf(o,sizeof(o)," (Option %d)",optCount);

                   strcat(buffer,o);

                   }

                 pEvent->SetTitle(buffer);

                 pEvent->SetShortText(ShortEventDescriptor->text.getText(buffer,sizeof(buffer)));

                 }

               if(ExtendedEventDescriptors) {

                 char buffer[ExtendedEventDescriptors->getMaximumTextLength(": ")+1];

                 pEvent->SetDescription(ExtendedEventDescriptors->getText(buffer,sizeof(buffer),": "));

                 }

               pEvent->SetComponents(NULL);

               pEvent->FixEpgBugs();

               Modified=true;

               }

             if(Modified) {

               pSchedule->Sort();

               Schedules->SetModified(pSchedule);

               }

             }

           delete d;

           }

         delete ExtendedEventDescriptors;

         delete ShortEventDescriptor;

         }

       }

     }

 }

 // --- cPluginPremiereEpg ------------------------------------------------------

 class cPluginPremiereEpg : public cPlugin {

 private:

   struct {

     cFilterPremiereEpg *filter;

     cDevice *device;

     } epg[MAXDVBDEVICES];

 public:

   cPluginPremiereEpg(void);

   virtual const char *Version(void) { return VERSION; }

   virtual const char *Description(void) { return DESCRIPTION; }

   virtual bool Start(void);

   virtual void Stop(void);

   };

 cPluginPremiereEpg::cPluginPremiereEpg(void)

 {

   memset(epg,0,sizeof(epg));

 }

 bool cPluginPremiereEpg::Start(void)

 {

   for(int i=0; i<MAXDVBDEVICES; i++) {

     cDevice *dev=cDevice::GetDevice(i);

     if(dev) {

       epg[i].device=dev;

       dev->AttachFilter(epg[i].filter=new cFilterPremiereEpg);

       isyslog("Attached premiere EPG filter to device %d",i);

       }

     }

   return true;

 }

 void cPluginPremiereEpg::Stop(void)

 {

   for(int i=0; i<MAXDVBDEVICES; i++) {

     cDevice *dev=epg[i].device;

     if(dev) dev->Detach(epg[i].filter);

     delete epg[i].filter;

     epg[i].device=0;

     epg[i].filter=0;

     }

 }

 VDRPLUGINCREATOR(cPluginPremiereEpg); // Don't touch this!