recorderbase.h

Go to the documentation of this file.

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

#include <stdint.h>

#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"

class FireWireDBOptions;
class GeneralDBOptions;
class RecordingProfile;
class DVBDBOptions;
class RecorderBase;
class ChannelBase;
class ProgramInfo;
class RingBuffer;
class TVRec;

class MTV_PUBLIC RecorderBase : public QRunnable
{
    friend class Transcode; // for access to SetIntOption(), SetStrOption()

  public:
    RecorderBase(TVRec *rec);
    virtual ~RecorderBase();

    void SetFrameRate(double rate)
    {
        video_frame_rate = rate;
        ntsc_framerate = (29.96 <= rate && 29.98 >= rate);
    }

    void SetRecording(const ProgramInfo *pginfo);

    void SetRingBuffer(RingBuffer *rbuf);

    virtual void SetOption(const QString &opt, const QString &value);

    virtual void SetOption(const QString &opt, int value);

    virtual void SetVideoFilters(QString &filters) = 0;

    virtual void SetOptionsFromProfile(RecordingProfile *profile,
                                       const QString &videodev,
                                       const QString &audiodev,
                                       const QString &vbidev) = 0;

    virtual void SetNextRecording(const ProgramInfo*, RingBuffer*) = 0;

    virtual void Initialize(void) = 0;

    virtual void run(void) = 0;

    virtual void Reset(void) = 0;

    virtual bool IsErrored(void) = 0;

    virtual long long GetFramesWritten(void) = 0;

    virtual int GetVideoFd(void) = 0;

    int64_t GetKeyframePosition(uint64_t desired) const;
    bool GetKeyframePositions(
        int64_t start, int64_t end, frm_pos_map_t&) const;

    virtual void StopRecording(void);
    virtual bool IsRecording(void);
    virtual bool IsRecordingRequested(void);

    virtual RecordingQuality *GetRecordingQuality(void) 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) { return video_frame_rate; }

    virtual void CheckForRingBufferSwitch(void);

    void SavePositionMap(bool force = 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,
        const RecordingProfile &profile,
        const GeneralDBOptions &genOpt,
        const DVBDBOptions     &dvbOpt);

  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 ClearStatistics(void);
    virtual void FinishRecording(void) = 0;
    virtual void StartNewFile(void) { }

    void SetPositionMapType(MarkTypes type) { positionMapType = type; }

    void AspectChange(uint ratio, long long frame);

    void ResolutionChange(uint width, uint height, long long frame);

    void FrameRateChange(uint framerate, long long frame);

    void SetDuration(uint64_t duration);

    void SetTotalFrames(uint64_t total_frames);

    TVRec         *tvrec;
    RingBuffer    *ringBuffer;
    bool           weMadeBuffer;

    QString        videocodec;
    QString        videodevice;

    bool           ntsc;
    bool           ntsc_framerate;
    double         video_frame_rate;

    uint           m_videoAspect; // AspectRatio

    uint           m_videoHeight;
    uint           m_videoWidth;
    double         m_frameRate;

    ProgramInfo   *curRecording;

    // For handling pausing + stop recording
    mutable QMutex pauseLock; // also used for request_recording and recording
    bool           request_pause;
    bool           paused;
    QWaitCondition pauseWait;
    QWaitCondition unpauseWait;
    bool           request_recording;
    bool           recording;
    QWaitCondition recordingWait;
    

    // For RingBuffer switching
    QMutex         nextRingBufferLock;
    RingBuffer    *nextRingBuffer;
    ProgramInfo   *nextRecording;

    // Seektable  support
    MarkTypes      positionMapType;
    mutable QMutex positionMapLock;
    frm_pos_map_t  positionMap;
    frm_pos_map_t  positionMapDelta;
    MythTimer      positionMapTimer;

    // 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 statisticsLock;
    QAtomicInt     timeOfFirstDataIsSet; // doesn't need locking
    QDateTime      timeOfFirstData;
    QAtomicInt     timeOfLatestDataCount; // doesn't need locking
    QAtomicInt     timeOfLatestDataPacketInterval; // doesn't need locking
    QDateTime      timeOfLatestData;
    MythTimer      timeOfLatestDataTimer;
    RecordingGaps  recordingGaps;
    static const uint kTimeOfLatestDataIntervalTarget;
};

#endif

/* vim: set expandtab tabstop=4 shiftwidth=4: */