recorderbase.h

Go to the documentation of this file.

// -*- Mode: c++ -*-
#ifndef RECORDERBASE_H_
#define RECORDERBASE_H_
 
#include <cstdint>
 
#include <QWaitCondition>
#include <QAtomicInt>
#include <QDateTime>
#include <QRunnable>
#include <QString>
#include <QMutex>
#include <QMap>
 
#include "recordingquality.h"
#include "programtypes.h" // for MarkTypes, frm_pos_map_t
#include "mythtimer.h"
#include "mythtvexp.h"
#include "recordingfile.h"
 
extern "C"
{
#include "libavcodec/avcodec.h" // for Video/Audio codec enums
}
 
class FireWireDBOptions;
class GeneralDBOptions;
class RecordingProfile;
class RecordingInfo;
class DVBDBOptions;
class RecorderBase;
class ChannelBase;
class MythMediaBuffer;
class TVRec;
 
class FrameRate
{
public:
    explicit FrameRate(uint n, uint d=1) : m_num(n), m_den(d) {}
    double toDouble(void) const { return m_num / (double)m_den; }
    bool isNonzero(void) const { return m_num != 0U; }
    uint getNum(void) const { return m_num; }
    uint getDen(void) const { return m_den; }
    QString toString(void) const { return QString("%1/%2").arg(m_num).arg(m_den); }
    bool operator==(const FrameRate other) const {
        return m_num == other.m_num && m_den == other.m_den;
    }
    bool operator!=(const FrameRate other) const { return !(*this == other); }
private:
    uint m_num;
    uint m_den;
};
 
enum class SCAN_t : uint8_t {
    UNKNOWN_SCAN,
    INTERLACED,
    PROGRESSIVE,
    VARIABLE
};
 
class MTV_PUBLIC RecorderBase : public QRunnable
{
    friend class Transcode; // for access to SetIntOption(), SetStrOption()
 
  public:
    explicit RecorderBase(TVRec *rec);
    ~RecorderBase() override;
 
    void SetFrameRate(double rate)
    {
        m_videoFrameRate = rate;
        m_ntscFrameRate = (29.96 <= rate && 29.98 >= rate);
        m_frameRate = FrameRate(lround(rate * 100), 100);
    }
 
    void SetRecording(const RecordingInfo *pginfo);
 
    void SetRingBuffer(MythMediaBuffer *Buffer);
 
    virtual void SetOption(const QString &name, const QString &value);
 
    virtual void SetOption(const QString &name, int value);
 
    void SetBoolOption(const QString &name, bool value)
        { SetOption(name, static_cast<int>(value)); }
 
    virtual void SetVideoFilters(QString &filters) = 0;
 
    virtual void SetOptionsFromProfile(RecordingProfile *profile,
                                       const QString &videodev,
                                       const QString &audiodev,
                                       const QString &vbidev) = 0;
 
    void SetNextRecording(const RecordingInfo *ri, MythMediaBuffer *Buffer);
 
    virtual void Initialize(void) = 0;
 
    void run(void) override = 0; // QRunnable
 
    virtual void Reset(void) = 0;
 
    virtual bool IsErrored(void) = 0;
 
    virtual long long GetFramesWritten(void) = 0;
 
    virtual int GetVideoFd(void) = 0;
 
    long long GetKeyframePosition(long long desired) const;
    bool GetKeyframePositions(
        long long start, long long end, frm_pos_map_t &map) const;
    bool GetKeyframeDurations(
        long long start, long long end, frm_pos_map_t &map) const;
 
    virtual void StopRecording(void);
    virtual bool IsRecording(void);
    virtual bool IsRecordingRequested(void);
 
    virtual RecordingQuality *GetRecordingQuality(const RecordingInfo *ri) const;
 
    // pausing interface
    virtual void Pause(bool clear = true);
    virtual void Unpause(void);
    virtual bool IsPaused(bool holding_lock = false) const;
    virtual bool WaitForPause(int timeout = 1000);
 
    double GetFrameRate(void) const { return m_frameRate.toDouble(); }
 
    virtual bool CheckForRingBufferSwitch(void);
 
    void SavePositionMap(bool force = false, bool finished = false);
 
    enum AspectRatio {
        ASPECT_UNKNOWN       = 0x00,
        ASPECT_1_1           = 0x01,
        ASPECT_4_3           = 0x02,
        ASPECT_16_9          = 0x03,
        ASPECT_2_21_1        = 0x04,
        ASPECT_CUSTOM        = 0x05,
    };
 
