Ticket #2703: 2703-v1.patch

File 2703-v1.patch, 26.9 KB (added by danielk, 14 years ago)

Updated patch

  • libs/libmythtv/dvbrecorder.cpp

     
    5858#include "programinfo.h"
    5959#include "mpegtables.h"
    6060#include "iso639.h"
     61#include "dvbstreamdata.h"
    6162#include "atscstreamdata.h"
    6263#include "atsctables.h"
    6364#include "cardutil.h"
     
    243244    }
    244245}
    245246
     247void DVBRecorder::HandleSTT(const SystemTimeTable*)
     248{
     249    dvbchannel->SetTimeOffset(GetStreamData()->TimeOffset());
     250}
     251
     252void DVBRecorder::HandleTDT(const TimeDateTable*)
     253{
     254    dvbchannel->SetTimeOffset(GetStreamData()->TimeOffset());
     255}
     256
    246257bool DVBRecorder::Open(void)
    247258{
    248259    if (IsOpen())
     
    301312    {
    302313        data->AddMPEGListener(this);
    303314
     315        DVBStreamData *dvb = dynamic_cast<DVBStreamData*>(data);
     316        if (dvb)
     317            dvb->AddDVBMainListener(this);
     318
    304319        ATSCStreamData *atsc = dynamic_cast<ATSCStreamData*>(data);
    305320
    306321        if (atsc && atsc->DesiredMinorChannel())
     
    512527    add_stream_type.push_back(StreamID::PrivSec);
    513528    _stream_data->AddListeningPID(MPEG_PAT_PID);
    514529
     530    add_pid.push_back(DVB_TDT_PID);
     531    add_stream_type.push_back(StreamID::PrivSec);
     532    _stream_data->AddListeningPID(DVB_TDT_PID);
     533
    515534    // Record the streams in the PMT...
    516535    bool need_pcr_pid = true;
    517536    for (uint i = 0; i < _input_pmt->StreamCount(); i++)
  • libs/libmythtv/dvbsignalmonitor.h

     
    2727
    2828    virtual void SetRotorTarget(float target);
    2929
     30    // MPEG
     31    virtual void HandlePMT(uint, const ProgramMapTable*);
     32
     33    // ATSC Main
     34    virtual void HandleSTT(const SystemTimeTable*);
     35
     36    // DVB Main
     37    virtual void HandleTDT(const TimeDateTable*);
     38
    3039  public slots:
    3140    void deleteLater(void);
    3241
     
    5261    bool RemovePIDFilter(uint pid);
    5362
    5463    int GetDVBCardNum(void) const;
     64    DVBChannel *GetDVBChannel(void);
    5565
    5666    bool SupportsTSMonitoring(void);
    5767  protected:
  • libs/libmythtv/dvbdev/dvbci.cpp

     
    10171017private:
    10181018  int interval;
    10191019  time_t lastTime;
     1020  int timeOffset;
    10201021  bool SendDateTime(void);
    10211022public:
    10221023  cCiDateTime(int SessionId, cCiTransportConnection *Tc);
    10231024  virtual bool Process(int Length = 0, const uint8_t *Data = NULL);
     1025  void SetTimeOffset(double offset);
    10241026  };
    10251027
    10261028cCiDateTime::cCiDateTime(int SessionId, cCiTransportConnection *Tc)
     
    10281030{
    10291031  interval = 0;
    10301032  lastTime = 0;
     1033  timeOffset = 0;
    10311034  dbgprotocol("New Date Time (session id %d)\n", SessionId);
    10321035}
    10331036
     1037void cCiDateTime::SetTimeOffset(double offset)
     1038{
     1039    timeOffset = (int) offset;
     1040    dbgprotocol("New Time Offset: %i secs\n", timeOffset);
     1041}
     1042
    10341043bool cCiDateTime::SendDateTime(void)
    10351044{
    10361045  time_t t = time(NULL);
    10371046  struct tm tm_gmt;
    10381047  struct tm tm_loc;
     1048
     1049  // Avoid using signed time_t types
     1050  if (timeOffset < 0)
     1051      t -= (time_t)(-timeOffset);
     1052  else
     1053      t += (time_t)(timeOffset);
     1054
    10391055  if (gmtime_r(&t, &tm_gmt) && localtime_r(&t, &tm_loc)) {
    10401056     int Y = tm_gmt.tm_year;
    10411057     int M = tm_gmt.tm_mon + 1;
     
    17341750  return cas && cas->SendPMT(CaPmt);
    17351751}
    17361752
     1753void cLlCiHandler::SetTimeOffset(double offset_in_seconds)
     1754{
     1755    cMutexLock MutexLock(&mutex);
     1756    cCiDateTime *dt = NULL;
     1757
     1758    for (uint i = 0; i < (uint) NumSlots(); i++)
     1759    {
     1760        dt = (cCiDateTime*) GetSessionByResourceId(RI_DATE_TIME, i);
     1761        if (dt)
     1762            dt->SetTimeOffset(offset_in_seconds);
     1763    }
     1764}
     1765
    17371766bool cLlCiHandler::Reset(int Slot)
    17381767{
    17391768  cMutexLock MutexLock(&mutex);
  • libs/libmythtv/dvbdev/dvbci.h

     
    153153  virtual cCiEnquiry *GetEnquiry(void) = 0;
    154154  virtual const unsigned short *GetCaSystemIds(int Slot) = 0;
    155155  virtual bool SetCaPmt(cCiCaPmt &CaPmt, int Slot) = 0;
     156  virtual void SetTimeOffset(double /*offset_in_seconds*/) { }
    156157  };
    157158
    158159class cLlCiHandler : public cCiHandler {
     
    188189  bool SetCaPmt(cCiCaPmt &CaPmt);
    189190  const unsigned short *GetCaSystemIds(int Slot);
    190191  bool SetCaPmt(cCiCaPmt &CaPmt, int Slot);
     192  void SetTimeOffset(double offset_in_seconds);
    191193  bool Reset(int Slot);
    192194  bool connected() const;
    193195  };
  • libs/libmythtv/dvbrecorder.h

     
    5555 *
    5656 *  \sa DTVRecorder, HDTVRecorder
    5757 */
    58 class DVBRecorder : public DTVRecorder,
    59                     private ReaderPausedCB,
    60                     public MPEGStreamListener
     58class DVBRecorder :
     59    public DTVRecorder,
     60    public MPEGStreamListener,
     61    public DVBMainStreamListener,
     62    public ATSCMainStreamListener,
     63    private ReaderPausedCB
    6164{
    6265  public:
    6366    DVBRecorder(TVRec *rec, DVBChannel* dvbchannel);
     
    8285    void HandleCAT(const ConditionalAccessTable*) {}
    8386    void HandlePMT(uint pid, const ProgramMapTable*);
    8487
     88    // ATSC Main
     89    void HandleSTT(const SystemTimeTable*);
     90    void HandleVCT(uint /*tsid*/, const VirtualChannelTable*) {}
     91    void HandleMGT(const MasterGuideTable*) {}
     92
     93    // DVBMainStreamListener
     94    void HandleTDT(const TimeDateTable*);
     95    void HandleNIT(const NetworkInformationTable*) {}
     96    void HandleSDT(uint /*tsid*/, const ServiceDescriptionTable*) {}
     97
    8598    void SetStreamData(MPEGStreamData*);
    8699    MPEGStreamData* GetStreamData(void) { return _stream_data; }
    87100
  • libs/libmythtv/eithelper.cpp

     
    635635static int calc_eit_utc_offset(void)
    636636{
    637637    QString config_offset = gContext->GetSetting("EITTimeOffset", "Auto");
     638
    638639    if (config_offset == "Auto")
    639     {
    640         QDateTime loc = QDateTime::currentDateTime(Qt::LocalTime);
    641         QDateTime utc = QDateTime::currentDateTime(Qt::UTC);
     640        return calc_utc_offset();
    642641
    643         int utc_offset = MythSecsTo(utc, loc);
    644 
    645         // clamp to nearest minute if within 10 seconds
    646         int off = utc_offset % 60;
    647         if (abs(off) < 10)
    648             utc_offset -= off;
    649         if (off < -50 && off > -60)
    650             utc_offset -= 60 + off;
    651         if (off > +50 && off < +60)
    652             utc_offset += 60 - off;
    653 
    654         return utc_offset;
    655     }
    656642    if (config_offset == "None")
    657643        return 0;
    658644
  • libs/libmythtv/dvbchannel.h

     
    3232
    3333    // Sets
    3434    void SetPMT(const ProgramMapTable*);
     35    void SetTimeOffset(double offset);
    3536    void SetSlowTuning(uint how_slow_in_ms)
    3637        { tuning_delay = how_slow_in_ms; }
    3738
  • libs/libmythtv/dvbcam.h

     
    2323    bool Stop();
    2424    bool IsRunning() const { return ciThreadRunning; }
    2525    void SetPMT(const ProgramMapTable *pmt);
     26    void SetTimeOffset(double offset_in_seconds);
    2627
    2728  private:
    2829    static void *CiHandlerThreadHelper(void*);
  • libs/libmythtv/mpeg/mpegstreamdata.cpp

     
    11// -*- Mode: c++ -*-
    22// Copyright (c) 2003-2004, Daniel Thor Kristjansson
     3
     4// POSIX headers
     5#include <sys/time.h> // for gettimeofday
     6
    37#include "mpegstreamdata.h"
    48#include "mpegtables.h"
    59#include "RingBuffer.h"
     
    4650 */
    4751MPEGStreamData::MPEGStreamData(int desiredProgram, bool cacheTables)
    4852    : _sistandard("mpeg"),
    49       _have_CRC_bug(false), _eit_helper(NULL), _eit_rate(0.0f),
     53      _have_CRC_bug(false),
     54      _local_utc_offset(0), _si_time_offset_cnt(0),
     55      _si_time_offset_indx(0),
     56      _eit_helper(NULL), _eit_rate(0.0f),
    5057      _listener_lock(true),
    5158      _cache_tables(cacheTables), _cache_lock(true),
    5259      // Single program stuff
     
    5865      _pat_single_program(NULL), _pmt_single_program(NULL),
    5966      _invalid_pat_seen(false), _invalid_pat_warning(false)
    6067{
     68    _local_utc_offset = calc_utc_offset();
     69    bzero(_si_time_offsets, sizeof(_si_time_offsets));
     70
    6171    AddListeningPID(MPEG_PAT_PID);
    6272}
    6373
     
    627637    }
    628638}
    629639
     640double MPEGStreamData::TimeOffset(void) const
     641{
     642    QMutex locker(&_si_time_lock);
     643    if (!_si_time_offset_cnt)
     644        return 0.0;
     645
     646    double avg_offset = 0.0;
     647    double mult = 1.0 / _si_time_offset_cnt;
     648    for (uint i = 0; i < _si_time_offset_cnt; i++)
     649        avg_offset += _si_time_offsets[i] * mult;
     650
     651    return avg_offset;
     652}
     653
     654void MPEGStreamData::UpdateTimeOffset(uint64_t _si_utc_time)
     655{
     656    struct timeval tm;
     657    if (gettimeofday(&tm, NULL) != 0)
     658        return;
     659
     660    double utc_time = tm.tv_sec + (tm.tv_usec * 0.000001);
     661    double si_time  = _si_utc_time;
     662
     663    QMutex locker(&_si_time_lock);
     664    _si_time_offsets[_si_time_offset_indx] = si_time - utc_time;
     665
     666    if (_si_time_offset_indx + 1 > _si_time_offset_cnt)
     667        _si_time_offset_cnt = _si_time_offset_indx + 1;
     668
     669    _si_time_offset_indx = (_si_time_offset_indx + 1) & 0xf;
     670
     671}
     672
    630673#define DONE_WITH_PES_PACKET() { if (psip) delete psip; \
    631674    if (morePSIPPackets) goto HAS_ANOTHER_PES; else return; }
    632675
     
    642685    if (!psip)
    643686       return;
    644687
     688    // Don't do the usual checks on TDT - it has no CRC, etc...
     689    if (TableID::TDT == psip->TableID())
     690    {
     691        HandleTables(tspacket->PID(), *psip);
     692        DONE_WITH_PES_PACKET();
     693    }
     694
    645695    // drop stuffing packets
    646696    if ((TableID::ST       == psip->TableID()) ||
    647697        (TableID::STUFFING == psip->TableID()))
  • libs/libmythtv/mpeg/atscstreamdata.cpp

     
    308308        {
    309309            SystemTimeTable stt(psip);
    310310
     311            UpdateTimeOffset(stt.UTCUnix());
     312
    311313            // only update internal offset if it changes
    312314            if (stt.GPSOffset() != _GPS_UTC_offset)
    313315                _GPS_UTC_offset = stt.GPSOffset();
    314316
     317            _listener_lock.lock();
    315318            for (uint i = 0; i < _atsc_main_listeners.size(); i++)
    316319                _atsc_main_listeners[i]->HandleSTT(&stt);
     320            _listener_lock.unlock();
    317321
    318322            if (_eit_helper && GPSOffset() != _eit_helper->GetGPSOffset())
    319323                _eit_helper->SetGPSOffset(GPSOffset());
  • libs/libmythtv/mpeg/dvbtables.cpp

     
    169169    return is_eit;
    170170}
    171171
    172 uint DVBEventInformationTable::StartTimeUnixUTC(uint i) const
    173 {
    174     const unsigned char *buf = StartTime(i);
    175 
    176     // Modified Julian date as number of days since 17th November 1858.
    177     // The unix epoch, 1st Jan 1970, was day 40587.
    178     uint mjd = (buf[0] << 8) | buf[1];
    179     if (mjd < 40587)
    180         return 0; // we don't handle pre-unix dates..
    181 
    182     uint secsSince1970 = (mjd - 40587)   * 86400;
    183     secsSince1970 += byteBCD2int(buf[2]) * 3600;
    184     secsSince1970 += byteBCD2int(buf[3]) * 60;
    185     secsSince1970 += byteBCD2int(buf[4]);
    186     return secsSince1970;
    187 }
    188 
    189172/** \fn dvbdate2qt(const unsigned char*)
    190  *  \return UTC time
     173 *  \return UTC time as QDateTime
    191174 */
    192175QDateTime dvbdate2qt(const unsigned char *buf)
    193176{
     
    228211    return QDateTime(date, time);
    229212}
    230213
    231 uint dvbdate2key(const unsigned char *buf)
     214/** \fn dvbdate2unix(const unsigned char*)
     215 *  \return UTC time as time_t
     216 */
     217time_t dvbdate2unix(const unsigned char *buf)
    232218{
     219    // Modified Julian date as number of days since 17th November 1858.
     220    // The unix epoch, 1st Jan 1970, was day 40587.
     221    uint mjd = (buf[0] << 8) | buf[1];
     222    if (mjd < 40587)
     223        return 0; // we don't handle pre-unix dates..
     224
     225    uint secsSince1970 = (mjd - 40587)   * 86400;
     226    secsSince1970 += byteBCD2int(buf[2]) * 3600;
     227    secsSince1970 += byteBCD2int(buf[3]) * 60;
     228    secsSince1970 += byteBCD2int(buf[4]);
     229    return secsSince1970;
     230}
     231
     232/** \fn dvbdate2key(const unsigned char*)
     233 *  \return UTC time as 32 bit key
     234 */
     235uint32_t dvbdate2key(const unsigned char *buf)
     236{
    233237    uint dt = (((uint)buf[0]) << 24) | (((uint)buf[1]) << 16); // 16 bits
    234238    uint tm = ((byteBCD2int(buf[2]) * 3600) +
    235239               (byteBCD2int(buf[3]) * 60) +
  • libs/libmythtv/mpeg/dvbstreamdata.cpp

     
    1919    SetVersionNITo(-1,0);
    2020    AddListeningPID(DVB_NIT_PID);
    2121    AddListeningPID(DVB_SDT_PID);
     22    AddListeningPID(DVB_TDT_PID);
    2223}
    2324
    2425DVBStreamData::~DVBStreamData()
     
    8990        return SDTSectionSeen(psip.TableIDExtension(), psip.Section());
    9091    }
    9192
     93    if (TableID::TDT == table_id)
     94        return false;
     95
    9296    bool is_eit = false;
    9397    if (DVB_EIT_PID == pid)
    9498    {
     
    183187    }
    184188    AddListeningPID(DVB_NIT_PID);
    185189    AddListeningPID(DVB_SDT_PID);
     190    AddListeningPID(DVB_TDT_PID);
    186191}
    187192
    188193/** \fn DVBStreamData::HandleTables(uint pid, const PSIPTable&)
     
    244249
    245250            return true;
    246251        }
     252        case TableID::TDT:
     253        {
     254            TimeDateTable tdt(psip);
     255
     256            UpdateTimeOffset(tdt.UTCUnix());
     257
     258            QMutexLocker locker(&_listener_lock);
     259            for (uint i = 0; i < _dvb_main_listeners.size(); i++)
     260                _dvb_main_listeners[i]->HandleTDT(&tdt);
     261
     262            return true;
     263        }
    247264        case TableID::NITo:
    248265        {
    249266            SetVersionNITo(psip.Version(), psip.LastSection());
  • libs/libmythtv/mpeg/mpegtables.h

     
    182182    DVB_SDT_PID   = 0x0011,
    183183    DVB_EIT_PID   = 0x0012,
    184184    DVB_RST_PID   = 0x0013,
    185     DVB_TOT_PID   = 0x0013,
     185    DVB_TDT_PID   = 0x0014,
    186186
    187187    // Dishnet longterm EIT is on pid 0x300
    188188    DVB_DNLONG_EIT_PID = 0x0300,
  • libs/libmythtv/mpeg/streamlisteners.h

     
    3131
    3232class NetworkInformationTable;
    3333class ServiceDescriptionTable;
     34class TimeDateTable;
    3435class DVBEventInformationTable;
    3536
    3637class MPEGStreamListener
     
    8990  protected:
    9091    virtual ~DVBMainStreamListener() {}
    9192  public:
     93    virtual void HandleTDT(const TimeDateTable*) = 0;
    9294    virtual void HandleNIT(const NetworkInformationTable*) = 0;
    9395    virtual void HandleSDT(uint tsid, const ServiceDescriptionTable*) = 0;
    9496};
  • libs/libmythtv/mpeg/atsctables.h

     
    651651    // protocol_version         8   8.0       0x00 for now
    652652
    653653    // system_time             32   9.0
    654     QDateTime SystemTimeGPS() const
     654    uint32_t GPSRaw(void) const
    655655    {
    656         uint t = ((pesdata()[9]<<24)  | (pesdata()[10]<<16) |
    657                   (pesdata()[11]<< 8) |  pesdata()[12]);
     656        return ((pesdata()[9] <<24) | (pesdata()[10]<<16) |
     657                (pesdata()[11]<< 8) |  pesdata()[12]);
     658    }
     659    QDateTime SystemTimeGPS(void) const
     660    {
    658661        QDateTime dt;
    659         dt.setTime_t(secs_Between_1Jan1970_6Jan1980 + t);
     662        dt.setTime_t(secs_Between_1Jan1970_6Jan1980 + GPSRaw());
    660663        return dt;
    661664    }
     665    time_t GPSUnix(void) const
     666        { return secs_Between_1Jan1970_6Jan1980 + GPSRaw(); }
     667    time_t UTCUnix(void) const
     668        { return GPSUnix() - GPSOffset(); }
     669
    662670    // GPS_UTC_offset           8  13.0
    663671    uint GPSOffset() const { return pesdata()[13]; }
    664672    // daylight_savings        16  14.0
  • libs/libmythtv/mpeg/mpegstreamdata.h

     
    5050    void SetCaching(bool cacheTables) { _cache_tables = cacheTables; }
    5151    virtual void Reset(int desiredProgram);
    5252
     53    /// \brief Current Offset from computer time to DVB time in seconds
     54    double TimeOffset(void) const;
     55
    5356    // EIT Source
    5457    virtual void SetEITHelper(EITHelper *eit_helper);
    5558    virtual void SetEITRate(float rate);
     
    217220
    218221    static int ResyncStream(unsigned char *buffer, int curr_pos, int len);
    219222
     223    void UpdateTimeOffset(uint64_t si_utc_time);
     224
    220225    // Caching
    221226    void IncrementRefCnt(const PSIPTable *psip) const;
    222227    virtual void DeleteCachedTable(PSIPTable *psip) const;
     
    228233
    229234    bool                      _have_CRC_bug;
    230235
     236    int                       _local_utc_offset;
     237
     238    mutable QMutex            _si_time_lock;
     239    uint                      _si_time_offset_cnt;
     240    uint                      _si_time_offset_indx;
     241    double                    _si_time_offsets[16];
     242
    231243    // Generic EIT stuff used for ATSC and DVB
    232244    EITHelper                *_eit_helper;
    233245    float                     _eit_rate;
  • libs/libmythtv/mpeg/dvbtables.h

     
    88#include "dvbdescriptors.h"
    99
    1010QDateTime dvbdate2qt(const unsigned char*);
    11 uint dvbdate2key(const unsigned char *);
     11time_t dvbdate2unix(const unsigned char*);
     12uint32_t dvbdate2key(const unsigned char*);
    1213
    1314/** \class NetworkInformationTable
    1415 *  \brief This table tells the decoder on which PIDs to find other tables.
     
    249250        { return _ptrs[i]+2; }
    250251    QDateTime StartTimeUTC(uint i) const
    251252        { return dvbdate2qt(StartTime(i)); }
    252     uint StartTimeUnixUTC(uint i) const;
    253     uint EndTimeUnixUTC(uint i) const
     253    time_t StartTimeUnixUTC(uint i) const
     254        { return dvbdate2unix(StartTime(i)); }
     255    time_t EndTimeUnixUTC(uint i) const
    254256        { return StartTimeUnixUTC(i) + DurationInSeconds(i); }
    255     /// Returns 32 bit key representing time
    256     uint StartTimeKey(uint i) const
     257    uint32_t StartTimeKey(uint i) const
    257258        { return dvbdate2key(StartTime(i)); }
    258259    //   duration              24   7.0+x
    259260    const unsigned char *Duration(uint i) const
     
    286287    mutable vector<const unsigned char*> _ptrs; // used to parse
    287288};
    288289
     290/** \class TimeDateTable
     291 *  \brief This table gives the current DVB stream time
     292 */
     293class TimeDateTable : public PSIPTable
     294{
     295  public:
     296    TimeDateTable(const PSIPTable& table)
     297        : PSIPTable(table)
     298    {
     299        assert(TableID::TDT == TableID());
     300    }
     301    ~TimeDateTable() { ; }
    289302
     303    // table_id                 8   0.0       0x70
     304    // section_syntax_indicator 1   1.0          0
     305    // reserved_future_use      1   1.1          1
     306    // reserved                 2   1.2          3
     307    // section_length          12   1.4         40
     308    // UTC_time                40   3.0          0
     309    const unsigned char *UTCdata(void) const
     310        { return pesdata() + 3; }
     311
     312    QDateTime UTC(void)  const { return dvbdate2qt(UTCdata());   }
     313    time_t UTCUnix(void) const { return dvbdate2unix(UTCdata()); }
     314};
     315
    290316#endif // _DVB_TABLES_H_
  • libs/libmythtv/dvbtypes.h

     
    1414#include <stdint.h>
    1515#include <unistd.h>
    1616
    17 // C++ headers
    18 #include <vector>
    19 using namespace std;
    20 
    2117// DVB headers
    2218#include <linux/dvb/version.h>
     19#include <linux/dvb/frontend.h>
     20#include <linux/dvb/dmx.h>
     21
    2322#if (DVB_API_VERSION != 3)
    24 #error "DVB driver includes with API version 3 not found!"
     23#    error "DVB driver includes with API version 3 not found!"
    2524#endif
    2625
    2726#ifndef DVB_API_VERSION_MINOR
    28 #define DVB_API_VERSION_MINOR 0
     27#    define DVB_API_VERSION_MINOR 0
    2928#endif
    3029
    31 #include <linux/dvb/frontend.h>
    32 #include <linux/dvb/dmx.h>
    33 
    3430#if (DVB_API_VERSION >= 3 && DVB_API_VERSION_MINOR >= 1)
    3531#    define USE_ATSC
    3632#else
     
    4339#    define VSB_16        (fe_modulation)(QAM_AUTO+2)
    4440#endif
    4541
    46 #define MPEG_TS_PKT_SIZE 188
    47 #define DEF_DMX_BUF_SIZE  64 * 1024
    48 #define MAX_SECTION_SIZE 4096
    49 #define DMX_DONT_FILTER 0x2000
    50 
    5142#ifdef FE_GET_EXTENDED_INFO
    5243  #define dvb_fe_params dvb_frontend_parameters_new
    5344#else
     
    5748class QString;
    5849QString toString(fe_status);
    5950
    60 typedef vector<uint16_t> dvb_pid_t;
    61 // needs to add provider id so dvbcam doesnt require parsing
    62 // of the pmt and or the pmtcache
    63 typedef vector<uint16_t> dvb_caid_t;
    64 
    6551#endif // DVB_TYPES_H
  • libs/libmythtv/dvbchannel.cpp

     
    534534        dvbcam->SetPMT(pmt);
    535535}
    536536
     537/** \fn DVBChannel::SetTimeOffset(double)
     538 *  \brief Tells the Conditional Access Module the offset
     539 *         from the computers utc time to dvb time.
     540 */
     541void DVBChannel::SetTimeOffset(double offset)
     542{
     543    if (dvbcam->IsRunning())
     544        dvbcam->SetTimeOffset(offset);
     545}
     546
    537547/*****************************************************************************
    538548           Tuning functions for each of the four types of cards.
    539549 *****************************************************************************/
  • libs/libmythtv/siscan.h

     
    9494    // DVB Main
    9595    void HandleNIT(const NetworkInformationTable*);
    9696    void HandleSDT(uint tsid, const ServiceDescriptionTable*);
     97    void HandleTDT(const TimeDateTable*) {}
    9798
    9899  private slots:
    99100    void HandleAllGood(void);
  • libs/libmythtv/dvbcam.cpp

     
    273273    pmt_updated = true;
    274274}
    275275
     276void DVBCam::SetTimeOffset(double offset_in_seconds)
     277{
     278    ciHandler->SetTimeOffset(offset_in_seconds);
     279}
     280
    276281static const char *cplm_info[] =
    277282{
    278283    "CPLM_MORE",
  • libs/libmythtv/dtvsignalmonitor.h

     
    8888    void HandlePMT(uint, const ProgramMapTable*);
    8989
    9090    // ATSC Main
    91     void HandleSTT(const SystemTimeTable*) {}
     91    void HandleSTT(const SystemTimeTable*);
    9292    void HandleVCT(uint /*tsid*/, const VirtualChannelTable*) {}
    9393    void HandleMGT(const MasterGuideTable*);
    9494
     
    101101        const DirectedChannelChangeSelectionCodeTable*) {}
    102102
    103103    // DVB Main
     104    void HandleTDT(const TimeDateTable*);
    104105    void HandleNIT(const NetworkInformationTable*);
    105106    void HandleSDT(uint, const ServiceDescriptionTable*);
    106107
  • libs/libmythtv/dvbsignalmonitor.cpp

     
    1414#include "mythdbcon.h"
    1515#include "dvbsignalmonitor.h"
    1616#include "dvbchannel.h"
     17#include "dvbstreamdata.h"
    1718#include "atscstreamdata.h"
    1819#include "mpegtables.h"
    1920#include "atsctables.h"
     
    555556    }
    556557}
    557558
     559void DVBSignalMonitor::HandlePMT(uint program_num, const ProgramMapTable *pmt)
     560{
     561    DTVSignalMonitor::HandlePMT(program_num, pmt);
     562    GetDVBChannel()->SetPMT(pmt);
     563}
     564
     565void DVBSignalMonitor::HandleSTT(const SystemTimeTable *stt)
     566{
     567    DTVSignalMonitor::HandleSTT(stt);
     568    GetDVBChannel()->SetTimeOffset(GetStreamData()->TimeOffset());
     569}
     570
     571void DVBSignalMonitor::HandleTDT(const TimeDateTable *tdt)
     572{
     573    DTVSignalMonitor::HandleTDT(tdt);
     574    GetDVBChannel()->SetTimeOffset(GetStreamData()->TimeOffset());
     575}
     576
     577DVBChannel *DVBSignalMonitor::GetDVBChannel(void)
     578{
     579    return dynamic_cast<DVBChannel*>(channel);
     580}
     581
    558582void DVBSignalMonitor::RunTableMonitor(void)
    559583{
    560584    dtvMonitorRunning = true;
  • libs/libmythtv/dtvsignalmonitor.cpp

     
    341341    }
    342342}
    343343
     344void DTVSignalMonitor::HandleSTT(const SystemTimeTable*)
     345{
     346    VERBOSE(VB_CHANNEL, LOC + "Time Offset: "<<GetStreamData()->TimeOffset());
     347}
     348
    344349void DTVSignalMonitor::HandleMGT(const MasterGuideTable* mgt)
    345350{
    346351    AddFlags(kDTVSigMon_MGTSeen);
     
    405410    AddFlags(kDTVSigMon_VCTMatch | kDTVSigMon_CVCTMatch);
    406411}
    407412
     413void DTVSignalMonitor::HandleTDT(const TimeDateTable*)
     414{
     415    VERBOSE(VB_CHANNEL, LOC + "Time Offset: "<<GetStreamData()->TimeOffset());
     416}
     417
    408418void DTVSignalMonitor::HandleNIT(const NetworkInformationTable *nit)
    409419{
    410420    DBG_SM("SetNIT()", QString("net_id = %1").arg(nit->NetworkID()));
  • libs/libmyth/util.cpp

     
    6262    return rettime;
    6363}
    6464
     65int calc_utc_offset(void)
     66{
     67    QDateTime loc = QDateTime::currentDateTime(Qt::LocalTime);
     68    QDateTime utc = QDateTime::currentDateTime(Qt::UTC);
     69
     70    int utc_offset = MythSecsTo(utc, loc);
     71
     72    // clamp to nearest minute if within 10 seconds
     73    int off = utc_offset % 60;
     74    if (abs(off) < 10)
     75        utc_offset -= off;
     76    if (off < -50 && off > -60)
     77        utc_offset -= 60 + off;
     78    if (off > +50 && off < +60)
     79        utc_offset += 60 - off;
     80
     81    return utc_offset;
     82}
     83
    6584/** \fn encodeLongLong(QStringList&,long long)
    6685 *  \brief Encodes a long for streaming in the MythTV protocol.
    6786 *
  • libs/libmyth/util.h

     
    3939};
    4040
    4141MPUBLIC QDateTime mythCurrentDateTime();
     42MPUBLIC int calc_utc_offset(void);
    4243
    4344// This is necessary for GCC 3.3, which has llabs(long long)
    4445// but not abs(long long) or std::llabs(long long)