MythTV  master
recordinginfo.cpp
Go to the documentation of this file.
1 // POSIX headers
2 #include <sys/types.h>
3 
4 // C headers
5 #include <cstdlib>
6 
7 // Qt headers
8 #include <QMap>
9 
10 // MythTV headers
11 #include "recordinginfo.h"
12 #include "recordingrule.h"
13 #include "scheduledrecording.h"
14 #include "mythmiscutil.h"
15 #include "mythdate.h"
16 #include "mythcorecontext.h"
17 #include "programinfoupdater.h"
18 #include "jobqueue.h"
19 #include "mythdb.h"
20 #include "mythlogging.h"
21 
22 #define LOC QString("RecordingInfo(%1): ").arg(GetBasename())
23 
24 static inline QString null_to_empty(const QString &str)
25 {
26  return str.isEmpty() ? "" : str;
27 }
28 
29 QString RecordingInfo::s_unknownTitle;
30 // works only for integer divisors of 60
31 static const uint kUnknownProgramLength = 30;
32 
33 RecordingInfo::RecordingInfo(
34  const QString &_title,
35  const QString &_sortTitle,
36  const QString &_subtitle,
37  const QString &_sortSubtitle,
38  const QString &_description,
39  uint _season,
40  uint _episode,
41  uint _totalepisodes,
42  const QString &_syndicatedepisode,
43  const QString &_category,
44 
45  uint _chanid,
46  const QString &_chanstr,
47  const QString &_chansign,
48  const QString &_channame,
49 
50  const QString &_recgroup,
51  const QString &_playgroup,
52 
53  const QString &_hostname,
54  const QString &_storagegroup,
55 
56  uint _year,
57  uint _partnumber,
58  uint _parttotal,
59 
60  const QString &_seriesid,
61  const QString &_programid,
62  const QString &_inetref,
63  const CategoryType _catType,
64 
65  int _recpriority,
66 
67  const QDateTime &_startts,
68  const QDateTime &_endts,
69  const QDateTime &_recstartts,
70  const QDateTime &_recendts,
71 
72  float _stars,
73  QDate _originalAirDate,
74 
75  bool _repeat,
76 
77  RecStatus::Type _oldrecstatus,
78  bool _reactivate,
79 
80  uint _recordid,
81  uint _parentid,
82  RecordingType _rectype,
83  RecordingDupInType _dupin,
84  RecordingDupMethodType _dupmethod,
85 
86  uint _sourceid,
87  uint _inputid,
88 
89  uint _findid,
90 
91  bool _commfree,
92  uint _subtitleType,
93  uint _videoproperties,
94  uint _audioproperties,
95  bool _future,
96  int _schedorder,
97  uint _mplexid,
98  uint _sgroupid,
99  const QString &_inputname) :
100  ProgramInfo(
101  _title, _sortTitle, _subtitle, _sortSubtitle,
102  _description, _season, _episode, _totalepisodes,
103  _category, _chanid, _chanstr, _chansign, _channame,
104  QString(), _recgroup, _playgroup,
105  _startts, _endts, _recstartts, _recendts,
106  _seriesid, _programid, _inetref, _inputname),
107  m_oldrecstatus(_oldrecstatus),
108  m_future(_future),
109  m_schedOrder(_schedorder),
110  m_mplexId(_mplexid),
111  m_sgroupId(_sgroupid),
112  m_desiredRecStartTs(_startts),
113  m_desiredRecEndTs(_endts)
114 {
115  m_hostname = _hostname;
116  m_storageGroup = _storagegroup;
117 
118  m_syndicatedEpisode = _syndicatedepisode;
119 
120  m_year = _year;
121  m_partNumber = _partnumber;
122  m_partTotal = _parttotal;
123  m_catType = _catType;
124 
125  m_recPriority = _recpriority;
126 
127  m_stars = clamp(_stars, 0.0F, 1.0F);
128  m_originalAirDate = _originalAirDate;
129  if (m_originalAirDate.isValid() && m_originalAirDate < QDate(1895, 12, 28))
130  m_originalAirDate = QDate();
131 
132  m_programFlags &= ~FL_REPEAT;
133  m_programFlags |= _repeat ? FL_REPEAT : 0;
134  m_programFlags &= ~FL_REACTIVATE;
135  m_programFlags |= _reactivate ? FL_REACTIVATE : 0;
136  m_programFlags &= ~FL_CHANCOMMFREE;
137  m_programFlags |= _commfree ? FL_CHANCOMMFREE : 0;
138 
139  m_recordId = _recordid;
140  m_parentId = _parentid;
141  m_recType = _rectype;
142  m_dupIn = _dupin;
143  m_dupMethod = _dupmethod;
144 
145  m_sourceId = _sourceid;
146  m_inputId = _inputid;
147  m_findId = _findid;
148 
149  m_properties = ((_subtitleType << kSubtitlePropertyOffset) |
150  (_videoproperties << kVideoPropertyOffset) |
151  _audioproperties);
152 
153  if (m_recStartTs >= m_recEndTs)
154  {
155  // start/end-offsets are invalid so ignore
156  m_recStartTs = m_startTs;
157  m_recEndTs = m_endTs;
158  }
159 
160  LoadRecordingFile();
161 }
162 
163 RecordingInfo::RecordingInfo(
164  const QString &_title,
165  const QString &_sortTitle,
166  const QString &_subtitle,
167  const QString &_sortSubtitle,
168  const QString &_description,
169  uint _season,
170  uint _episode,
171  const QString &_category,
172 
173  uint _chanid,
174  const QString &_chanstr,
175  const QString &_chansign,
176  const QString &_channame,
177 
178  const QString &_recgroup,
179  const QString &_playgroup,
180 
181  const QString &_seriesid,
182  const QString &_programid,
183  const QString &_inetref,
184 
185  int _recpriority,
186 
187  const QDateTime &_startts,
188  const QDateTime &_endts,
189  const QDateTime &_recstartts,
190  const QDateTime &_recendts,
191 
192  RecStatus::Type _recstatus,
193 
194  uint _recordid,
195  RecordingType _rectype,
196  RecordingDupInType _dupin,
197  RecordingDupMethodType _dupmethod,
198 
199  uint _findid,
200 
201  bool _commfree) :
202  ProgramInfo(
203  _title, _sortTitle, _subtitle, _sortSubtitle,
204  _description, _season, _episode, 0,
205  _category, _chanid, _chanstr, _chansign, _channame,
206  QString(), _recgroup, _playgroup,
207  _startts, _endts, _recstartts, _recendts,
208  _seriesid, _programid, _inetref, ""),
209  m_desiredRecStartTs(_startts),
210  m_desiredRecEndTs(_endts)
211 {
212  m_recPriority = _recpriority;
213 
214  m_recStatus = _recstatus,
215 
216  m_recordId = _recordid;
217  m_recType = _rectype;
218  m_dupIn = _dupin;
219  m_dupMethod = _dupmethod;
220 
221  m_findId = _findid;
222 
223  m_programFlags &= ~FL_CHANCOMMFREE;
224  m_programFlags |= _commfree ? FL_CHANCOMMFREE : 0;
225 
226  LoadRecordingFile();
227 }
228 
237 RecordingInfo::RecordingInfo(
238  uint _chanid, const QDateTime &desiredts,
239  bool genUnknown, std::chrono::hours maxHours, LoadStatus *status)
240 {
241  ProgramList schedList;
242  ProgramList progList;
243 
244  MSqlBindings bindings;
245  QString querystr = "WHERE program.chanid = :CHANID AND "
246  " program.starttime < :STARTTS1 AND "
247  " program.endtime > :STARTTS2 ";
248  bindings[":CHANID"] = QString::number(_chanid);
249  QDateTime query_startts = desiredts.addSecs(50 - desiredts.time().second());
250  bindings[":STARTTS1"] = query_startts;
251  bindings[":STARTTS2"] = query_startts;
252 
253  ::LoadFromScheduler(schedList);
254  LoadFromProgram(progList, querystr, bindings, schedList);
255 
256  if (!progList.empty())
257  {
258  ProgramInfo *pginfo = progList[0];
259 
260  if (maxHours > 0h)
261  {
262  auto maxSecs = duration_cast<std::chrono::seconds>(maxHours);
263  if (desiredts.secsTo(pginfo->GetScheduledEndTime()) > maxSecs.count())
264  {
265  pginfo->SetScheduledEndTime(desiredts.addSecs(maxSecs.count()));
266  pginfo->SetRecordingEndTime(pginfo->GetScheduledEndTime());
267  }
268  }
269 
270  *this = *pginfo;
271  if (status)
272  *status = kFoundProgram;
273  return;
274  }
275 
276  m_recStartTs = m_startTs = desiredts;
277  m_recEndTs = m_endTs = desiredts;
278  m_lastModified = desiredts;
279 
280  MSqlQuery query(MSqlQuery::InitCon());
281  query.prepare("SELECT chanid, channum, callsign, name, "
282  "commmethod, outputfilters "
283  "FROM channel "
284  "WHERE chanid = :CHANID");
285  query.bindValue(":CHANID", _chanid);
286 
287  if (!query.exec())
288  {
289  MythDB::DBError("Loading Program overlapping a datetime", query);
290  if (status)
291  *status = kNoProgram;
292  return;
293  }
294 
295  if (!query.next())
296  {
297  if (status)
298  *status = kNoProgram;
299  return;
300  }
301 
302  m_chanId = query.value(0).toUInt();
303  m_chanStr = query.value(1).toString();
304  m_chanSign = query.value(2).toString();
305  m_chanName = query.value(3).toString();
306  m_programFlags &= ~FL_CHANCOMMFREE;
307  m_programFlags |= (query.value(4).toInt() == COMM_DETECT_COMMFREE) ?
308  FL_CHANCOMMFREE : 0;
309  m_chanPlaybackFilters = query.value(5).toString();
310 
311  {
312  QMutexLocker locker(&s_staticDataLock);
313  if (s_unknownTitle.isEmpty())
314  s_unknownTitle = gCoreContext->GetSetting("UnknownTitle");
315  m_title = s_unknownTitle;
316  }
317 
318  if (!genUnknown)
319  {
320  if (status)
321  *status = kFakedZeroMinProgram;
322  return;
323  }
324 
325  // Round endtime up to the next half-hour.
326  m_endTs = QDateTime(
327  m_endTs.date(),
328  QTime(m_endTs.time().hour(),
329  m_endTs.time().minute() / kUnknownProgramLength
330  * kUnknownProgramLength), Qt::UTC);
331  m_endTs = m_endTs.addSecs(kUnknownProgramLength * 60);
332 
333  // if under a minute, bump it up to the next half hour
334  if (m_startTs.secsTo(m_endTs) < 60)
335  m_endTs = m_endTs.addSecs(kUnknownProgramLength * 60);
336 
337  m_recEndTs = m_endTs;
338 
339  // Find next program starttime
340  bindings.clear();
341  QDateTime nextstart = m_startTs;
342  querystr = "WHERE program.chanid = :CHANID AND "
343  " program.starttime > :STARTTS "
344  "GROUP BY program.starttime ORDER BY program.starttime LIMIT 1 ";
345  bindings[":CHANID"] = QString::number(_chanid);
346  bindings[":STARTTS"] = desiredts.addSecs(50 - desiredts.time().second());
347 
348  LoadFromProgram(progList, querystr, bindings, schedList);
349 
350  if (!progList.empty())
351  nextstart = (*progList.begin())->GetScheduledStartTime();
352 
353  if (nextstart > m_startTs && nextstart < m_recEndTs)
354  m_recEndTs = m_endTs = nextstart;
355 
356  if (status)
357  *status = kFakedLiveTVProgram;
358 
359  m_desiredRecStartTs = m_startTs;
360  m_desiredRecEndTs = m_endTs;
361 
362  LoadRecordingFile();
363 }
364 
366 void RecordingInfo::clone(const RecordingInfo &other,
367  bool ignore_non_serialized_data)
368 {
369  bool is_same =
370  ((m_chanId != 0U) && m_recStartTs.isValid() && m_startTs.isValid() &&
371  m_chanId == other.GetChanID() &&
372  m_recStartTs == other.GetRecordingStartTime() &&
373  m_startTs == other.GetScheduledStartTime());
374 
375  ProgramInfo::clone(other, ignore_non_serialized_data);
376 
377  if (!is_same)
378  {
379  delete m_record;
380  m_record = nullptr;
381  }
382 
383  if (!ignore_non_serialized_data)
384  {
385  m_oldrecstatus = other.m_oldrecstatus;
386  m_savedrecstatus = other.m_savedrecstatus;
387  m_future = other.m_future;
388  m_schedOrder = other.m_schedOrder;
389  m_mplexId = other.m_mplexId;
390  m_sgroupId = other.m_sgroupId;
391  m_desiredRecStartTs = other.m_desiredRecStartTs;
392  m_desiredRecEndTs = other.m_desiredRecEndTs;
393  }
394 
395  delete m_recordingFile;
396  m_recordingFile = nullptr;
397  LoadRecordingFile();
398 }
399 
401 void RecordingInfo::clone(const ProgramInfo &other,
402  bool ignore_non_serialized_data)
403 {
404  bool is_same =
405  ((m_chanId != 0U) && m_recStartTs.isValid() && m_startTs.isValid() &&
406  m_chanId == other.GetChanID() &&
407  m_recStartTs == other.GetRecordingStartTime() &&
408  m_startTs == other.GetScheduledStartTime());
409 
410  ProgramInfo::clone(other, ignore_non_serialized_data);
411 
412  if (!is_same)
413  {
414  delete m_record;
415  m_record = nullptr;
416  }
417 
418  m_oldrecstatus = RecStatus::Unknown;
419  m_savedrecstatus = RecStatus::Unknown;
420  m_future = false;
421  m_schedOrder = 0;
422  m_mplexId = 0;
423  m_sgroupId = 0;
424  m_desiredRecStartTs = QDateTime();
425  m_desiredRecEndTs = QDateTime();
426 
427  delete m_recordingFile;
428  m_recordingFile = nullptr;
429  LoadRecordingFile();
430 }
431 
432 void RecordingInfo::clear(void)
433 {
434  ProgramInfo::clear();
435 
436  delete m_record;
437  m_record = nullptr;
438 
439  m_oldrecstatus = RecStatus::Unknown;
440  m_savedrecstatus = RecStatus::Unknown;
441  m_future = false;
442  m_schedOrder = 0;
443  m_mplexId = 0;
444  m_sgroupId = 0;
445  m_desiredRecStartTs = QDateTime();
446  m_desiredRecEndTs = QDateTime();
447 
448  delete m_recordingFile;
449  m_recordingFile = nullptr;
450 }
451 
452 
456 RecordingInfo::~RecordingInfo()
457 {
458  delete m_record;
459  m_record = nullptr;
460 
461  delete m_recordingFile;
462  m_recordingFile = nullptr;
463 }
464 
470 RecordingType RecordingInfo::GetProgramRecordingStatus(void)
471 {
472  if (m_record == nullptr)
473  {
474  m_record = new RecordingRule();
475  m_record->LoadByProgram(this);
476  }
477 
478  return m_record->m_type;
479 }
480 
486 QString RecordingInfo::GetProgramRecordingProfile(void) const
487 {
488  if (m_record == nullptr)
489  {
490  m_record = new RecordingRule();
491  m_record->LoadByProgram(this);
492  }
493 
494  return m_record->m_recProfile;
495 }
496 
500 int RecordingInfo::GetAutoRunJobs(void) const
501 {
502  if (m_record == nullptr)
503  {
504  m_record = new RecordingRule();
505  m_record->LoadByProgram(this);
506  }
507 
508  int result = 0;
509 
510  if (m_record->m_autoTranscode)
511  result |= JOB_TRANSCODE;
512  if (m_record->m_autoCommFlag)
513  result |= JOB_COMMFLAG;
514  if (m_record->m_autoMetadataLookup)
515  result |= JOB_METADATA;
516  if (m_record->m_autoUserJob1)
517  result |= JOB_USERJOB1;
518  if (m_record->m_autoUserJob2)
519  result |= JOB_USERJOB2;
520  if (m_record->m_autoUserJob3)
521  result |= JOB_USERJOB3;
522  if (m_record->m_autoUserJob4)
523  result |= JOB_USERJOB4;
524 
525 
526  return result;
527 }
528 
532 void RecordingInfo::ApplyRecordRecID(void)
533 {
534  MSqlQuery query(MSqlQuery::InitCon());
535 
536  if (getRecordID() < 0)
537  {
538  LOG(VB_GENERAL, LOG_ERR,
539  "ProgInfo Error: ApplyRecordRecID(void) needs recordid");
540  return;
541  }
542 
543  query.prepare("UPDATE recorded "
544  "SET recordid = :RECID "
545  "WHERE chanid = :CHANID AND starttime = :START");
546 
547  if (m_recType == kOverrideRecord && m_parentId > 0)
548  query.bindValue(":RECID", m_parentId);
549  else
550  query.bindValue(":RECID", getRecordID());
551  query.bindValue(":CHANID", m_chanId);
552  query.bindValue(":START", m_recStartTs);
553 
554  if (!query.exec())
555  MythDB::DBError(LOC + "RecordID update", query);
556 }
557 
567 void RecordingInfo::ApplyRecordStateChange(RecordingType newstate, bool save)
568 {
569  GetProgramRecordingStatus();
570  if (newstate == kOverrideRecord || newstate == kDontRecord)
571  m_record->MakeOverride();
572  m_record->m_type = newstate;
573 
574  if (save)
575  {
576  if (newstate == kNotRecording)
577  m_record->Delete();
578  else
579  m_record->Save();
580  }
581 }
582 
588 void RecordingInfo::ApplyRecordRecPriorityChange(int newrecpriority)
589 {
590  GetProgramRecordingStatus();
591  m_record->m_recPriority = newrecpriority;
592  m_record->Save();
593 }
594 
600 void RecordingInfo::ApplyRecordRecGroupChange(const QString &newrecgroup)
601 {
602  MSqlQuery query(MSqlQuery::InitCon());
603 
604  int newrecgroupid = GetRecgroupID(newrecgroup);
605 
606  // Catchall - in the event that the group doesn't exist, then to avoid
607  // breakage, we need to create it
608  if (newrecgroupid == 0)
609  {
610  query.prepare("INSERT INTO recgroups SET recgroup = :NAME, "
611  "displayname = :DISPLAYNAME");
612  query.bindValue(":NAME", newrecgroup);
613  query.bindValue(":DISPLAYNAME", newrecgroup);
614 
615  if (query.exec())
616  newrecgroupid = query.lastInsertId().toInt();
617 
618  if (newrecgroupid <= 0)
619  {
620  LOG(VB_GENERAL, LOG_ERR, QString("Could not create recording group (%1). "
621  "Does it already exist?").arg(newrecgroup));
622  return;
623  }
624  }
625 
626  LOG(VB_GENERAL, LOG_NOTICE,
627  QString("ApplyRecordRecGroupChange: %1 to %2 (%3)").arg(m_recGroup)
628  .arg(newrecgroup)
629  .arg(newrecgroupid));
630 
631  query.prepare("UPDATE recorded"
632  " SET recgroup = :RECGROUP, "
633  " recgroupid = :RECGROUPID "
634  " WHERE chanid = :CHANID"
635  " AND starttime = :START ;");
636  query.bindValue(":RECGROUP", null_to_empty(newrecgroup));
637  query.bindValue(":RECGROUPID", newrecgroupid);
638  query.bindValue(":START", m_recStartTs);
639  query.bindValue(":CHANID", m_chanId);
640 
641  if (!query.exec())
642  MythDB::DBError("RecGroup update", query);
643 
644  m_recGroup = newrecgroup; // Deprecate in favour of recgroupid
645  //recgroupid = newrecgroupid;
646 
647  SendUpdateEvent();
648 }
649 
650 void RecordingInfo::ApplyRecordRecGroupChange(int newrecgroupid)
651 {
652  MSqlQuery query(MSqlQuery::InitCon());
653 
654  QString newrecgroup;
655  if (newrecgroupid > 0)
656  {
657  newrecgroup = GetRecgroupString(newrecgroupid);
658 
659  query.prepare("UPDATE recorded"
660  " SET recgroup = :RECGROUP, "
661  " recgroupid = :RECGROUPID "
662  " WHERE chanid = :CHANID"
663  " AND starttime = :START ;");
664  query.bindValue(":RECGROUP", null_to_empty(newrecgroup));
665  query.bindValue(":RECGROUPID", newrecgroupid);
666  query.bindValue(":START", m_recStartTs);
667  query.bindValue(":CHANID", m_chanId);
668 
669  if (!query.exec())
670  MythDB::DBError("RecGroup update", query);
671 
672  m_recGroup = newrecgroup; // Deprecate in favour of recgroupid
673  //recgroupid = newrecgroupid;
674 
675  SendUpdateEvent();
676  }
677 
678  LOG(VB_GENERAL, LOG_NOTICE,
679  QString("ApplyRecordRecGroupChange: %1 to %2 (%3)").arg(m_recGroup)
680  .arg(newrecgroup)
681  .arg(newrecgroupid));
682 }
683 
689 void RecordingInfo::ApplyRecordPlayGroupChange(const QString &newplaygroup)
690 {
691  MSqlQuery query(MSqlQuery::InitCon());
692 
693  query.prepare("UPDATE recorded"
694  " SET playgroup = :PLAYGROUP"
695  " WHERE chanid = :CHANID"
696  " AND starttime = :START ;");
697  query.bindValue(":PLAYGROUP", null_to_empty(newplaygroup));
698  query.bindValue(":START", m_recStartTs);
699  query.bindValue(":CHANID", m_chanId);
700 
701  if (!query.exec())
702  MythDB::DBError("PlayGroup update", query);
703 
704  m_playGroup = newplaygroup;
705 
706  SendUpdateEvent();
707 }
708 
714 void RecordingInfo::ApplyStorageGroupChange(const QString &newstoragegroup)
715 {
716  MSqlQuery query(MSqlQuery::InitCon());
717 
718  query.prepare("UPDATE recorded"
719  " SET storagegroup = :STORAGEGROUP"
720  " WHERE chanid = :CHANID"
721  " AND starttime = :START ;");
722  query.bindValue(":STORAGEGROUP", null_to_empty(newstoragegroup));
723  query.bindValue(":START", m_recStartTs);
724  query.bindValue(":CHANID", m_chanId);
725 
726  if (!query.exec())
727  MythDB::DBError("StorageGroup update", query);
728 
729  m_storageGroup = newstoragegroup;
730 
731  SendUpdateEvent();
732 }
733 
741 void RecordingInfo::ApplyRecordRecTitleChange(const QString &newTitle,
742  const QString &newSubtitle, const QString &newDescription)
743 {
744  MSqlQuery query(MSqlQuery::InitCon());
745  QString sql = "UPDATE recorded SET title = :TITLE, subtitle = :SUBTITLE ";
746  if (!newDescription.isNull())
747  sql += ", description = :DESCRIPTION ";
748  sql += " WHERE chanid = :CHANID AND starttime = :START ;";
749 
750  query.prepare(sql);
751  query.bindValue(":TITLE", newTitle);
752  query.bindValue(":SUBTITLE", null_to_empty(newSubtitle));
753  if (!newDescription.isNull())
754  query.bindValue(":DESCRIPTION", newDescription);
755  query.bindValue(":CHANID", m_chanId);
756  query.bindValue(":START", m_recStartTs);
757 
758  if (!query.exec())
759  MythDB::DBError("RecTitle update", query);
760 
761  m_title = newTitle;
762  m_subtitle = newSubtitle;
763  if (!newDescription.isNull())
764  m_description = newDescription;
765 
766  SendUpdateEvent();
767 }
768 
769 /* \fn RecordingInfo::ApplyTranscoderProfileChangeById(int id)
770  * \brief Sets the transcoder profile for a recording
771  * \param profileid is the 'id' field from recordingprofiles table.
772  */
773 void RecordingInfo::ApplyTranscoderProfileChangeById(int id)
774 {
775  MSqlQuery query(MSqlQuery::InitCon());
776 
777  query.prepare("UPDATE recorded "
778  "SET transcoder = :PROFILEID "
779  "WHERE chanid = :CHANID "
780  "AND starttime = :START");
781  query.bindValue(":PROFILEID", id);
782  query.bindValue(":CHANID", m_chanId);
783  query.bindValue(":START", m_recStartTs);
784 
785  if (!query.exec())
786  MythDB::DBError(LOC + "unable to update transcoder "
787  "in recorded table", query);
788 }
789 
793 void RecordingInfo::ApplyTranscoderProfileChange(const QString &profile) const
794 {
795  if (profile == "Default") // use whatever is already in the transcoder
796  return;
797 
798  MSqlQuery query(MSqlQuery::InitCon());
799 
800  if (profile == "Autodetect")
801  {
802  query.prepare("UPDATE recorded "
803  "SET transcoder = 0 "
804  "WHERE chanid = :CHANID "
805  "AND starttime = :START");
806  query.bindValue(":CHANID", m_chanId);
807  query.bindValue(":START", m_recStartTs);
808 
809  if (!query.exec())
810  MythDB::DBError(LOC + "unable to update transcoder "
811  "in recorded table", query);
812  }
813  else
814  {
815  MSqlQuery pidquery(MSqlQuery::InitCon());
816  pidquery.prepare("SELECT r.id "
817  "FROM recordingprofiles r, profilegroups p "
818  "WHERE r.profilegroup = p.id "
819  "AND p.name = 'Transcoders' "
820  "AND r.name = :PROFILE ");
821  pidquery.bindValue(":PROFILE", profile);
822 
823  if (!pidquery.exec())
824  {
825  MythDB::DBError("ProgramInfo: unable to query transcoder "
826  "profile ID", query);
827  }
828  else if (pidquery.next())
829  {
830  query.prepare("UPDATE recorded "
831  "SET transcoder = :TRANSCODER "
832  "WHERE chanid = :CHANID "
833  "AND starttime = :START");
834  query.bindValue(":TRANSCODER", pidquery.value(0).toInt());
835  query.bindValue(":CHANID", m_chanId);
836  query.bindValue(":START", m_recStartTs);
837 
838  if (!query.exec())
839  MythDB::DBError(LOC + "unable to update transcoder "
840  "in recorded table", query);
841  }
842  else
843  {
844  LOG(VB_GENERAL, LOG_ERR,
845  "ProgramInfo: unable to query transcoder profile ID");
846  }
847  }
848 }
849 
854 void RecordingInfo::ApplyNeverRecord(void)
855 {
856  SetRecordingStatus(RecStatus::NeverRecord);
857  SetScheduledStartTime(MythDate::current());
858  SetScheduledEndTime(GetRecordingStartTime());
859  AddHistory(true, true);
860 }
861 
865 void RecordingInfo::QuickRecord(void)
866 {
867  RecordingType curType = GetProgramRecordingStatus();
868  if (curType == kNotRecording)
869  ApplyRecordStateChange(kSingleRecord);
870 }
871 
875 RecordingRule* RecordingInfo::GetRecordingRule(void)
876 {
877  GetProgramRecordingStatus();
878  return m_record;
879 }
880 
884 int RecordingInfo::getRecordID(void)
885 {
886  GetProgramRecordingStatus();
887  m_recordId = m_record->m_recordID;
888  return m_recordId;
889 }
890 
891 bool RecordingInfo::QueryRecordedIdForKey(int & recordedid,
892  uint chanid, const QDateTime& recstartts)
893 {
894  if (chanid < 1)
895  {
896  LOG(VB_RECORD, LOG_WARNING,
897  QString("QueryRecordedIdFromKey: Invalid chanid %1").arg(chanid));
898  return false;
899  }
900  if (!recstartts.isValid())
901  {
902  LOG(VB_RECORD, LOG_WARNING,
903  QString("QueryRecordedIdFromKey: Invalid start ts %1")
904  .arg(recstartts.toString()));
905  return false;
906  }
907 
908  MSqlQuery query(MSqlQuery::InitCon());
909  query.prepare(
910  "SELECT recordedid FROM recorded "
911  "WHERE chanid = :CHANID AND starttime = :RECSTARTTS");
912  query.bindValue(":CHANID", chanid);
913  query.bindValue(":RECSTARTTS", recstartts);
914  if (query.exec() && query.next())
915  {
916  recordedid = query.value(0).toUInt();
917  return true;
918  }
919 
920  return false;
921 }
922 
931 void RecordingInfo::StartedRecording(const QString& ext)
932 {
933  QString dirname = m_pathname;
934 
935  if (!m_record)
936  {
937  m_record = new RecordingRule();
938  m_record->LoadByProgram(this);
939  }
940 
941  m_hostname = gCoreContext->GetHostName();
942  m_pathname = CreateRecordBasename(ext);
943 
944  int count = 0;
945  while (!InsertProgram(this, m_record) && count < 50)
946  {
947  m_recStartTs = m_recStartTs.addSecs(1);
948  m_pathname = CreateRecordBasename(ext);
949  count++;
950  }
951 
952  if (count >= 50)
953  {
954  LOG(VB_GENERAL, LOG_ERR, "Couldn't insert program");
955  return;
956  }
957 
958  m_pathname = dirname + "/" + m_pathname;
959 
960  LOG(VB_FILE, LOG_INFO, LOC + QString("StartedRecording: Recording to '%1'")
961  .arg(m_pathname));
962 
963 
964  MSqlQuery query(MSqlQuery::InitCon());
965 
966  query.prepare("DELETE FROM recordedseek WHERE chanid = :CHANID"
967  " AND starttime = :START;");
968  query.bindValue(":CHANID", m_chanId);
969  query.bindValue(":START", m_recStartTs);
970 
971  if (!query.exec() || !query.isActive())
972  MythDB::DBError("Clear seek info on record", query);
973 
974  query.prepare("DELETE FROM recordedmarkup WHERE chanid = :CHANID"
975  " AND starttime = :START;");
976  query.bindValue(":CHANID", m_chanId);
977  query.bindValue(":START", m_recStartTs);
978 
979  if (!query.exec() || !query.isActive())
980  MythDB::DBError("Clear markup on record", query);
981 
982  query.prepare("REPLACE INTO recordedcredits"
983  " SELECT * FROM credits"
984  " WHERE chanid = :CHANID AND starttime = :START;");
985  query.bindValue(":CHANID", m_chanId);
986  query.bindValue(":START", m_startTs);
987  if (!query.exec() || !query.isActive())
988  MythDB::DBError("Copy program credits on record", query);
989 
990  query.prepare("REPLACE INTO recordedprogram"
991  " SELECT * from program"
992  " WHERE chanid = :CHANID AND starttime = :START"
993  " AND title = :TITLE;");
994  query.bindValue(":CHANID", m_chanId);
995  query.bindValue(":START", m_startTs);
996  query.bindValue(":TITLE", m_title);
997  if (!query.exec() || !query.isActive())
998  MythDB::DBError("Copy program data on record", query);
999 
1000  query.prepare("REPLACE INTO recordedrating"
1001  " SELECT * from programrating"
1002  " WHERE chanid = :CHANID AND starttime = :START;");
1003  query.bindValue(":CHANID", m_chanId);
1004  query.bindValue(":START", m_startTs);
1005  if (!query.exec() || !query.isActive())
1006  MythDB::DBError("Copy program ratings on record", query);
1007 
1008  // File
1009  if (!GetRecordingFile())
1010  LoadRecordingFile();
1011  RecordingFile *recFile = GetRecordingFile();
1012  recFile->m_fileName = GetBasename();
1013  recFile->m_storageDeviceID = GetHostname();
1014  recFile->m_storageGroup = GetStorageGroup();
1015  recFile->Save();
1016 
1017  SendAddedEvent();
1018 }
1019 
1020 bool RecordingInfo::InsertProgram(RecordingInfo *pg,
1021  const RecordingRule *rule)
1022 {
1023  QString inputname = pg->GetInputName();
1024  int recgroupid = GetRecgroupID(pg->m_recGroup);
1025 
1026  MSqlQuery query(MSqlQuery::InitCon());
1027 
1028  if (!query.exec("LOCK TABLES recorded WRITE"))
1029  {
1030  MythDB::DBError("InsertProgram -- lock", query);
1031  return false;
1032  }
1033 
1034  query.prepare(
1035  "SELECT recordid "
1036  " FROM recorded "
1037  " WHERE chanid = :CHANID AND "
1038  " starttime = :STARTS");
1039  query.bindValue(":CHANID", pg->m_chanId);
1040  query.bindValue(":STARTS", pg->m_recStartTs);
1041 
1042  bool err = true;
1043  if (!query.exec())
1044  {
1045  MythDB::DBError("InsertProgram -- select", query);
1046  }
1047  else if (query.next())
1048  {
1049  LOG(VB_GENERAL, LOG_ERR,
1050  QString("RecordingInfo::InsertProgram(%1): ")
1051  .arg(pg->toString()) + "recording already exists...");
1052  }
1053  else
1054  {
1055  err = false;
1056  }
1057 
1058  if (err)
1059  {
1060  if (!query.exec("UNLOCK TABLES"))
1061  MythDB::DBError("InsertProgram -- unlock tables", query);
1062  return false;
1063  }
1064 
1065  query.prepare(
1066  "INSERT INTO recorded "
1067  " (chanid, starttime, endtime, title, "
1068  " subtitle, description, season, episode, "
1069  " hostname, category, recgroup, autoexpire, "
1070  " recordid, seriesid, programid, inetref, "
1071  " stars, previouslyshown, originalairdate, "
1072  " findid, transcoder, playgroup, recpriority, "
1073  " basename, progstart, progend, profile, "
1074  " duplicate, storagegroup, inputname, recgroupid) "
1075  "VALUES"
1076  " (:CHANID, :STARTS, :ENDS, :TITLE, "
1077  " :SUBTITLE, :DESC, :SEASON, :EPISODE, "
1078  " :HOSTNAME, :CATEGORY, :RECGROUP, :AUTOEXP, "
1079  " :RECORDID, :SERIESID, :PROGRAMID, :INETREF, "
1080  " :STARS, :REPEAT, :ORIGAIRDATE, "
1081  " :FINDID, :TRANSCODER, :PLAYGROUP, :RECPRIORITY, "
1082  " :BASENAME, :PROGSTART, :PROGEND, :PROFILE, "
1083  " 0, :STORGROUP, :INPUTNAME, :RECGROUPID) "
1084  );
1085 
1086  if (pg->m_recType == kOverrideRecord)
1087  query.bindValue(":RECORDID", pg->m_parentId);
1088  else
1089  query.bindValue(":RECORDID", pg->m_recordId);
1090 
1091  if (pg->m_originalAirDate.isValid())
1092  {
1093  query.bindValue(":ORIGAIRDATE", pg->m_originalAirDate);
1094  // If there is no originalairdate use "year"
1095  }
1096  else if (pg->m_year >= 1895)
1097  {
1098  query.bindValue(":ORIGAIRDATE", QDate(pg->m_year,1,1));
1099  }
1100  else
1101  {
1102  query.bindValue(":ORIGAIRDATE", "0000-00-00");
1103  }
1104 
1105  query.bindValue(":CHANID", pg->m_chanId);
1106  query.bindValue(":STARTS", pg->m_recStartTs);
1107  query.bindValue(":ENDS", pg->m_recEndTs);
1108  query.bindValue(":TITLE", pg->m_title);
1109  query.bindValue(":SUBTITLE", null_to_empty(pg->m_subtitle));
1110  query.bindValue(":DESC", null_to_empty(pg->m_description));
1111  query.bindValue(":SEASON", pg->m_season);
1112  query.bindValue(":EPISODE", pg->m_episode);
1113  query.bindValue(":HOSTNAME", pg->m_hostname);
1114  query.bindValue(":CATEGORY", null_to_empty(pg->m_category));
1115  query.bindValue(":RECGROUP", null_to_empty(pg->m_recGroup));
1116  query.bindValue(":AUTOEXP", rule->m_autoExpire);
1117  query.bindValue(":SERIESID", null_to_empty(pg->m_seriesId));
1118  query.bindValue(":PROGRAMID", null_to_empty(pg->m_programId));
1119  query.bindValue(":INETREF", null_to_empty(pg->m_inetRef));
1120  query.bindValue(":FINDID", pg->m_findId);
1121  query.bindValue(":STARS", pg->m_stars);
1122  query.bindValue(":REPEAT", pg->IsRepeat());
1123  query.bindValue(":TRANSCODER", rule->m_transcoder);
1124  query.bindValue(":PLAYGROUP", pg->m_playGroup);
1125  query.bindValue(":RECPRIORITY", rule->m_recPriority);
1126  query.bindValue(":BASENAME", pg->m_pathname);
1127  query.bindValue(":STORGROUP", null_to_empty(pg->m_storageGroup));
1128  query.bindValue(":PROGSTART", pg->m_startTs);
1129  query.bindValue(":PROGEND", pg->m_endTs);
1130  query.bindValue(":PROFILE", null_to_empty(rule->m_recProfile));
1131  query.bindValue(":INPUTNAME", inputname);
1132  query.bindValue(":RECGROUPID", recgroupid);
1133 
1134  bool ok = query.exec() && (query.numRowsAffected() > 0);
1135  if (ok)
1136  {
1137  pg->SetRecordingID(query.lastInsertId().toUInt());
1138  }
1139  bool active = query.isActive();
1140 
1141  if (!query.exec("UNLOCK TABLES"))
1142  MythDB::DBError("InsertProgram -- unlock tables", query);
1143 
1144  if (!ok && !active)
1145  {
1146  MythDB::DBError("InsertProgram -- insert", query);
1147 
1148  }
1149  else if (pg->m_recordId > 0)
1150  {
1151  query.prepare("UPDATE channel SET last_record = NOW() "
1152  "WHERE chanid = :CHANID");
1153  query.bindValue(":CHANID", pg->GetChanID());
1154  if (!query.exec())
1155  MythDB::DBError("InsertProgram -- channel last_record", query);
1156 
1157  query.prepare("UPDATE record SET last_record = NOW() "
1158  "WHERE recordid = :RECORDID");
1159  query.bindValue(":RECORDID", pg->m_recordId);
1160  if (!query.exec())
1161  MythDB::DBError("InsertProgram -- record last_record", query);
1162 
1163  if (pg->m_recType == kOverrideRecord && pg->m_parentId > 0)
1164  {
1165  query.prepare("UPDATE record SET last_record = NOW() "
1166  "WHERE recordid = :PARENTID");
1167  query.bindValue(":PARENTID", pg->m_parentId);
1168  if (!query.exec())
1169  MythDB::DBError("InsertProgram -- record last_record override",
1170  query);
1171  }
1172  }
1173 
1174  return ok;
1175 }
1176 
1185 void RecordingInfo::FinishedRecording(bool allowReRecord)
1186 {
1187  MSqlQuery query(MSqlQuery::InitCon());
1188  query.prepare("UPDATE recorded SET endtime = :ENDTIME, "
1189  " duplicate = :DUPLICATE "
1190  "WHERE chanid = :CHANID AND "
1191  " starttime = :STARTTIME ");
1192  query.bindValue(":ENDTIME", m_recEndTs);
1193  query.bindValue(":CHANID", m_chanId);
1194  query.bindValue(":STARTTIME", m_recStartTs);
1195  query.bindValue(":DUPLICATE", !allowReRecord);
1196 
1197  if (!query.exec())
1198  MythDB::DBError("FinishedRecording update", query);
1199 
1200  GetProgramRecordingStatus();
1201  if (!allowReRecord)
1202  {
1203  m_recStatus = RecStatus::Recorded;
1204 
1205  qint64 starttime = m_recStartTs.toSecsSinceEpoch();
1206  qint64 endtime = m_recEndTs.toSecsSinceEpoch();
1207  SaveTotalDuration(std::chrono::seconds(endtime - starttime));
1208 
1209  QString msg = "Finished recording";
1210  QString msg_subtitle = m_subtitle.isEmpty() ? "" :
1211  QString(" \"%1\"").arg(m_subtitle);
1212  QString details = QString("%1%2: channel %3")
1213  .arg(m_title)
1214  .arg(msg_subtitle)
1215  .arg(m_chanId);
1216 
1217  LOG(VB_GENERAL, LOG_INFO, QString("%1 %2").arg(msg).arg(details));
1218  }
1219 
1220  SendUpdateEvent();
1221 }
1222 
1227 void RecordingInfo::UpdateRecordingEnd(void)
1228 {
1229  MSqlQuery query(MSqlQuery::InitCon());
1230  query.prepare("UPDATE recorded SET endtime = :ENDTIME "
1231  "WHERE chanid = :CHANID AND "
1232  " starttime = :STARTTIME ");
1233  query.bindValue(":ENDTIME", m_recEndTs);
1234 
1235  query.bindValue(":CHANID", m_chanId);
1236  query.bindValue(":STARTTIME", m_recStartTs);
1237 
1238  if (!query.exec())
1239  MythDB::DBError("UpdateRecordingEnd update", query);
1240 
1241  SendUpdateEvent();
1242 }
1243 
1247 void RecordingInfo::ReactivateRecording(void)
1248 {
1249  MSqlQuery result(MSqlQuery::InitCon());
1250 
1251  result.prepare("UPDATE oldrecorded SET reactivate = 1 "
1252  "WHERE station = :STATION AND "
1253  " starttime = :STARTTIME AND "
1254  " title = :TITLE;");
1255  result.bindValue(":STARTTIME", m_startTs);
1256  result.bindValue(":TITLE", m_title);
1257  result.bindValue(":STATION", m_chanSign);
1258 
1259  if (!result.exec())
1260  MythDB::DBError("ReactivateRecording", result);
1261 
1262  ScheduledRecording::ReschedulePlace("Reactivate");
1263 }
1264 
1268 void RecordingInfo::AddHistory(bool resched, bool forcedup, bool future)
1269 {
1270  bool dup = (GetRecordingStatus() == RecStatus::Recorded || forcedup);
1271  RecStatus::Type rs = (GetRecordingStatus() == RecStatus::CurrentRecording &&
1272  !future) ? RecStatus::PreviousRecording : GetRecordingStatus();
1273  LOG(VB_SCHEDULE, LOG_INFO, QString("AddHistory: %1/%2, %3, %4, %5/%6")
1274  .arg(int(rs)).arg(int(m_oldrecstatus)).arg(future).arg(dup)
1275  .arg(GetScheduledStartTime(MythDate::ISODate)).arg(GetTitle()));
1276  if (!future)
1277  m_oldrecstatus = GetRecordingStatus();
1278  if (dup)
1279  SetReactivated(false);
1280  uint erecid = m_parentId ? m_parentId : m_recordId;
1281 
1282  MSqlQuery result(MSqlQuery::InitCon());
1283 
1284  result.prepare("REPLACE INTO oldrecorded (chanid,starttime,"
1285  "endtime,title,subtitle,description,season,episode,"
1286  "category,seriesid,programid,inetref,findid,recordid,"
1287  "station,rectype,recstatus,duplicate,reactivate,generic,"
1288  "future) "
1289  "VALUES(:CHANID,:START,:END,:TITLE,:SUBTITLE,:DESC,:SEASON,"
1290  ":EPISODE,:CATEGORY,:SERIESID,:PROGRAMID,:INETREF,"
1291  ":FINDID,:RECORDID,:STATION,:RECTYPE,:RECSTATUS,:DUPLICATE,"
1292  ":REACTIVATE,:GENERIC,:FUTURE);");
1293  result.bindValue(":CHANID", m_chanId);
1294  result.bindValue(":START", m_startTs);
1295  result.bindValue(":END", m_endTs);
1296  result.bindValue(":TITLE", m_title);
1297  result.bindValue(":SUBTITLE", null_to_empty(m_subtitle));
1298  result.bindValue(":DESC", null_to_empty(m_description));
1299  result.bindValue(":SEASON", m_season);
1300  result.bindValue(":EPISODE", m_episode);
1301  result.bindValue(":CATEGORY", null_to_empty(m_category));
1302  result.bindValue(":SERIESID", null_to_empty(m_seriesId));
1303  result.bindValue(":PROGRAMID", null_to_empty(m_programId));
1304  result.bindValue(":INETREF", null_to_empty(m_inetRef));
1305  result.bindValue(":FINDID", m_findId);
1306  result.bindValue(":RECORDID", erecid);
1307  result.bindValue(":STATION", null_to_empty(m_chanSign));
1308  result.bindValue(":RECTYPE", m_recType);
1309  result.bindValue(":RECSTATUS", rs);
1310  result.bindValue(":DUPLICATE", dup);
1311  result.bindValue(":REACTIVATE", 0);
1312  result.bindValue(":GENERIC", IsGeneric());
1313  result.bindValue(":FUTURE", future);
1314 
1315  if (!result.exec())
1316  MythDB::DBError("addHistory", result);
1317 
1318  if (dup && m_findId)
1319  {
1320  result.prepare("REPLACE INTO oldfind (recordid, findid) "
1321  "VALUES(:RECORDID,:FINDID);");
1322  result.bindValue(":RECORDID", erecid);
1323  result.bindValue(":FINDID", m_findId);
1324 
1325  if (!result.exec())
1326  MythDB::DBError("addFindHistory", result);
1327  }
1328 
1329  // The adding of an entry to oldrecorded may affect near-future
1330  // scheduling decisions, so recalculate if told
1331  if (resched)
1332  ScheduledRecording::RescheduleCheck(*this, "AddHistory");
1333 }
1334 
1338 void RecordingInfo::DeleteHistory(void)
1339 {
1340  uint erecid = m_parentId ? m_parentId : m_recordId;
1341 
1342  MSqlQuery result(MSqlQuery::InitCon());
1343 
1344  result.prepare("DELETE FROM oldrecorded WHERE title = :TITLE AND "
1345  "starttime = :START AND station = :STATION");
1346  result.bindValue(":TITLE", m_title);
1347  result.bindValue(":START", m_recStartTs);
1348  result.bindValue(":STATION", m_chanSign);
1349 
1350  if (!result.exec())
1351  MythDB::DBError("deleteHistory", result);
1352 
1353  if (/*m_duplicate &&*/ m_findId)
1354  {
1355  result.prepare("DELETE FROM oldfind WHERE "
1356  "recordid = :RECORDID AND findid = :FINDID");
1357  result.bindValue(":RECORDID", erecid);
1358  result.bindValue(":FINDID", m_findId);
1359 
1360  if (!result.exec())
1361  MythDB::DBError("deleteFindHistory", result);
1362  }
1363 
1364  // The removal of an entry from oldrecorded may affect near-future
1365  // scheduling decisions, so recalculate
1366  ScheduledRecording::RescheduleCheck(*this, "DeleteHistory");
1367 }
1368 
1377 void RecordingInfo::ForgetHistory(void)
1378 {
1379  uint erecid = m_parentId ? m_parentId : m_recordId;
1380  uint din = m_dupIn;
1381  uint dmeth = m_dupMethod;
1382 
1383  if (din == kDupsUnset)
1384  din = kDupsInAll;
1385  if (dmeth == kDupCheckUnset)
1386  dmeth = kDupCheckSubThenDesc;
1387 
1388  MSqlQuery result(MSqlQuery::InitCon());
1389 
1390  // Handle this specific entry in recorded.
1391  result.prepare("UPDATE recorded SET duplicate = 0 "
1392  "WHERE chanid = :CHANID "
1393  "AND starttime = :STARTTIME "
1394  "AND title = :TITLE;");
1395  result.bindValue(":STARTTIME", m_recStartTs);
1396  result.bindValue(":TITLE", m_title);
1397  result.bindValue(":CHANID", m_chanId);
1398 
1399  if (!result.exec())
1400  MythDB::DBError("forgetRecorded1", result);
1401 
1402  // Handle other matching entries in recorded.
1403  if (din & kDupsInRecorded)
1404  {
1405  result.prepare(
1406  "UPDATE recorded SET duplicate = 0 "
1407  "WHERE duplicate = 1 AND "
1408  " title = :TITLE AND "
1409  " ( "
1410  " (:PROGRAMID1 <> '' AND "
1411  " :PROGRAMID2 = recorded.programid) "
1412  " OR "
1413  " ( "
1414  " (:PROGRAMID3 = '' OR recorded.programid = '' OR "
1415  " LEFT(:PROGRAMID4, LOCATE('/', :PROGRAMID5)) <> "
1416  " LEFT(recorded.programid, "
1417  " LOCATE('/', recorded.programid))) "
1418  " AND "
1419  " (((:DUPMETHOD1 & 0x02) = 0) OR (:SUBTITLE1 <> '' "
1420  " AND :SUBTITLE2 = recorded.subtitle)) "
1421  " AND "
1422  " (((:DUPMETHOD2 & 0x04) = 0) OR (:DESCRIPTION1 <> '' "
1423  " AND :DESCRIPTION2 = recorded.description)) "
1424  " AND "
1425  " (((:DUPMETHOD3 & 0x08) = 0) OR "
1426  " (:SUBTITLE3 <> '' AND "
1427  " (:SUBTITLE4 = recorded.subtitle OR "
1428  " (recorded.subtitle = '' AND "
1429  " :SUBTITLE5 = recorded.description))) OR "
1430  " (:SUBTITLE6 = '' AND :DESCRIPTION3 <> '' AND "
1431  " (:DESCRIPTION4 = recorded.subtitle OR "
1432  " (recorded.subtitle = '' AND "
1433  " :DESCRIPTION5 = recorded.description)))) "
1434  " ) "
1435  " )" );
1436  result.bindValue(":TITLE", m_title);
1437  result.bindValue(":SUBTITLE1", null_to_empty(m_subtitle));
1438  result.bindValue(":SUBTITLE2", null_to_empty(m_subtitle));
1439  result.bindValue(":SUBTITLE3", null_to_empty(m_subtitle));
1440  result.bindValue(":SUBTITLE4", null_to_empty(m_subtitle));
1441  result.bindValue(":SUBTITLE5", null_to_empty(m_subtitle));
1442  result.bindValue(":SUBTITLE6", null_to_empty(m_subtitle));
1443  result.bindValue(":DESCRIPTION1", null_to_empty(m_description));
1444  result.bindValue(":DESCRIPTION2", null_to_empty(m_description));
1445  result.bindValue(":DESCRIPTION3", null_to_empty(m_description));
1446  result.bindValue(":DESCRIPTION4", null_to_empty(m_description));
1447  result.bindValue(":DESCRIPTION5", null_to_empty(m_description));
1448  result.bindValue(":PROGRAMID1", null_to_empty(m_programId));
1449  result.bindValue(":PROGRAMID2", null_to_empty(m_programId));
1450  result.bindValue(":PROGRAMID3", null_to_empty(m_programId));
1451  result.bindValue(":PROGRAMID4", null_to_empty(m_programId));
1452  result.bindValue(":PROGRAMID5", null_to_empty(m_programId));
1453  result.bindValue(":DUPMETHOD1", dmeth);
1454  result.bindValue(":DUPMETHOD2", dmeth);
1455  result.bindValue(":DUPMETHOD3", dmeth);
1456 
1457  if (!result.exec())
1458  MythDB::DBError("forgetRecorded2", result);
1459  }
1460 
1461  // Handle this specific entry in oldrecorded.
1462  result.prepare("UPDATE oldrecorded SET duplicate = 0 "
1463  "WHERE station = :STATION "
1464  "AND starttime = :STARTTIME "
1465  "AND title = :TITLE;");
1466  result.bindValue(":STARTTIME", m_startTs);
1467  result.bindValue(":TITLE", m_title);
1468  result.bindValue(":STATION", m_chanSign);
1469 
1470  if (!result.exec())
1471  MythDB::DBError("forgetOldRecorded1", result);
1472 
1473  // Handle other matching entries in oldrecorded.
1474  if (din & kDupsInOldRecorded)
1475  {
1476  result.prepare(
1477  "UPDATE oldrecorded SET duplicate = 0 "
1478  "WHERE duplicate = 1 AND "
1479  " title = :TITLE AND "
1480  " ( "
1481  " (:PROGRAMID1 <> '' AND "
1482  " :PROGRAMID2 = oldrecorded.programid) "
1483  " OR "
1484  " ( "
1485  " (:PROGRAMID3 = '' OR oldrecorded.programid = '' OR "
1486  " LEFT(:PROGRAMID4, LOCATE('/', :PROGRAMID5)) <> "
1487  " LEFT(oldrecorded.programid, "
1488  " LOCATE('/', oldrecorded.programid))) "
1489  " AND "
1490  " (((:DUPMETHOD1 & 0x02) = 0) OR (:SUBTITLE1 <> '' "
1491  " AND :SUBTITLE2 = oldrecorded.subtitle)) "
1492  " AND "
1493  " (((:DUPMETHOD2 & 0x04) = 0) OR (:DESCRIPTION1 <> '' "
1494  " AND :DESCRIPTION2 = oldrecorded.description)) "
1495  " AND "
1496  " (((:DUPMETHOD3 & 0x08) = 0) OR "
1497  " (:SUBTITLE3 <> '' AND "
1498  " (:SUBTITLE4 = oldrecorded.subtitle OR "
1499  " (oldrecorded.subtitle = '' AND "
1500  " :SUBTITLE5 = oldrecorded.description))) OR "
1501  " (:SUBTITLE6 = '' AND :DESCRIPTION3 <> '' AND "
1502  " (:DESCRIPTION4 = oldrecorded.subtitle OR "
1503  " (oldrecorded.subtitle = '' AND "
1504  " :DESCRIPTION5 = oldrecorded.description)))) "
1505  " ) "
1506  " )" );
1507  result.bindValue(":TITLE", m_title);
1508  result.bindValue(":SUBTITLE1", null_to_empty(m_subtitle));
1509  result.bindValue(":SUBTITLE2", null_to_empty(m_subtitle));
1510  result.bindValue(":SUBTITLE3", null_to_empty(m_subtitle));
1511  result.bindValue(":SUBTITLE4", null_to_empty(m_subtitle));
1512  result.bindValue(":SUBTITLE5", null_to_empty(m_subtitle));
1513  result.bindValue(":SUBTITLE6", null_to_empty(m_subtitle));
1514  result.bindValue(":DESCRIPTION1", null_to_empty(m_description));
1515  result.bindValue(":DESCRIPTION2", null_to_empty(m_description));
1516  result.bindValue(":DESCRIPTION3", null_to_empty(m_description));
1517  result.bindValue(":DESCRIPTION4", null_to_empty(m_description));
1518  result.bindValue(":DESCRIPTION5", null_to_empty(m_description));
1519  result.bindValue(":PROGRAMID1", null_to_empty(m_programId));
1520  result.bindValue(":PROGRAMID2", null_to_empty(m_programId));
1521  result.bindValue(":PROGRAMID3", null_to_empty(m_programId));
1522  result.bindValue(":PROGRAMID4", null_to_empty(m_programId));
1523  result.bindValue(":PROGRAMID5", null_to_empty(m_programId));
1524  result.bindValue(":DUPMETHOD1", dmeth);
1525  result.bindValue(":DUPMETHOD2", dmeth);
1526  result.bindValue(":DUPMETHOD3", dmeth);
1527 
1528  if (!result.exec())
1529  MythDB::DBError("forgetOldRecorded2", result);
1530  }
1531 
1532  // Remove any never records which aren't need anymore.
1533  result.prepare("DELETE FROM oldrecorded "
1534  "WHERE recstatus = :NEVER AND duplicate = 0");
1535  result.bindValue(":NEVER", RecStatus::NeverRecord);
1536 
1537  if (!result.exec())
1538  MythDB::DBError("forgetNeverHistory", result);
1539 
1540  // Handle matching entries in oldfind.
1541  if (m_findId)
1542  {
1543  result.prepare("DELETE FROM oldfind WHERE "
1544  "recordid = :RECORDID AND findid = :FINDID");
1545  result.bindValue(":RECORDID", erecid);
1546  result.bindValue(":FINDID", m_findId);
1547 
1548  if (!result.exec())
1549  MythDB::DBError("forgetFindHistory", result);
1550  }
1551 
1552  // The removal of an entry from oldrecorded may affect near-future
1553  // scheduling decisions, so recalculate
1554  ScheduledRecording::RescheduleCheck(*this, "ForgetHistory");
1555 }
1556 
1560 void RecordingInfo::SetDupHistory(void)
1561 {
1562  MSqlQuery result(MSqlQuery::InitCon());
1563 
1564  result.prepare("UPDATE oldrecorded SET duplicate = 1 "
1565  "WHERE future = 0 AND duplicate = 0 "
1566  "AND title = :TITLE AND "
1567  "((programid = '' AND subtitle = :SUBTITLE"
1568  " AND description = :DESC) OR "
1569  " (programid <> '' AND programid = :PROGRAMID) OR "
1570  " (findid <> 0 AND findid = :FINDID))");
1571  result.bindValue(":TITLE", m_title);
1572  result.bindValue(":SUBTITLE", null_to_empty(m_subtitle));
1573  result.bindValue(":DESC", null_to_empty(m_description));
1574  result.bindValue(":PROGRAMID", null_to_empty(m_programId));
1575  result.bindValue(":FINDID", m_findId);
1576 
1577  if (!result.exec())
1578  MythDB::DBError("setDupHistory", result);
1579 
1580  ScheduledRecording::RescheduleCheck(*this, "SetHistory");
1581 }
1582 
1587 void RecordingInfo::SubstituteMatches(QString &str)
1588 {
1589  str.replace("%RECID%", QString::number(getRecordID()));
1590  str.replace("%PARENTID%", QString::number(m_parentId));
1591  str.replace("%FINDID%", QString::number(m_findId));
1592  str.replace("%RECSTATUS%", QString::number(m_recStatus));
1593  str.replace("%RECTYPE%", QString::number(m_recType));
1594  str.replace("%REACTIVATE%", IsReactivated() ? "1" : "0");
1595  str.replace("%INPUTNAME%", GetInputName());
1596  str.replace("%CHANNUM%", GetChanNum());
1597 
1598  ProgramInfo::SubstituteMatches(str);
1599 }
1600 
1604 uint RecordingInfo::GetRecgroupID(const QString& recGroup)
1605 {
1606  MSqlQuery query(MSqlQuery::InitCon());
1607 
1608  query.prepare("SELECT recgroupid FROM recgroups WHERE recgroup = :RECGROUP");
1609  query.bindValue(":RECGROUP", null_to_empty(recGroup));
1610 
1611  if (!query.exec())
1612  MythDB::DBError("RecGroup update", query);
1613 
1614  if (!query.next())
1615  return 0;
1616 
1617  return query.value(0).toUInt();
1618 }
1619 
1623 QString RecordingInfo::GetRecgroupString(uint recGroupID)
1624 {
1625  MSqlQuery query(MSqlQuery::InitCon());
1626 
1627  query.prepare("SELECT recgroup FROM recgroups WHERE recgroupid = :RECGROUPID");
1628  query.bindValue(":RECGROUPID", recGroupID);
1629  if (!query.exec() || !query.next())
1630  {
1631  MythDB::DBError("GetRecgroupString()", query);
1632  return QString();
1633  }
1634  return query.value(0).toString();
1635 }
1636 
1637 void RecordingInfo::LoadRecordingFile()
1638 {
1639  if (!m_recordingFile)
1640  {
1641  m_recordingFile = new RecordingFile();
1642  if (m_recordedId > 0)
1643  {
1644  m_recordingFile->m_recordingId = m_recordedId;
1645  m_recordingFile->Load();
1646  }
1647  }
1648 }
1649 
1650 void RecordingInfo::SaveFilesize(uint64_t fsize)
1651 {
1652  if (!GetRecordingFile())
1653  LoadRecordingFile();
1654  GetRecordingFile()->m_fileSize = fsize;
1655  GetRecordingFile()->Save(); // Ideally this would be called just the once when all metadata is gathered
1656 
1657  s_updater->insert(m_recordedId, kPIUpdateFileSize, fsize);
1658 
1659  ProgramInfo::SaveFilesize(fsize); // Temporary
1660 }
1661 
1662 void RecordingInfo::SetFilesize(uint64_t fsize)
1663 {
1664  if (!GetRecordingFile())
1665  LoadRecordingFile();
1666  GetRecordingFile()->m_fileSize = fsize;
1667  s_updater->insert(m_recordedId, kPIUpdateFileSize, fsize);
1668 
1669  // Make sure the old storage location is updated for now
1670  ProgramInfo::SetFilesize(fsize);
1671 }
1672 
1673 uint64_t RecordingInfo::GetFilesize(void) const
1674 {
1675  if (GetRecordingFile() && GetRecordingFile()->m_fileSize > 0)
1676  return GetRecordingFile()->m_fileSize;
1677 
1678  // Temporary fallback to reading from old storage location
1679  return ProgramInfo::GetFilesize();
1680 }
1681 
1682 
1683 /* vim: set expandtab tabstop=4 shiftwidth=4: */
RecordingInfo::ApplyRecordPlayGroupChange
void ApplyRecordPlayGroupChange(const QString &newplaygroup)
Sets the recording group, both in this RecordingInfo and in the database.
Definition: recordinginfo.cpp:689
RecordingInfo::GetRecgroupID
static uint GetRecgroupID(const QString &recGroup)
Temporary helper during transition from string to ID.
Definition: recordinginfo.cpp:1604
JOB_USERJOB3
@ JOB_USERJOB3
Definition: jobqueue.h:81
MSqlBindings
QMap< QString, QVariant > MSqlBindings
typedef for a map of string -> string bindings for generic queries.
Definition: mythdbcon.h:98
ProgramInfo::m_startTs
QDateTime m_startTs
Definition: programinfo.h:778
JOB_USERJOB4
@ JOB_USERJOB4
Definition: jobqueue.h:82
MSqlQuery::isActive
bool isActive(void) const
Definition: mythdbcon.h:204
RecordingRule::LoadByProgram
bool LoadByProgram(const ProgramInfo *proginfo)
Definition: recordingrule.cpp:168
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:783
RecStatus::Type
Type
Definition: recStatus.h:16
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:125
RecordingInfo::InsertProgram
static bool InsertProgram(RecordingInfo *pg, const RecordingRule *rule)
Definition: recordinginfo.cpp:1020
RecordingInfo::m_future
bool m_future
Definition: recordinginfo.h:278
ProgramInfo::SaveFilesize
virtual void SaveFilesize(uint64_t fsize)
Sets recording file size in database, and sets "filesize" field.
Definition: programinfo.cpp:6126
RecordingRule::m_autoTranscode
bool m_autoTranscode
Definition: recordingrule.h:133
ProgramInfo::m_fileSize
uint64_t m_fileSize
Definition: programinfo.h:776
RecordingInfo::QueryRecordedIdForKey
static bool QueryRecordedIdForKey(int &recordedid, uint chanid, const QDateTime &recstartts)
Definition: recordinginfo.cpp:891
RecordingInfo::FinishedRecording
void FinishedRecording(bool allowReRecord)
If not a premature stop, adds program to history of recorded programs.
Definition: recordinginfo.cpp:1185
ProgramInfo::GetFilesize
virtual uint64_t GetFilesize(void) const
Definition: programinfo.cpp:6157
RecordingInfo::ApplyNeverRecord
void ApplyNeverRecord(void)
Set this program to never be recorded by inserting 'history' for it into the database with a status o...
Definition: recordinginfo.cpp:854
ProgramInfo::m_recEndTs
QDateTime m_recEndTs
Definition: programinfo.h:781
RecordingInfo::m_oldrecstatus
RecStatus::Type m_oldrecstatus
Definition: recordinginfo.h:276
ProgramInfo::m_catType
CategoryType m_catType
Definition: programinfo.h:774
ProgramInfo::m_inputId
uint32_t m_inputId
Definition: programinfo.h:794
ProgramInfo::m_title
QString m_title
Definition: programinfo.h:743
RecordingRule::m_autoCommFlag
bool m_autoCommFlag
Definition: recordingrule.h:132
RecordingInfo::kFoundProgram
@ kFoundProgram
Definition: recordinginfo.h:181
ProgramInfo::SetRecordingStatus
void SetRecordingStatus(RecStatus::Type status)
Definition: programinfo.h:571
ProgramInfo::m_dupMethod
uint8_t m_dupMethod
Definition: programinfo.h:807
ProgramInfo::GetHostname
QString GetHostname(void) const
Definition: programinfo.h:419
ProgramInfo::m_storageGroup
QString m_storageGroup
Definition: programinfo.h:769
ProgramInfo::GetInputName
QString GetInputName(void) const
Definition: programinfo.h:462
ProgramInfo::m_chanId
uint32_t m_chanId
Definition: programinfo.h:757
mythdb.h
ProgramInfo::m_dupIn
uint8_t m_dupIn
Definition: programinfo.h:806
RecordingRule::Save
bool Save(bool sendSig=true)
Definition: recordingrule.cpp:383
RecordingInfo::m_desiredRecEndTs
QDateTime m_desiredRecEndTs
Definition: recordinginfo.h:283
RecordingInfo::ApplyRecordStateChange
void ApplyRecordStateChange(RecordingType newstate, bool save=true)
Sets RecordingType of "record", creating "record" if it does not exist.
Definition: recordinginfo.cpp:567
ProgramInfo::m_recordId
uint32_t m_recordId
Definition: programinfo.h:790
RecStatus::NeverRecord
@ NeverRecord
Definition: recStatus.h:43
ProgramInfo::m_recStartTs
QDateTime m_recStartTs
Definition: programinfo.h:780
RecordingInfo::ApplyRecordRecID
void ApplyRecordRecID(void)
Sets recordid to match RecordingRule recordid.
Definition: recordinginfo.cpp:532
kDupCheckSubThenDesc
@ kDupCheckSubThenDesc
Definition: recordingtypes.h:64
ProgramInfo::m_description
QString m_description
Definition: programinfo.h:747
ProgramInfo::s_staticDataLock
static QMutex s_staticDataLock
Definition: programinfo.h:828
RecordingInfo
Holds information on a TV Program one might wish to record.
Definition: recordinginfo.h:34
RecordingInfo::GetFilesize
uint64_t GetFilesize(void) const override
Definition: recordinginfo.cpp:1673
RecordingInfo::ForgetHistory
void ForgetHistory(void)
Forget the recording of a program so it will be recorded again.
Definition: recordinginfo.cpp:1377
ProgramInfo::clone
virtual void clone(const ProgramInfo &other, bool ignore_non_serialized_data=false)
Copies important fields from other ProgramInfo.
Definition: programinfo.cpp:835
ProgramInfo::GetChanNum
QString GetChanNum(void) const
This is the channel "number", in the form 1, 1_2, 1-2, 1#1, etc.
Definition: programinfo.h:374
FL_REACTIVATE
@ FL_REACTIVATE
Definition: programtypes.h:147
RecordingInfo::SetFilesize
void SetFilesize(uint64_t fsize) override
Definition: recordinginfo.cpp:1662
MSqlQuery::lastInsertId
QVariant lastInsertId()
Return the id of the last inserted row.
Definition: mythdbcon.cpp:888
JOB_COMMFLAG
@ JOB_COMMFLAG
Definition: jobqueue.h:74
AutoDeleteDeque::empty
bool empty(void) const
Definition: autodeletedeque.h:66
null_to_empty
static QString null_to_empty(const QString &str)
Definition: recordinginfo.cpp:24
RecordingInfo::DeleteHistory
void DeleteHistory(void)
Deletes recording history, creating "record" it if necessary.
Definition: recordinginfo.cpp:1338
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:198
arg
arg(title).arg(filename).arg(doDelete))
RecordingInfo::GetProgramRecordingStatus
RecordingType GetProgramRecordingStatus(void)
Returns the recording type for this RecordingInfo, creating "record" field if necessary.
Definition: recordinginfo.cpp:470
RecStatus::Unknown
@ Unknown
Definition: recStatus.h:32
RecordingRule
Internal representation of a recording rule, mirrors the record table.
Definition: recordingrule.h:32
RecordingDupMethodType
RecordingDupMethodType
Definition: recordingtypes.h:57
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:603
ProgramInfo::m_recPriority
int32_t m_recPriority
Definition: programinfo.h:755
ProgramInfo::m_season
uint m_season
Definition: programinfo.h:748
RecordingFile
Holds information on a recording file and it's video and audio streams.
Definition: recordingfile.h:29
RecStatus::Recorded
@ Recorded
Definition: recStatus.h:29
ProgramInfo::SetScheduledStartTime
void SetScheduledStartTime(const QDateTime &dt)
Definition: programinfo.h:514
ProgramInfo::IsReactivated
bool IsReactivated(void) const
Definition: programinfo.h:486
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
ProgramInfo::GetScheduledEndTime
QDateTime GetScheduledEndTime(void) const
The scheduled end time of the program.
Definition: programinfo.h:395
ProgramInfo::m_pathname
QString m_pathname
Definition: programinfo.h:766
RecordingInfo::UpdateRecordingEnd
void UpdateRecordingEnd(void)
Update information in the recorded table when the end-time of a recording is changed.
Definition: recordinginfo.cpp:1227
ProgramInfo::m_endTs
QDateTime m_endTs
Definition: programinfo.h:779
RecordingInfo::s_unknownTitle
static QString s_unknownTitle
Definition: recordinginfo.h:293
RecordingInfo::getRecordID
int getRecordID(void)
Returns a record id, creating "record" it if necessary.
Definition: recordinginfo.cpp:884
MythDate::current
QDateTime current(bool stripped)
Returns current Date and Time in UTC.
Definition: mythdate.cpp:10
kDupsInAll
@ kDupsInAll
Definition: recordingtypes.h:47
ProgramInfo::GetRecordingStartTime
QDateTime GetRecordingStartTime(void) const
Approximate time the recording started.
Definition: programinfo.h:402
ProgramInfo::SendAddedEvent
void SendAddedEvent(void) const
Sends event out that the ProgramInfo should be added to lists.
Definition: programinfo.cpp:2616
RecordingInfo::m_mplexId
uint m_mplexId
Definition: recordinginfo.h:280
JOB_USERJOB2
@ JOB_USERJOB2
Definition: jobqueue.h:80
RecordingInfo::ApplyTranscoderProfileChange
void ApplyTranscoderProfileChange(const QString &profile) const
Sets the transcoder profile for a recording.
Definition: recordinginfo.cpp:793
ProgramInfo::m_sourceId
uint32_t m_sourceId
Definition: programinfo.h:793
AutoDeleteDeque::begin
iterator begin(void)
Definition: autodeletedeque.h:50
kDupsInRecorded
@ kDupsInRecorded
Definition: recordingtypes.h:45
ProgramInfo::IsRepeat
bool IsRepeat(void) const
Definition: programinfo.h:484
RecordingInfo::ApplyStorageGroupChange
void ApplyStorageGroupChange(const QString &newstoragegroup)
Sets the storage group, both in this RecordingInfo and in the database.
Definition: recordinginfo.cpp:714
RecordingInfo::GetProgramRecordingProfile
QString GetProgramRecordingProfile(void) const
Returns recording profile name that will be, or was used, for this program, creating "record" field i...
Definition: recordinginfo.cpp:486
RecordingDupInType
RecordingDupInType
Definition: recordingtypes.h:42
ProgramInfo::m_hostname
QString m_hostname
Definition: programinfo.h:768
ProgramInfo::m_chanName
QString m_chanName
Definition: programinfo.h:760
mythdate.h
ProgramInfo::SetRecordingEndTime
void SetRecordingEndTime(const QDateTime &dt)
Definition: programinfo.h:517
RecordingInfo::GetRecordingFile
RecordingFile * GetRecordingFile() const
Definition: recordinginfo.h:271
COMM_DETECT_COMMFREE
@ COMM_DETECT_COMMFREE
Definition: programtypes.h:93
ProgramInfo::GetScheduledStartTime
QDateTime GetScheduledStartTime(void) const
The scheduled start time of program.
Definition: programinfo.h:388
mythlogging.h
ProgramInfo::GetRecordingStatus
RecStatus::Type GetRecordingStatus(void) const
Definition: programinfo.h:445
RecordingInfo::m_savedrecstatus
RecStatus::Type m_savedrecstatus
Definition: recordinginfo.h:277
hardwareprofile.scan.profile
profile
Definition: scan.py:99
RecordingRule::m_autoUserJob4
bool m_autoUserJob4
Definition: recordingrule.h:137
ProgramInfo::m_recType
uint8_t m_recType
Definition: programinfo.h:805
ProgramInfo::m_category
QString m_category
Definition: programinfo.h:752
ProgramInfo::SetScheduledEndTime
void SetScheduledEndTime(const QDateTime &dt)
Definition: programinfo.h:515
RecStatus::PreviousRecording
@ PreviousRecording
Definition: recStatus.h:34
programinfoupdater.h
JOB_USERJOB1
@ JOB_USERJOB1
Definition: jobqueue.h:79
ProgramInfo::m_playGroup
QString m_playGroup
Definition: programinfo.h:764
RecordingInfo::m_desiredRecStartTs
QDateTime m_desiredRecStartTs
Definition: recordinginfo.h:282
RecordingInfo::SaveFilesize
void SaveFilesize(uint64_t fsize) override
Sets recording file size in database, and sets "filesize" field.
Definition: recordinginfo.cpp:1650
RecordingInfo::GetRecgroupString
static QString GetRecgroupString(uint recGroupID)
Temporary helper during transition from string to ID.
Definition: recordinginfo.cpp:1623
ProgramInfo::clear
virtual void clear(void)
Definition: programinfo.cpp:929
ProgramInfo::GetTitle
QString GetTitle(void) const
Definition: programinfo.h:359
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:535
ProgramInfo::m_seriesId
QString m_seriesId
Definition: programinfo.h:771
RecordingRule::m_autoUserJob2
bool m_autoUserJob2
Definition: recordingrule.h:135
RecordingFile::Save
bool Save()
Definition: recordingfile.cpp:55
RecordingInfo::RecordingInfo
RecordingInfo(void)
Definition: recordinginfo.h:37
MythDB::DBError
static void DBError(const QString &where, const MSqlQuery &query)
Definition: mythdb.cpp:178
kDupsInOldRecorded
@ kDupsInOldRecorded
Definition: recordingtypes.h:46
RecordingRule::m_autoExpire
bool m_autoExpire
Definition: recordingrule.h:127
RecordingInfo::GetAutoRunJobs
int GetAutoRunJobs(void) const
Returns a bitmap of which jobs are attached to this RecordingInfo.
Definition: recordinginfo.cpp:500
ProgramInfo::m_lastModified
QDateTime m_lastModified
Definition: programinfo.h:785
RecordingRule::m_recProfile
QString m_recProfile
Definition: recordingrule.h:121
ProgramInfo::m_episode
uint m_episode
Definition: programinfo.h:749
clamp
float clamp(float val, float minimum, float maximum)
Definition: mythmiscutil.h:59
kDupCheckUnset
@ kDupCheckUnset
Definition: recordingtypes.h:59
RecordingInfo::QuickRecord
void QuickRecord(void)
Create a kSingleRecord if not already scheduled.
Definition: recordinginfo.cpp:865
ProgramInfo::SaveTotalDuration
void SaveTotalDuration(std::chrono::milliseconds duration)
Store the Total Duration at frame 0 in the recordedmarkup table.
Definition: programinfo.cpp:4136
ProgramInfo::m_recGroup
QString m_recGroup
Definition: programinfo.h:763
RecordingRule::m_type
RecordingType m_type
Definition: recordingrule.h:113
FL_CHANCOMMFREE
@ FL_CHANCOMMFREE
Definition: programtypes.h:144
ProgramInfo::toString
QString toString(Verbosity v=kLongDescription, const QString &sep=":", const QString &grp="\"") const
Definition: programinfo.cpp:1833
ProgramInfoUpdater::insert
void insert(uint recordedid, PIAction action, uint64_t filesize=0ULL)
Definition: programinfoupdater.cpp:10
scheduledrecording.h
ScheduledRecording::RescheduleCheck
static void RescheduleCheck(const RecordingInfo &recinfo, const QString &why)
Definition: scheduledrecording.h:23
jobqueue.h
RecordingInfo::ReactivateRecording
void ReactivateRecording(void)
Asks the scheduler to restart this recording if possible.
Definition: recordinginfo.cpp:1247
RecordingInfo::StartedRecording
void StartedRecording(const QString &ext)
Inserts this RecordingInfo into the database as an existing recording.
Definition: recordinginfo.cpp:931
ProgramInfo::m_originalAirDate
QDate m_originalAirDate
Definition: programinfo.h:784
uint
unsigned int uint
Definition: compat.h:140
ProgramInfo::SetFilesize
virtual void SetFilesize(uint64_t sz)
Definition: programinfo.cpp:6116
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:60
ProgramInfo::LoadFromScheduler
static QStringList LoadFromScheduler(const QString &tmptable, int recordid)
Definition: programinfo.cpp:5326
RecordingInfo::LoadStatus
LoadStatus
Definition: recordinginfo.h:179
RecordingInfo::kNoProgram
@ kNoProgram
Definition: recordinginfo.h:180
ProgramInfo::CategoryType
CategoryType
Definition: programinfo.h:75
ProgramInfo::GetStorageGroup
QString GetStorageGroup(void) const
Definition: programinfo.h:420
ProgramInfo::m_recStatus
int8_t m_recStatus
Definition: programinfo.h:804
ScheduledRecording::ReschedulePlace
static void ReschedulePlace(const QString &why)
Definition: scheduledrecording.h:33
RecordingInfo::LoadRecordingFile
void LoadRecordingFile()
Definition: recordinginfo.cpp:1637
RecordingInfo::m_sgroupId
uint m_sgroupId
Definition: recordinginfo.h:281
RecordingFile::m_fileSize
uint64_t m_fileSize
Definition: recordingfile.h:45
kSubtitlePropertyOffset
#define kSubtitlePropertyOffset
Definition: programtypes.h:214
RecordingInfo::kFakedZeroMinProgram
@ kFakedZeroMinProgram
Definition: recordinginfo.h:183
RecordingInfo::m_schedOrder
int m_schedOrder
Definition: recordinginfo.h:279
AutoDeleteDeque< ProgramInfo * >
ProgramInfo::m_parentId
uint32_t m_parentId
Definition: programinfo.h:791
ProgramInfo::m_chanPlaybackFilters
QString m_chanPlaybackFilters
Definition: programinfo.h:761
recordinginfo.h
RecordingInfo::ApplyRecordRecPriorityChange
void ApplyRecordRecPriorityChange(int newrecpriority)
Sets recording priority of "record", creating "record" if it does not exist.
Definition: recordinginfo.cpp:588
ProgramInfo::GetChanID
uint GetChanID(void) const
This is the unique key used in the database to locate tuning information.
Definition: programinfo.h:370
kPIUpdateFileSize
@ kPIUpdateFileSize
Definition: programinfoupdater.h:22
RecordingRule::m_transcoder
int m_transcoder
Definition: recordingrule.h:131
RecordingRule::m_autoUserJob1
bool m_autoUserJob1
Definition: recordingrule.h:134
ProgramInfo::s_updater
static ProgramInfoUpdater * s_updater
Definition: programinfo.h:829
RecordingInfo::~RecordingInfo
~RecordingInfo() override
Destructor deletes "record" if it exists.
Definition: recordinginfo.cpp:456
RecordingInfo::SubstituteMatches
void SubstituteMatches(QString &str) override
Replace MATCH% vars in the specified string.
Definition: recordinginfo.cpp:1587
RecordingInfo::clone
virtual void clone(const RecordingInfo &other, bool ignore_non_serialized_data=false)
Copies important fields from other RecordingInfo.
Definition: recordinginfo.cpp:366
ProgramInfo
Holds information on recordings and videos.
Definition: programinfo.h:67
RecordingRule::m_recordID
int m_recordID
Unique Recording Rule ID.
Definition: recordingrule.h:72
ProgramInfo::m_inetRef
QString m_inetRef
Definition: programinfo.h:773
mythmiscutil.h
RecordingFile::m_recordingId
uint m_recordingId
Definition: recordingfile.h:38
ProgramInfo::m_subtitle
QString m_subtitle
Definition: programinfo.h:745
mythcorecontext.h
kOverrideRecord
@ kOverrideRecord
Definition: recordingtypes.h:28
RecordingInfo::m_record
class RecordingRule * m_record
Definition: recordinginfo.h:286
ProgramInfo::m_syndicatedEpisode
QString m_syndicatedEpisode
Definition: programinfo.h:751
kNotRecording
@ kNotRecording
Definition: recordingtypes.h:21
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:864
JOB_METADATA
@ JOB_METADATA
Definition: jobqueue.h:75
MythDate::ISODate
@ ISODate
Default UTC.
Definition: mythdate.h:17
ProgramInfo::m_findId
uint32_t m_findId
Definition: programinfo.h:795
RecStatus::CurrentRecording
@ CurrentRecording
Definition: recStatus.h:35
RecordingFile::m_fileName
QString m_fileName
Definition: recordingfile.h:44
LoadFromProgram
bool LoadFromProgram(ProgramList &destination, const QString &where, const QString &groupBy, const QString &orderBy, const MSqlBindings &bindings, const ProgramList &schedList)
Definition: programinfo.cpp:5461
RecordingInfo::clear
void clear(void) override
Definition: recordinginfo.cpp:432
LOC
#define LOC
Definition: recordinginfo.cpp:22
kSingleRecord
@ kSingleRecord
Definition: recordingtypes.h:22
ProgramInfo::m_chanSign
QString m_chanSign
Definition: programinfo.h:759
RecordingInfo::AddHistory
void AddHistory(bool resched=true, bool forcedup=false, bool future=false)
Adds recording history, creating "record" it if necessary.
Definition: recordinginfo.cpp:1268
ProgramInfo::SubstituteMatches
virtual void SubstituteMatches(QString &str)
Subsitute MATCH% type variable names in the given string.
Definition: programinfo.cpp:5213
RecordingInfo::ApplyTranscoderProfileChangeById
void ApplyTranscoderProfileChangeById(int id)
Definition: recordinginfo.cpp:773
kUnknownProgramLength
static const uint kUnknownProgramLength
Definition: recordinginfo.cpp:31
ProgramInfo::m_programFlags
uint32_t m_programFlags
ProgramFlag.
Definition: programinfo.h:797
ProgramInfo::m_partTotal
uint16_t m_partTotal
Definition: programinfo.h:802
ProgramInfo::m_chanStr
QString m_chanStr
Definition: programinfo.h:758
ProgramInfo::SendUpdateEvent
void SendUpdateEvent(void) const
Sends event out that the ProgramInfo should be reloaded.
Definition: programinfo.cpp:2611
RecordingInfo::kFakedLiveTVProgram
@ kFakedLiveTVProgram
Definition: recordinginfo.h:182
RecordingInfo::SetRecordingID
void SetRecordingID(uint _recordedid) override
Definition: recordinginfo.h:213
RecordingRule::Delete
bool Delete(bool sendSig=true)
Definition: recordingrule.cpp:501
RecordingRule::MakeOverride
bool MakeOverride(void)
Definition: recordingrule.cpp:361
MSqlQuery::numRowsAffected
int numRowsAffected() const
Definition: mythdbcon.h:206
MythCoreContext::GetHostName
QString GetHostName(void)
Definition: mythcorecontext.cpp:858
ProgramInfo::m_partNumber
uint16_t m_partNumber
Definition: programinfo.h:801
RecordingInfo::ApplyRecordRecTitleChange
void ApplyRecordRecTitleChange(const QString &newTitle, const QString &newSubtitle, const QString &newDescription)
Sets the recording title, subtitle, and description both in this RecordingInfo and in the database.
Definition: recordinginfo.cpp:741
RecordingInfo::m_recordingFile
RecordingFile * m_recordingFile
Definition: recordinginfo.h:287
RecordingFile::Load
bool Load()
Definition: recordingfile.cpp:7
FL_REPEAT
@ FL_REPEAT
Definition: programtypes.h:145
RecordingInfo::GetRecordingRule
RecordingRule * GetRecordingRule(void)
Returns the "record" field, creating it if necessary.
Definition: recordinginfo.cpp:875
RecordingInfo::ApplyRecordRecGroupChange
void ApplyRecordRecGroupChange(const QString &newrecgroup)
Sets the recording group, both in this RecordingInfo and in the database.
Definition: recordinginfo.cpp:600
ProgramInfo::m_programId
QString m_programId
Definition: programinfo.h:772
recordingrule.h
ProgramInfo::m_stars
float m_stars
Rating, range [0..1].
Definition: programinfo.h:783
RecordingRule::m_recPriority
int m_recPriority
Definition: recordingrule.h:109
RecordingFile::m_storageGroup
QString m_storageGroup
Definition: recordingfile.h:41
ProgramInfo::m_year
uint16_t m_year
Definition: programinfo.h:800
ProgramInfo::GetBasename
QString GetBasename(void) const
Definition: programinfo.h:342
RecordingRule::m_autoUserJob3
bool m_autoUserJob3
Definition: recordingrule.h:136
kVideoPropertyOffset
#define kVideoPropertyOffset
Definition: programtypes.h:200
ProgramInfo::SetReactivated
void SetReactivated(bool reactivate)
Definition: programinfo.h:532
ProgramInfo::IsGeneric
bool IsGeneric(void) const
Definition: programinfo.cpp:1824
query
MSqlQuery query(MSqlQuery::InitCon())
JOB_TRANSCODE
@ JOB_TRANSCODE
Definition: jobqueue.h:73
ProgramInfo::m_recordedId
uint m_recordedId
Definition: programinfo.h:809
ProgramInfo::CreateRecordBasename
QString CreateRecordBasename(const QString &ext) const
Returns a filename for a recording based on the recording channel and date.
Definition: programinfo.cpp:2291
RecordingType
RecordingType
Definition: recordingtypes.h:19
kDontRecord
@ kDontRecord
Definition: recordingtypes.h:29
ProgramInfo::m_properties
uint16_t m_properties
SubtitleType,VideoProperty,AudioProperty.
Definition: programinfo.h:799
RecordingRule::m_autoMetadataLookup
bool m_autoMetadataLookup
Definition: recordingrule.h:138
kDupsUnset
@ kDupsUnset
Definition: recordingtypes.h:44
RecordingFile::m_storageDeviceID
QString m_storageDeviceID
Definition: recordingfile.h:40
MythCoreContext::GetSetting
QString GetSetting(const QString &key, const QString &defaultval="")
Definition: mythcorecontext.cpp:918
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:808
RecordingInfo::SetDupHistory
void SetDupHistory(void)
Set the duplicate flag in oldrecorded.
Definition: recordinginfo.cpp:1560
Generated on Thu Jan 28 2021 03:17:00 for MythTV by   doxygen 1.8.17