    static RecorderBase *CreateRecorder(
        TVRec                  *tvrec,
        ChannelBase            *channel,
        RecordingProfile       &profile,
        const GeneralDBOptions &genOpt);
 
  protected:
    void SetIntOption(RecordingProfile *profile, const QString &name);
    void SetStrOption(RecordingProfile *profile, const QString &name);
    virtual bool PauseAndWait(int timeout = 100);
 
    virtual void ResetForNewFile(void) = 0;
    virtual void SetRecordingStatus(RecStatus::Type status,
                                    const QString& file, int line);
    virtual void ClearStatistics(void);
    virtual void FinishRecording(void);
    virtual void StartNewFile(void) { }
 
    void SetPositionMapType(MarkTypes type) { m_positionMapType = type; }
 
    void AspectChange(uint aspect, long long frame);
 
    void ResolutionChange(uint width, uint height, long long frame);
 
    void FrameRateChange(uint framerate, uint64_t frame);
 
    void VideoScanChange(SCAN_t scan, uint64_t frame);
 
    void VideoCodecChange(AVCodecID vCodec);
 
    void AudioCodecChange(AVCodecID aCodec);
 
    void SetDuration(uint64_t duration);
 
    void SetTotalFrames(uint64_t total_frames);
 
    void TryWriteProgStartMark(const frm_pos_map_t &durationDeltaCopy);
 
    TVRec         *m_tvrec                {nullptr};
    MythMediaBuffer *m_ringBuffer         {nullptr};
    bool           m_weMadeBuffer         {true};
 
    AVContainer    m_containerFormat      {formatUnknown};
    AVCodecID      m_primaryVideoCodec    {AV_CODEC_ID_NONE};
    AVCodecID      m_primaryAudioCodec    {AV_CODEC_ID_NONE};
    QString        m_videocodec           {"rtjpeg"};
    QString        m_videodevice;
 
    bool           m_ntsc                 {true};
    bool           m_ntscFrameRate        {true};
    double         m_videoFrameRate       {29.97};
 
    uint           m_videoAspect          {0}; // AspectRatio (1 = 4:3, 2 = 16:9
 
    uint           m_videoHeight          {0};
    uint           m_videoWidth           {0};
    FrameRate      m_frameRate            {0};
 
    RecordingInfo *m_curRecording         {nullptr};
 
    // For handling pausing + stop recording
    mutable QMutex m_pauseLock; // also used for request_recording and recording
    bool           m_requestPause         {false};
    bool           m_paused               {false};
    QWaitCondition m_pauseWait;
    QWaitCondition m_unpauseWait;
    bool           m_requestRecording     {false};
    bool           m_recording            {false};
    QWaitCondition m_recordingWait;
 
 
    // For RingBuffer switching
    QMutex         m_nextRingBufferLock;
    MythMediaBuffer    *m_nextRingBuffer       {nullptr};
    RecordingInfo *m_nextRecording        {nullptr};
    MythTimer      m_ringBufferCheckTimer;
 
    // Seektable  support
    MarkTypes      m_positionMapType      {MARK_GOP_BYFRAME};
    mutable QMutex m_positionMapLock;
    frm_pos_map_t  m_positionMap;
    frm_pos_map_t  m_positionMapDelta;
    frm_pos_map_t  m_durationMap;
    frm_pos_map_t  m_durationMapDelta;
    MythTimer      m_positionMapTimer;
 
    // ProgStart mark support
    qint64         m_estimatedProgStartMS {0};
    long long      m_lastSavedKeyframe    {0};
    long long      m_lastSavedDuration    {0};
 
    // Statistics
    // Note: Once we enter RecorderBase::run(), only that thread can
    // update these values safely. These values are read in that thread
    // without locking and updated with the lock held. Outside that
    // thread these values are only read, and only with the lock held.
    mutable QMutex m_statisticsLock;
    QAtomicInt     m_timeOfFirstDataIsSet; // doesn't need locking
    QDateTime      m_timeOfFirstData;
    QAtomicInt     m_timeOfLatestDataCount; // doesn't need locking
    QAtomicInt     m_timeOfLatestDataPacketInterval; // doesn't need locking
    QDateTime      m_timeOfLatestData;
    MythTimer      m_timeOfLatestDataTimer;
    RecordingGaps  m_recordingGaps;
    static const uint kTimeOfLatestDataIntervalTarget;
};
 
#endif
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */