mhi.h

Go to the documentation of this file.

#ifndef MHI_H
#define MHI_H
 
// Misc header
#include <ft2build.h>
#include FT_FREETYPE_H
 
// STL headers
#include <list>
#include <vector>
 
// Qt headers
#include <QWaitCondition>
#include <QRunnable>
#include <QString>
#include <QMutex>
#include <QImage>
#include <QList>
#include <QRect>
#include <QPair>
#include <QMap>                         // for QMap
#include <QRegion>                      // for QRegion
#include <QSize>                        // for QSize
 
// MythTV headers
#include "libmythbase/mythdeque.h"
#include "libmythfreemheg/freemheg.h"
 
#include "mhegic.h"
 
class MythPainter;
class InteractiveScreen;
class DSMCCPacket;
class MHIImageData;
class MHIContext;
class MythAVCopy;
class Dsmcc;
class InteractiveTV;
class MHStream;
class MThread;
class QByteArray;
 
// Special value for the NetworkBootInfo version.  Real values are a byte.
static constexpr uint16_t NBI_VERSION_UNSET { 257 };
 
class MHIContext : public MHContext, public QRunnable
{
  public:
    explicit MHIContext(InteractiveTV *parent);
    ~MHIContext() override;
 
    void QueueDSMCCPacket(unsigned char *data, int length, int componentTag,
        unsigned carouselId, int dataBroadcastId);
    // A NetworkBootInfo sub-descriptor is present in the PMT.
    void SetNetBootInfo(const unsigned char *data, uint length);
    void Restart(int chanid, int sourceid, bool isLive);
    // Offer a key press.  Returns true if it accepts it.
    // This will depend on the current profile.
    bool OfferKey(const QString& key);
    void UpdateOSD(InteractiveScreen *osdWindow, MythPainter *osdPainter);
    void Reinit(QRect videoRect, QRect dispRect, float aspect);
 
    void StopEngine(void);
 
    // Test for an object in the carousel.
    // Returns true if the object is present and
    // so a call to GetCarouselData will not block and will return the data.
    // Returns false if the object is not currently present because it has not
    // yet appeared and also if it is not present in the containing directory.
    bool CheckCarouselObject(const QString& objectPath) override; // MHContext
 
    // Get an object from the carousel.  Returns true and sets the data if
    // it was able to retrieve the named object.  Blocks if the object seems
    // to be present but has not yet appeared.  Returns false if the object
    // cannot be retrieved.
    bool GetCarouselData(const QString& objectPath, QByteArray &result) override; // MHContext
 
    // Set the input register.  This sets the keys that are to be handled
    // by MHEG.  Flushes the key queue.
    void SetInputRegister(int num) override; // MHContext
 
    void RequireRedraw(const QRegion &region) override; // MHContext
 
    bool CheckStop(void) override // MHContext
        { return m_stop; }
 
    void GetInitialStreams(int &audioTag, int &videoTag) const;
 
    MHDLADisplay *CreateDynamicLineArt(
        bool isBoxed, MHRgba lineColour, MHRgba fillColour) override; // MHContext
    MHTextDisplay *CreateText(void) override; // MHContext
    MHBitmapDisplay *CreateBitmap(bool tiled) override; // MHContext
    void DrawRect(int xPos, int yPos, int width, int height,
                  MHRgba colour) override; // MHContext
    void DrawBackground(const QRegion &reg) override; // MHContext
    void DrawVideo(const QRect &videoRect, const QRect &dispRect) override; // MHContext
 
    void DrawImage(int x, int y, QRect rect, const QImage &image,
        bool bScaled = false, bool bUnder = false);
 
    int GetChannelIndex(const QString &str) override; // MHContext
    bool GetServiceInfo(int channelId, int &netId, int &origNetId,
                        int &transportId, int &serviceId) override; // MHContext
    bool TuneTo(int channel, int tuneinfo) override; // MHContext
 
    bool BeginStream(const QString &str, MHStream* notify) override; // MHContext
    void EndStream() override; // MHContext
    // Called when the stream starts or stops
    bool StreamStarted(bool bStarted = true);
    bool BeginAudio(int tag) override; // MHContext
    void StopAudio() override; // MHContext
    bool BeginVideo(int tag) override; // MHContext
    void StopVideo() override; // MHContext
    // Get current stream position, -1 if unknown
    std::chrono::milliseconds GetStreamPos() override; // MHContext
    // Get current stream size, -1 if unknown
    std::chrono::milliseconds GetStreamMaxPos() override; // MHContext
    // Set current stream position
    std::chrono::milliseconds SetStreamPos(std::chrono::milliseconds pos) override; // MHContext
    // Play or pause a stream
    void StreamPlay(bool play) override; // MHContext
 
