channelutil.h

Go to the documentation of this file.

// -*- Mode: c++ -*-
#ifndef CHANUTIL_H
#define CHANUTIL_H

// C++ headers
#include <cstdint>
#include <deque>
#include <vector>
using namespace std;

// Qt headers
#include <QString>
#include <QCoreApplication>

// MythTV headers
#include "mythtvexp.h"
#include "dtvmultiplex.h"
#include "channelinfo.h"
#include "iptvtuningdata.h"
#include "tv.h" // for CHANNEL_DIRECTION

class NetworkInformationTable;

class pid_cache_item_t
{
  public:
    pid_cache_item_t() = default;
    pid_cache_item_t(uint pid, uint sid_tid) :
        m_pid(pid), m_sid_tid(sid_tid) {}
    uint GetPID(void) const { return m_pid; }
    uint GetStreamID(void) const
        { return (m_sid_tid&0x100) ? GetID() : 0; }
    uint GetTableID(void) const
        { return (m_sid_tid&0x100) ? 0 : GetID(); }
    uint GetID(void) const { return m_sid_tid & 0xff; }
    bool IsPCRPID(void) const { return ( m_sid_tid&0x200 ) != 0; }
    bool IsPermanent(void) const { return ( m_sid_tid&0x10000 ) != 0; }
    uint GetComposite(void) const { return m_sid_tid; }
  private:
    uint m_pid     {0};
    uint m_sid_tid {0};
};
typedef vector<pid_cache_item_t> pid_cache_t;

class MTV_PUBLIC ChannelUtil
{
    Q_DECLARE_TR_FUNCTIONS(ChannelUtil);

  public:
    // Multiplex Stuff

    static uint    CreateMultiplex(
        int  sourceid,          QString sistandard,
        uint64_t frequency,     QString modulation,
        int  transport_id = -1, int     network_id = -1);

    static uint    CreateMultiplex(
        int         sourceid,     QString     sistandard,
        uint64_t    frequency,    QString     modulation,
        // DVB specific
        int         transport_id, int         network_id,
        int         symbol_rate,  signed char bandwidth,
        signed char polarity,     signed char inversion,
        signed char trans_mode,
        QString     inner_FEC,    QString     constellation,
        signed char hierarchy,    QString     hp_code_rate,
        QString     lp_code_rate, QString     guard_interval,
        QString     mod_sys,      QString     rolloff);

    static uint    CreateMultiplex(uint sourceid, const DTVMultiplex&,
                                   int transport_id, int network_id);

    static vector<uint> CreateMultiplexes(
        int sourceid, const NetworkInformationTable *nit);

    static uint    GetMplexID(uint sourceid, const QString &channum);
    static int     GetMplexID(uint sourceid,     uint64_t frequency);
    static int     GetMplexID(uint sourceid,     uint64_t frequency,
                              uint transport_id, uint network_id);
    static int     GetMplexID(uint sourceid,
                              uint transport_id, uint network_id);
    static uint    GetMplexID(uint chanid);
    static int     GetBetterMplexID(int current_mplexid,
                                    int transport_id, int network_id);

    static bool    GetTuningParams(uint mplexid,
                                   QString  &modulation,
                                   uint64_t &frequency,
                                   uint     &dvb_transportid,
                                   uint     &dvb_networkid,
                                   QString  &si_std);

    static bool    GetATSCChannel(uint sourceid, const QString &channum,
                                  uint &major,   uint          &minor);
    static bool    IsATSCChannel(uint sourceid, const QString &channum)
        { uint m1, m2; GetATSCChannel(sourceid, channum, m1,m2); return m2; }

    // Channel/Service Stuff
    static int     CreateChanID(uint sourceid, const QString &chan_num);

    static bool    CreateChannel(uint db_mplexid,
                                 uint db_sourceid,
                                 uint new_channel_id,
                                 const QString &callsign,
                                 const QString &service_name,
                                 const QString &chan_num,
                                 uint service_id,
                                 uint atsc_major_channel,
                                 uint atsc_minor_channel,
                                 bool use_on_air_guide,
                                 bool hidden,
                                 bool hidden_in_guide,
                                 const QString &freqid,
                                 QString icon    = QString(),
                                 QString format  = "Default",
                                 QString xmltvid = QString(),
                                 QString default_authority = QString());

    static bool    UpdateChannel(uint db_mplexid,
                                 uint source_id,
                                 uint channel_id,
                                 const QString &callsign,
                                 const QString &service_name,
                                 const QString &chan_num,
                                 uint service_id,
                                 uint atsc_major_channel,
                                 uint atsc_minor_channel,
                                 bool use_on_air_guide,
                                 bool hidden,
                                 bool hidden_in_guide,
                                 const QString& freqid  = QString(),
                                 const QString& icon    = QString(),
                                 QString format  = QString(),
                                 const QString& xmltvid = QString(),
                                 const QString& default_authority = QString());

    static bool    CreateIPTVTuningData(
        uint channel_id, const IPTVTuningData &tuning)
    {
        return UpdateIPTVTuningData(channel_id, tuning);
    }

    static bool    UpdateIPTVTuningData(
        uint channel_id, const IPTVTuningData &tuning);

    static void    UpdateInsertInfoFromDB(ChannelInsertInfo &chan);
    static void    UpdateChannelNumberFromDB(ChannelInsertInfo &chan);

    static bool    DeleteChannel(uint channel_id);

    static bool    SetVisible(uint channel_id, bool visible);

    static bool    SetServiceVersion(int mplexid, int version);

    static int     GetChanID(int db_mplexid,    int service_transport_id,
                             int major_channel, int minor_channel,
                             int program_number);

    static int     GetServiceVersion(int mplexid);

    // Misc gets
    static QString GetDefaultAuthority(uint chanid);
    static QString GetIcon(uint chanid);
    static vector<uint> GetInputIDs(uint chanid);
    static QString GetUnknownCallsign(void);
    static uint    FindChannel(uint sourceid, const QString &freqid);
    static int     GetChanID(uint sourceid, const QString &channum)
        { return GetChannelValueInt("chanid", sourceid, channum); }
    static bool    GetChannelData(
        uint    sourceid,
        uint    &chanid,          const QString &channum,
        QString &tvformat,        QString       &modulation,
        QString &freqtable,       QString       &freqid,
        int     &finetune,        uint64_t      &frequency,
        QString &dtv_si_std,      int     &mpeg_prog_num,
        uint    &atsc_major,      uint          &atsc_minor,
        uint    &dvb_transportid, uint          &dvb_networkid,
        uint    &mplexid,         bool          &commfree);
    static int     GetProgramNumber(uint sourceid, const QString &channum)
        { return GetChannelValueInt("serviceid", sourceid, channum); }
    static QString GetVideoFilters(uint sourceid, const QString &channum)
        { return GetChannelValueStr("videofilters", sourceid, channum); }
    static IPTVTuningData GetIPTVTuningData(uint chanid);

    // Are there any other possibly useful sort orders?
    // e.g. Sorting by sourceid would probably be better done by two distinct
    // calls to LoadChannels specifying the sourceid
    enum OrderBy
    {
        kChanOrderByChanNum,
        kChanOrderByName,
        kChanOrderByLiveTV,
    };

    enum GroupBy
    {
        kChanGroupByCallsign,
        kChanGroupByChanid // Because of the nature of the query we always need to group
    };

    static ChannelInfoList LoadChannels(uint startIndex, uint count,
                                        uint &totalAvailable,
                                        bool ignoreHidden = true,
                                        OrderBy orderBy = kChanOrderByChanNum,
                                        GroupBy groupBy = kChanGroupByChanid,
                                        uint sourceID = 0,
                                        uint channelGroupID = 0,
                                        bool liveTVOnly = false,
                                        const QString& callsign = "",
                                        const QString& channum = "");

    static ChannelInfoList GetChannels(
        uint sourceid, bool visible_only, 
        const QString &group_by = QString(), uint channel_groupid = 0)
    {
        return GetChannelsInternal(sourceid, visible_only, false,
                                   group_by, channel_groupid);
    }


    static ChannelInfoList GetAllChannels(uint sourceid)
    {
        return GetChannelsInternal(sourceid, false, true, QString(), 0);
    }
    static vector<uint> GetChanIDs(int sourceid = -1, bool onlyVisible = false);
    static uint    GetChannelCount(int sourceid = -1);
    static void    SortChannels(ChannelInfoList &list, const QString &order,
                                bool eliminate_duplicates = false);
    static int     GetNearestChannel(const ChannelInfoList &list,
                                     const QString &channum);

    static uint    GetNextChannel(const ChannelInfoList &sorted,
                                  uint old_chanid,
                                  uint mplexid_restriction,
                                  uint chanid_restriction,
                                  ChannelChangeDirection direction,
                                  bool skip_non_visible = true,
                                  bool skip_same_channum_and_callsign = false);

    static QString GetChannelValueStr(const QString &channel_field,
                                      uint           sourceid,
                                      const QString &channum);

    static int     GetChannelValueInt(const QString &channel_field,
                                      uint           sourceid,
                                      const QString &channum);

    static bool    IsOnSameMultiplex(uint srcid,
                                     const QString &new_channum,
                                     const QString &old_channum);

    static QStringList GetValidRecorderList(uint            chanid,
                                            const QString &channum);

    static bool    IsConflicting(const QString &channum,
                                 uint sourceid = 0, uint excluded_chanid = 0)
    {
        vector<uint> chanids = GetConflicting(channum, sourceid);
        return (chanids.size() > 1) ||
            ((1 == chanids.size()) && (chanids[0] != excluded_chanid));
    }

    static vector<uint> GetConflicting(const QString &channum,
                                       uint sourceid = 0);

    static QString GetChanNum(int chan_id);

    static int     GetTimeOffset(int chan_id);
    static int     GetSourceID(int mplexid);
    static uint    GetSourceIDForChannel(uint chanid);

    static QStringList GetInputTypes(uint chanid);

    static bool    GetCachedPids(uint chanid, pid_cache_t &pid_cache);

    // Misc sets
    static bool    SetChannelValue(const QString &field_name,
                                   const QString& value,
                                   uint           sourceid,
                                   const QString &channum);

    static bool    SetChannelValue(const QString &field_name,
                                   const QString& value,
                                   int            chanid);

    static bool    SaveCachedPids(uint chanid,
                                  const pid_cache_t &_pid_cache,
                                  bool delete_all = false);

    static const QString kATSCSeparators;

  private:
    static ChannelInfoList GetChannelsInternal(
        uint sourceid, bool visible_only, bool include_disconnected,
        const QString &group_by, uint channel_groupid);
    static QString GetChannelStringField(int chan_id, const QString &field);
};

#endif // CHANUTIL_H