MythTV  master
tv_rec.h
Go to the documentation of this file.
1 #ifndef TVREC_H
2 #define TVREC_H
3 
4 // Qt headers
5 #include <QWaitCondition>
6 #include <QStringList>
7 #include <QDateTime>
8 #include <QRunnable>
9 #include <QString>
10 #include <QMap>
11 #include <QMutex> // for QMutex
12 #include <QReadWriteLock>
13 #include <QHash> // for QHash
14 
15 // C++ headers
16 #include <vector> // for vector
17 
18 // MythTV headers
19 #include "mythtimer.h"
20 #include "mthread.h"
21 #include "inputinfo.h"
22 #include "mythdeque.h"
23 
24 #include "recordinginfo.h"
25 #include "tv.h"
26 #include "signalmonitorlistener.h"
27 #include "mythtvexp.h" // for MTV_PUBLIC
28 #include "programtypes.h" // for RecStatus, RecStatus::Type, etc
29 #include "videoouttypes.h" // for PictureAttribute
30 
31 #include "mythconfig.h"
32 
33 // locking order
34 // setChannelLock -> stateChangeLock -> triggerEventLoopLock
35 // -> pendingRecLock
36 
37 class RingBuffer;
38 class EITScanner;
39 class RecordingProfile;
40 class LiveTVChain;
41 
42 class RecorderBase;
43 class DTVRecorder;
44 class DVBRecorder;
45 class HDHRRecorder;
46 class ASIRecorder;
47 class CetonRecorder;
48 
49 class SignalMonitor;
50 class DTVSignalMonitor;
51 
52 class ChannelBase;
53 class DTVChannel;
54 class DVBChannel;
55 class FirewireChannel;
56 class V4LChannel;
57 class HDHRChannel;
58 class CetonChannel;
59 
60 class MPEGStreamData;
61 class ProgramMapTable;
62 class RecordingQuality;
63 
65 {
66  public:
68  videodev(""), vbidev(""),
69  audiodev(""),
70  inputtype("V4L"),
72  signal_timeout(1000), channel_timeout(3000),
74 
75  QString videodev;
76  QString vbidev;
77  QString audiodev;
78  QString inputtype;
84 };
85 
87 {
88  public:
93 };
94 
96 {
97  public:
98  FireWireDBOptions() : speed(-1), connection(-1), model("") {;}
99 
100  int speed;
102  QString model;
103 };
104 
106 {
107  public:
108  explicit TuningRequest(uint f) :
109  flags(f), program(nullptr),
110  majorChan(0), minorChan(0), progNum(-1) {;}
112  flags(f), program(p),
113  majorChan(0), minorChan(0), progNum(-1) {;}
114  TuningRequest(uint f, QString ch, QString in = QString()) :
115  flags(f), program(nullptr), channel(ch),
116  input(in), majorChan(0), minorChan(0), progNum(-1) {;}
117 
118  QString toString(void) const;
119 
120  bool IsOnSameMultiplex(void) const { return minorChan || (progNum >= 0); }
121 
122  public:
125  QString channel;
126  QString input;
129  int progNum;
130 };
133 
135 {
136  public:
138  info(nullptr), hasLaterShowing(false), canceled(false),
139  ask(false), doNotAsk(false) { }
141  QDateTime recordingStart;
143  bool canceled;
144  bool ask;
145  bool doNotAsk;
146  vector<uint> possibleConflicts;
147 };
148 typedef QMap<uint,PendingInfo> PendingMap;
149 
150 class MTV_PUBLIC TVRec : public SignalMonitorListener, public QRunnable
151 {
152  Q_DECLARE_TR_FUNCTIONS(TVRec)
153 
154  friend class TuningRequest;
155  friend class TVRecRecordThread;
156 
157  public:
158  explicit TVRec(int _inputid);
159  ~TVRec(void);
160 
161  bool Init(void);
162 
163  void RecordPending(const ProgramInfo *rcinfo, int secsleft, bool hasLater);
164  RecStatus::Type StartRecording(ProgramInfo *rcinfo);
165  RecStatus::Type GetRecordingStatus(void) const;
166 
167  void StopRecording(bool killFile = false);
169  void FinishRecording(void) { SetFlags(kFlagFinishRecording,
170  __FILE__, __LINE__); }
172  void FrontendReady(void) { SetFlags(kFlagFrontendReady,
173  __FILE__, __LINE__); }
174  void CancelNextRecording(bool cancel);
175  ProgramInfo *GetRecording(void);
176 
178  bool IsRunning(void) const { return HasFlags(kFlagRunMainLoop); }
180  void Stop(void) { ClearFlags(kFlagRunMainLoop, __FILE__, __LINE__); }
181 
182  TVState GetState(void) const;
184  bool IsPlaying(void) { return StateIsPlaying(internalState); }
187  bool IsRecording(void) { return StateIsRecording(internalState); }
188 
189  bool SetVideoFiltersForChannel(uint sourceid, const QString &channum);
190 
191  bool IsBusy(InputInfo *busy_input = nullptr, int time_buffer = 5) const;
192  bool IsReallyRecording(void);
193 
194  float GetFramerate(void);
195  long long GetFramesWritten(void);
196  long long GetFilePosition(void);
197  long long GetMaxBitrate(void) const;
198  int64_t GetKeyframePosition(uint64_t desired) const;
199  bool GetKeyframePositions(int64_t start, int64_t end, frm_pos_map_t&) const;
200  bool GetKeyframeDurations(int64_t start, int64_t end, frm_pos_map_t&) const;
201  void SpawnLiveTV(LiveTVChain *newchain, bool pip, QString startchan);
202  QString GetChainID(void);
203  void StopLiveTV(void);
204  void PauseRecorder(void);
205  void ToggleChannelFavorite(QString);
206 
207  void SetLiveRecording(int recording);
208 
209  QString GetInput(void) const;
210  uint GetSourceID(void) const;
211  QString SetInput(QString input);
212 
215  { SetChannel(QString("NextChannel %1").arg((int)dir)); }
216  void SetChannel(QString name, uint requestType = kFlagDetect);
217  bool QueueEITChannelChange(const QString &name);
218 
219  int SetSignalMonitoringRate(int rate, int notifyFrontend = 1);
220  int GetPictureAttribute(PictureAttribute attr);
221  int ChangePictureAttribute(PictureAdjustType type, PictureAttribute attr,
222  bool direction);
223  bool CheckChannel(QString name) const;
224  bool ShouldSwitchToAnotherInput(QString chanid);
225  bool CheckChannelPrefix(const QString&,uint&,bool&,QString&);
226  void GetNextProgram(BrowseDirection direction,
227  QString &title, QString &subtitle,
228  QString &desc, QString &category,
229  QString &starttime, QString &endtime,
230  QString &callsign, QString &iconpath,
231  QString &channelname, uint &chanid,
232  QString &seriesid, QString &programid);
233  bool GetChannelInfo(uint &chanid, uint &sourceid,
234  QString &callsign, QString &channum,
235  QString &channame, QString &xmltvid) const;
236  bool SetChannelInfo(uint chanid, uint sourceid, QString oldchannum,
237  QString callsign, QString channum,
238  QString channame, QString xmltvid);
239 
241  uint GetInputId(void) { return inputid; }
242  uint GetParentId(void) { return parentid; }
243  uint GetMajorId(void) { return parentid ? parentid : inputid; }
245  bool IsErrored(void) const { return HasFlags(kFlagErrored); }
246 
247  void RingBufferChanged(RingBuffer*, RecordingInfo*, RecordingQuality*);
248  void RecorderPaused(void);
249 
250  void SetNextLiveTVDir(QString dir);
251 
252  uint GetFlags(void) const { return stateFlags; }
253 
254  static TVRec *GetTVRec(uint inputid);
255 
256  void AllGood(void) override { WakeEventLoop(); } // SignalMonitorListener
257  void StatusChannelTuned(const SignalMonitorValue&) override { } // SignalMonitorListener
258  void StatusSignalLock(const SignalMonitorValue&) override { } // SignalMonitorListener
259  void StatusSignalStrength(const SignalMonitorValue&) override { } // SignalMonitorListener
260 
261  protected:
262  void run(void) override; // QRunnable
263  bool WaitForEventThreadSleep(bool wake = true, ulong time = ULONG_MAX);
264 
265  private:
266  void SetRingBuffer(RingBuffer *);
267  void SetPseudoLiveTVRecording(RecordingInfo*);
268  void TeardownAll(void);
269  void WakeEventLoop(void);
270 
271  static bool GetDevices(uint inputid,
272  uint &parentid,
273  GeneralDBOptions &general_opts,
274  DVBDBOptions &dvb_opts,
275  FireWireDBOptions &firewire_opts);
276 
277  static QString GetStartChannel(uint inputid);
278 
279  void TeardownRecorder(uint request_flags);
280  DTVRecorder *GetDTVRecorder(void);
281 
282  bool CreateChannel(const QString &startChanNum,
283  bool enter_power_save_mode);
284  void CloseChannel(void);
285  DTVChannel *GetDTVChannel(void);
286  V4LChannel *GetV4LChannel(void);
287 
288  bool SetupSignalMonitor(
289  bool tablemon, bool EITscan, bool notify);
290  bool SetupDTVSignalMonitor(bool EITscan);
291  void TeardownSignalMonitor(void);
292  DTVSignalMonitor *GetDTVSignalMonitor(void);
293 
294  bool HasFlags(uint f) const { return (stateFlags & f) == f; }
295  void SetFlags(uint f, const QString & file, int line);
296  void ClearFlags(uint f, const QString & file, int line);
297  static QString FlagToString(uint);
298 
299  void HandleTuning(void);
300  void TuningShutdowns(const TuningRequest&);
301  void TuningFrequency(const TuningRequest&);
302  MPEGStreamData *TuningSignalCheck(void);
303 
304  void TuningNewRecorder(MPEGStreamData*);
305  void TuningRestartRecorder(void);
306  QString TuningGetChanNum(const TuningRequest&, QString &input) const;
307  bool TuningOnSameMultiplex(TuningRequest &request);
308 
309  void HandleStateChange(void);
310  void ChangeState(TVState nextState);
311  bool StateIsRecording(TVState state);
312  bool StateIsPlaying(TVState state);
313  TVState RemovePlaying(TVState state);
314  TVState RemoveRecording(TVState state);
315 
316  void HandlePendingRecordings(void);
317 
318  bool WaitForNextLiveTVDir(void);
319  bool GetProgramRingBufferForLiveTV(RecordingInfo **pginfo, RingBuffer **rb,
320  const QString &channum);
321  bool CreateLiveTVRingBuffer(const QString & channum);
322  bool SwitchLiveTVRingBuffer(const QString & channum,
323  bool discont, bool set_rec);
324 
325  RecordingInfo *SwitchRecordingRingBuffer(const RecordingInfo &rcinfo);
326 
327  void StartedRecording(RecordingInfo*);
328  void FinishedRecording(RecordingInfo*, RecordingQuality*);
329  QDateTime GetRecordEndTime(const ProgramInfo*) const;
330  void CheckForRecGroupChange(void);
331  void NotifySchedulerOfRecording(RecordingInfo*);
332  typedef enum { kAutoRunProfile, kAutoRunNone, } AutoRunInitType;
333  void InitAutoRunJobs(RecordingInfo*, AutoRunInitType,
334  RecordingProfile *, int line);
335 
336  void SetRecordingStatus(
337  RecStatus::Type new_status, int line, bool have_lock = false);
338 
339  QString LoadProfile(void*, RecordingInfo*,
341 
342  // Various components TVRec coordinates
347 
350 
355  QDateTime preFailDeadline;
357 
358  // Various threads
363 
364  // Configuration variables from database
374 
375  // Configuration variables from setup routines
378  bool ispip;
379 
380  // Configuration variables from database, based on inputid
384 
385  QString recProfileName;
386 
387  // State variables
388  mutable QMutex setChannelLock;
389  mutable QMutex stateChangeLock;
390  mutable QMutex pendingRecLock;
398  QDateTime eitScanStartTime;
399  mutable QMutex triggerEventLoopLock;
400  QWaitCondition triggerEventLoopWait;
402  mutable QMutex triggerEventSleepLock;
403  QWaitCondition triggerEventSleepWait;
405  volatile bool switchingBuffer;
407 
408  // Current recording info
410  QDateTime recordEndTime;
411  QHash<QString,int> autoRunJobs; // RecordingInfo::MakeUniqueKey()->autoRun
413 
414  // Pending recording info
416 
417  // Pseudo LiveTV recording
419  QString nextLiveTVDir;
421  QWaitCondition triggerLiveTVDir;
423 
424  // LiveTV file chain
426 
427  // RingBuffer info
429  QString rbFileExt;
430 
431  public:
432  static QReadWriteLock inputsLock;
433  static QMap<uint,TVRec*> inputs;
434 
435  public:
437 
438  // General State flags
439  static const uint kFlagFrontendReady = 0x00000001;
440  static const uint kFlagRunMainLoop = 0x00000002;
441  static const uint kFlagExitPlayer = 0x00000004;
442  static const uint kFlagFinishRecording = 0x00000008;
443  static const uint kFlagErrored = 0x00000010;
444  static const uint kFlagCancelNextRecording = 0x00000020;
445 
446  // Tuning flags
448  static const uint kFlagLiveTV = 0x00000100;
450  static const uint kFlagRecording = 0x00000200;
452  static const uint kFlagAntennaAdjust = 0x00000400;
453  static const uint kFlagRec = 0x00000F00;
454 
455  // Non-recording Commands
457  static const uint kFlagEITScan = 0x00001000;
459  static const uint kFlagCloseRec = 0x00002000;
461  static const uint kFlagKillRec = 0x00004000;
462 
463  static const uint kFlagNoRec = 0x0000F000;
464  static const uint kFlagKillRingBuffer = 0x00010000;
465 
466  // Waiting stuff
467  static const uint kFlagWaitingForRecPause = 0x00100000;
468  static const uint kFlagWaitingForSignal = 0x00200000;
469  static const uint kFlagNeedToStartRecorder = 0x00800000;
470  static const uint kFlagPendingActions = 0x00F00000;
471 
472  // Running stuff
473  static const uint kFlagSignalMonitorRunning = 0x01000000;
474  static const uint kFlagEITScannerRunning = 0x04000000;
475 
476  static const uint kFlagDummyRecorderRunning = 0x10000000;
477  static const uint kFlagRecorderRunning = 0x20000000;
478  static const uint kFlagAnyRecRunning = 0x30000000;
479  static const uint kFlagAnyRunning = 0x3F000000;
480 
481  // Tuning state
482  static const uint kFlagRingBufferReady = 0x40000000;
483  static const uint kFlagDetect = 0x80000000;
484 };
485 
486 #endif
uint flags
Definition: tv_rec.h:123
uint dvb_tuning_delay
Definition: tv_rec.h:91
bool IsPlaying(void)
Returns "state == kState_RecordingPreRecorded".
Definition: tv_rec.h:184
QString recProfileName
Definition: tv_rec.h:385
int audiosamplerate
Definition: tv_rec.h:79
ProgramInfo * info
Definition: tv_rec.h:140
uint inputid
Definition: tv_rec.h:376
This is a wrapper around QThread that does several additional things.
Definition: mthread.h:46
QString LiveTVStartChannel
Definition: tv_rec.h:422
This is a specialization of RecorderBase used to handle MPEG-2, MPEG-4, MPEG-4 AVC,...
Definition: dtvrecorder.h:28
uint GetInputId(void)
Returns the inputid.
Definition: tv_rec.h:241
ChannelChangeDirection
ChannelChangeDirection is an enumeration of possible channel changing directions.
Definition: tv.h:28
bool earlyCommFlag
Definition: tv_rec.h:366
RecordingInfo * pseudoLiveTVRecording
Definition: tv_rec.h:418
VERBOSE_PREAMBLE Most true
Definition: verbosedefs.h:91
QString model
Definition: tv_rec.h:102
MythDeque< TuningRequest > TuningQueue
Definition: tv_rec.h:131
QMutex triggerEventSleepLock
Definition: tv_rec.h:402
This is a specialization of DTVRecorder used to handle streams from DVB drivers.
Definition: dvbrecorder.h:21
int overRecordSecNrml
Definition: tv_rec.h:371
QMap< uint, PendingInfo > PendingMap
Definition: tv_rec.h:148
QDateTime recordEndTime
Definition: tv_rec.h:410
RecStatus::Type m_recStatus
Definition: tv_rec.h:406
uint minorChan
Definition: tv_rec.h:128
TuningRequest(uint f)
Definition: tv_rec.h:108
void AllGood(void) override
Signal to be sent when you have a lock on all values.
Definition: tv_rec.h:256
volatile bool switchingBuffer
Definition: tv_rec.h:405
uint channel_timeout
Definition: tv_rec.h:82
QString vbidev
Definition: tv_rec.h:76
GeneralDBOptions()
Definition: tv_rec.h:67
static QMap< uint, TVRec * > inputs
Definition: tv_rec.h:433
QString nextLiveTVDir
Definition: tv_rec.h:419
Holds information on a TV Program one might wish to record.
Definition: recordinginfo.h:34
bool dvb_eitscan
Definition: tv_rec.h:92
QString channel
Definition: tv_rec.h:125
uint GetMajorId(void)
Definition: tv_rec.h:243
unsigned int uint
Definition: compat.h:140
Provides interface to the tuning hardware when using DVB drivers.
Definition: dvbchannel.h:29
QHash< QString, int > autoRunJobs
Definition: tv_rec.h:411
uint signal_timeout
Definition: tv_rec.h:81
void ChangeChannel(ChannelChangeDirection dir)
Changes to a channel in the 'dir' channel change direction.
Definition: tv_rec.h:214
void StatusChannelTuned(const SignalMonitorValue &) override
Signal to be sent with change change status.
Definition: tv_rec.h:257
QMutex nextLiveTVDirLock
Definition: tv_rec.h:420
int overrecordseconds
Definition: tv_rec.h:412
void FrontendReady(void)
Tells TVRec that the frontend's TV class is ready for messages.
Definition: tv_rec.h:172
static QReadWriteLock inputsLock
Definition: tv_rec.h:432
bool IsOnSameMultiplex(void) const
Definition: tv_rec.h:120
TVState
TVState is an enumeration of the states used by TV and TVRec.
Definition: tv.h:50
QWaitCondition triggerEventSleepWait
Definition: tv_rec.h:403
QDateTime signalMonitorDeadline
Definition: tv_rec.h:352
bool runJobOnHostOnly
Definition: tv_rec.h:367
QDateTime preFailDeadline
Definition: tv_rec.h:355
bool changeState
Definition: tv_rec.h:393
GeneralDBOptions genOpt
Definition: tv_rec.h:381
void StatusSignalLock(const SignalMonitorValue &) override
Signal to be sent as true when it is safe to begin or continue recording, and false if it may not be ...
Definition: tv_rec.h:258
bool reachedPreFail
Definition: tv_rec.h:356
bool dvb_on_demand
Definition: tv_rec.h:90
uint GetParentId(void)
Definition: tv_rec.h:242
DVBDBOptions()
Definition: tv_rec.h:89
bool wait_for_seqstart
Definition: tv_rec.h:83
RecordingInfo * curRecording
Definition: tv_rec.h:409
bool triggerEventLoopSignal
Definition: tv_rec.h:401
QString overRecordCategory
Definition: tv_rec.h:373
bool transcodeFirst
Definition: tv_rec.h:365
PendingMap pendingRecordings
Definition: tv_rec.h:415
RecordingInfo * program
Definition: tv_rec.h:124
enum BrowseDirections BrowseDirection
Used to request ProgramInfo for channel browsing.
Holds information on recordings and videos.
Definition: programinfo.h:66
static int run(MythMediaDevice *dev=nullptr, bool startRandomShow=false)
bool signalEventCmdSent
Definition: tv_rec.h:349
FireWireDBOptions fwOpt
Definition: tv_rec.h:383
int progNum
Definition: tv_rec.h:129
VERBOSE_PREAMBLE false
Definition: verbosedefs.h:85
bool skip_btaudio
Definition: tv_rec.h:80
uint signalMonitorCheckCnt
Definition: tv_rec.h:353
Class providing a generic interface to digital tuning hardware.
Definition: dtvchannel.h:34
RecorderBase * recorder
Definition: tv_rec.h:343
#define MTV_PUBLIC
Definition: mythtvexp.h:15
This is the coordinating class of the Recorder Subsystem.
Definition: tv_rec.h:150
bool hasLaterShowing
Definition: tv_rec.h:142
TuningRequest myth_deque_init(const TuningRequest *)
Definition: tv_rec.h:132
TuningQueue tuningRequests
Definition: tv_rec.h:396
#define GetState(a, b)
QDateTime startRecordingDeadline
Definition: tv_rec.h:351
QMutex setChannelLock
Definition: tv_rec.h:388
bool pauseNotify
Definition: tv_rec.h:394
QString rbFileExt
Definition: tv_rec.h:429
FirewireChannel Copyright (c) 2005 by Jim Westfall and Dave Abrahams Distributed as part of MythTV un...
void Stop(void)
Tells TVRec to stop event loop.
Definition: tv_rec.h:180
int overRecordSecCat
Definition: tv_rec.h:372
bool canceled
Definition: tv_rec.h:143
bool ask
Definition: tv_rec.h:144
uint stateFlags
Definition: tv_rec.h:395
RingBuffer * ringBuffer
Definition: tv_rec.h:428
Acts as glue between ChannelBase, EITSource, and EITHelper.
Definition: eitscanner.h:30
QDateTime eitScanStartTime
Definition: tv_rec.h:398
static const uint kSignalMonitoringRate
How many milliseconds the signal monitor should wait between checks.
Definition: tv_rec.h:436
PictureAttribute
Definition: videoouttypes.h:89
const char * name
Definition: ParseText.cpp:339
Implements tuning for TV cards using the V4L driver API, both versions 1 and 2.
Definition: v4lchannel.h:32
This is the abstract base class for supporting recorder hardware.
Definition: recorderbase.h:66
void StatusSignalStrength(const SignalMonitorValue &) override
Signal to be sent with an actual signal value.
Definition: tv_rec.h:259
QDateTime signalEventCmdTimeout
Definition: tv_rec.h:348
This is a specialization of DTVRecorder used to handle streams from ASI drivers.
Definition: asirecorder.h:55
This class is intended to detect the presence of needed tables.
PendingInfo()
Definition: tv_rec.h:137
bool IsRunning(void) const
Returns true if event loop has not been told to shut down.
Definition: tv_rec.h:178
QWaitCondition triggerEventLoopWait
Definition: tv_rec.h:400
Signal monitoring base class.
Definition: signalmonitor.h:32
QString audiodev
Definition: tv_rec.h:77
MThread * eventThread
Event processing thread, runs TVRec::run().
Definition: tv_rec.h:360
uint GetFlags(void) const
Definition: tv_rec.h:252
bool triggerEventSleepSignal
Definition: tv_rec.h:404
bool reachedRecordingDeadline
Definition: tv_rec.h:354
Abstract class providing a generic interface to tuning hardware.
Definition: channelbase.h:31
PictureAdjustType
Definition: tv.h:120
bool HasFlags(uint f) const
Definition: tv_rec.h:294
TVState desiredNextState
Definition: tv_rec.h:392
QString inputtype
Definition: tv_rec.h:78
TuningRequest(uint f, QString ch, QString in=QString())
Definition: tv_rec.h:114
QDateTime recordingStart
Definition: tv_rec.h:141
bool IsErrored(void) const
Returns true is "errored" is true, false otherwise.
Definition: tv_rec.h:245
vector< uint > possibleConflicts
Definition: tv_rec.h:146
QString input
Definition: tv_rec.h:126
bool ispip
Definition: tv_rec.h:378
EITScanner * scanner
Definition: tv_rec.h:346
bool IsRecording(void)
Returns "state == kState_RecordingRecordedOnly".
Definition: tv_rec.h:187
ChannelBase * channel
Definition: tv_rec.h:344
Implements a file/stream reader/writer.
DVBDBOptions dvbOpt
Definition: tv_rec.h:382
int eitCrawlIdleStart
Definition: tv_rec.h:368
QMap< long long, long long > frm_pos_map_t
Frame # -> File offset map.
Definition: programtypes.h:46
QWaitCondition triggerLiveTVDir
Definition: tv_rec.h:421
QMutex triggerEventLoopLock
Definition: tv_rec.h:399
QMutex stateChangeLock
Definition: tv_rec.h:389
QMutex pendingRecLock
Definition: tv_rec.h:390
int audioSampleRateDB
Definition: tv_rec.h:370
LiveTVChain * tvchain
Definition: tv_rec.h:425
QString toString(void) const
Definition: tv_rec.cpp:4859
MThread * recorderThread
Recorder thread, runs RecorderBase::run().
Definition: tv_rec.h:362
A PMT table maps a program described in the ProgramAssociationTable to various PID's which describe t...
Definition: mpegtables.h:656
Keeps track of recordings in a current LiveTV instance.
Definition: livetvchain.h:31
uint majorChan
Definition: tv_rec.h:127
SignalMonitor * signalMonitor
Definition: tv_rec.h:345
QString videodev
Definition: tv_rec.h:75
int eitTransportTimeout
Definition: tv_rec.h:369
Encapsulates data about MPEG stream and emits events for each table.
TuningRequest(uint f, RecordingInfo *p)
Definition: tv_rec.h:111
TuningRequest lastTuningRequest
Definition: tv_rec.h:397
bool doNotAsk
Definition: tv_rec.h:145
uint parentid
Definition: tv_rec.h:377
TVState internalState
Definition: tv_rec.h:391