    // Get the context id strings.  The format of these strings is specified
    // by the UK MHEG profile.
    const char *GetReceiverId(void) override // MHContext
        { return "MYT001001"; } // Version number?
    const char *GetDSMCCId(void) override // MHContext
        { return "DSMMYT001"; } // DSMCC version.
 
    // InteractionChannel
    // 0= Active, 1= Inactive, 2= Disabled
    int GetICStatus() override; // MHContext
 
    // Operations used by the display classes
    // Add an item to the display vector
    void AddToDisplay(const QImage &image, QRect rect, bool bUnder = false);
    int ScaleX(int n, bool roundup = false) const;
    int ScaleY(int n, bool roundup = false) const;
    QRect Scale(QRect r) const;
    int ScaleVideoX(int n, bool roundup = false) const;
    int ScaleVideoY(int n, bool roundup = false) const;
    QRect ScaleVideo(QRect r) const;
 
    FT_Face GetFontFace(void) { return m_face; }
    bool IsFaceLoaded(void) const { return m_faceLoaded; }
    bool LoadFont(const QString& name);
    bool ImageUpdated(void) const { return m_updated; }
 
    static const int kStdDisplayWidth = 720;
    static const int kStdDisplayHeight = 576;
 
  protected:
    void run(void) override; // QRunnable
    void ProcessDSMCCQueue(void);
    void NetworkBootRequested(void);
    void ClearDisplay(void);
    void ClearQueue(void);
    bool LoadChannelCache();
    bool GetDSMCCObject(const QString &objectPath, QByteArray &result);
    bool CheckAccess(const QString &objectPath, QByteArray &cert);
 
    InteractiveTV   *m_parent         {nullptr};
 
    // Pointer to the DSMCC object carousel.
    Dsmcc           *m_dsmcc          {nullptr};
    QMutex           m_dsmccLock;
    MythDeque<DSMCCPacket*> m_dsmccQueue;
 
    MHInteractionChannel m_ic;  // Interaction channel
    MHStream        *m_notify         {nullptr};
 
    QMutex           m_keyLock;
    MythDeque<int>   m_keyQueue;
    int              m_keyProfile     {0};
 
    MHEG            *m_engine; // Pointer to the MHEG engine
 
    mutable QMutex   m_runLock;
    QWaitCondition   m_engineWait; // protected by m_runLock
    bool             m_stop           {false}; // protected by m_runLock
    QMutex           m_displayLock;
    bool             m_updated        {false};
 
    std::list<MHIImageData*> m_display; // List of items to display
 
    FT_Face          m_face           {nullptr};
    bool             m_faceLoaded     {false};
 
    MThread         *m_engineThread   {nullptr};
 
    int              m_currentChannel {-1};
    int              m_currentStream  {-1};
    bool             m_isLive         {false};
    int              m_currentSource  {-1};
 
    int              m_audioTag       {-1};
    int              m_videoTag       {-1};
    QList<int>       m_tuneInfo;
 
    uint             m_lastNbiVersion {NBI_VERSION_UNSET};
    std::vector<unsigned char> m_nbiData;
 
    QRect            m_videoRect, m_videoDisplayRect;
    QRect            m_displayRect;
 
    // Channel index database cache
    using Val_t = QPair< int, int >; // transportid, chanid
    using Key_t = QPair< int, int >; // networkid, serviceid
    using ChannelCache_t = QMultiMap< Key_t, Val_t >;
    ChannelCache_t  m_channelCache;
    QMutex          m_channelMutex;
    static int Tid(ChannelCache_t::const_iterator it) { return it->first; }
    static int Cid(ChannelCache_t::const_iterator it) { return it->second; }
    static int Nid(ChannelCache_t::const_iterator it) { return it.key().first; }
    static int Sid(ChannelCache_t::const_iterator it) { return it.key().second; }
};
 
// Object for drawing text.
class MHIText : public MHTextDisplay
{
  public:
    explicit MHIText(MHIContext *parent)
        : m_parent(parent) {}
    ~MHIText() override = default;
 
    void Draw(int x, int y) override; // MHTextDisplay
    void Clear(void) override; // MHTextDisplay
    void AddText(int x, int y, const QString &str, MHRgba colour) override; // MHTextDisplay
 
    void SetSize(int width, int height) override; // MHTextDisplay
    void SetFont(int size, bool isBold, bool isItalic) override; // MHTextDisplay
 
    QRect GetBounds(const QString &str, int &strLen, int maxSize = -1) override; // MHTextDisplay
 
  public:
    MHIContext *m_parent     {nullptr};
    QImage      m_image;
    int         m_fontSize   {12};
    bool        m_fontItalic {false};
    bool        m_fontBold   {false};
    int         m_width      {0};
    int         m_height     {0};
};
 
class MHIBitmap : public MHBitmapDisplay
{
  public:
    MHIBitmap(MHIContext *parent, bool tiled);
    ~MHIBitmap() override;
 
    // Deleted functions should be public.
    MHIBitmap(const MHIBitmap &) = delete;            // not copyable
    MHIBitmap &operator=(const MHIBitmap &) = delete; // not copyable
 
    void CreateFromPNG(const unsigned char *data, int length) override; // MHBitmapDisplay
 
    void CreateFromMPEG(const unsigned char *data, int length) override; // MHBitmapDisplay
 
    void CreateFromJPEG(const unsigned char *data, int length) override; // MHBitmapDisplay
 
    void Draw(int x, int y, QRect rect, bool tiled, bool bUnder) override; // MHBitmapDisplay
 
    void ScaleImage(int newWidth, int newHeight) override; // MHBitmapDisplay
 
    // Gets
    QSize GetSize(void) override { return m_image.size(); } // MHBitmapDisplay
    bool IsOpaque(void) override { return !m_image.isNull() && m_opaque; } // MHBitmapDisplay
 
  public:
    MHIContext *m_parent  {nullptr};
    bool        m_tiled;
    QImage      m_image;
    bool        m_opaque  {false};
    MythAVCopy *m_copyCtx {nullptr};
};
 
class MHIDLA : public MHDLADisplay
{
  public:
    MHIDLA(MHIContext *parent, bool isBoxed,
           MHRgba lineColour, MHRgba fillColour)
        : m_parent(parent),            m_boxed(isBoxed),
          m_boxLineColour(lineColour), m_boxFillColour(fillColour) {}
    void Draw(int x, int y) override; // MHDLADisplay
    void SetSize(int width, int height) override // MHDLADisplay
    {
        m_width  = width;
        m_height = height;
        Clear();
    }
    void SetLineSize(int width) override // MHDLADisplay
        { m_lineWidth = width;   }
    void SetLineColour(MHRgba colour) override // MHDLADisplay
        { m_lineColour = colour; }
    void SetFillColour(MHRgba colour) override // MHDLADisplay
        { m_fillColour = colour; }
 
    void Clear(void) override; // MHDLADisplay
 
    // add items to the drawing.
    void DrawLine(int x1, int y1, int x2, int y2) override; // MHDLADisplay
    void DrawBorderedRectangle(int x, int y, int width, int height) override; // MHDLADisplay
    void DrawOval(int x, int y, int width, int height) override; // MHDLADisplay
    void DrawArcSector(int x, int y, int width, int height,
                       int start, int arc, bool isSector) override; // MHDLADisplay
    void DrawPoly(bool isFilled, const MHPointVec& xArray, const MHPointVec& yArray) override; // MHDLADisplay
 
  protected:
    void DrawRect(int x, int y, int width, int height, MHRgba colour);
    void DrawLineSub(int x1, int y1, int x2, int y2, bool swapped);
 
  protected:
    MHIContext *m_parent        {nullptr};
    QImage      m_image;
    int         m_width         {0}; 
    int         m_height        {0}; 
    bool        m_boxed;             
    MHRgba      m_boxLineColour;     
    MHRgba      m_boxFillColour;     
    MHRgba      m_lineColour;        
    MHRgba      m_fillColour;        
    int         m_lineWidth     {0}; 
};
 
class DSMCCPacket
{
  public:
    DSMCCPacket(unsigned char *data, int length, int tag,
                unsigned car, int dbid)
        : m_componentTag(tag),    m_carouselId(car),
          m_dataBroadcastId(dbid)
    {
        m_data.assign(data, data+length);
    }
 
  public:
    std::vector<uint8_t> m_data;
    int            m_componentTag;
    unsigned       m_carouselId;
    int            m_dataBroadcastId;
};
 
#endif // MHI_H