MythTV  master
v2serviceUtil.cpp
Go to the documentation of this file.
1 // Standard UNIX C headers
2 #include <unistd.h>
3 #include <fcntl.h>
4 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__OpenBSD__) || defined(_WIN32)
5 #include <sys/types.h>
6 #else
7 #include <sys/sysmacros.h>
8 #endif
9 #include <sys/stat.h>
10 
11 // MythTV
12 #include "libmythbase/compat.h"
18 #include "libmythtv/cardutil.h"
19 #include "libmythtv/channelgroup.h"
20 #include "libmythtv/channelinfo.h"
21 #include "libmythtv/channelutil.h"
24 #include "libmythtv/tv_rec.h"
25 
26 // MythBackend
27 #include "backendcontext.h"
28 #include "encoderlink.h"
29 #include "scheduler.h"
30 #include "v2encoder.h"
31 #include "v2frontend.h"
32 #include "v2serviceUtil.h"
33 
34 void V2FillProgramInfo( V2Program *pProgram,
35  ProgramInfo *pInfo,
36  bool bIncChannel /* = true */,
37  bool bDetails /* = true */,
38  bool bIncCast /* = true */,
39  bool bIncArtwork /* = true */,
40  bool bIncRecording /* = true */)
41 {
42  if ((pProgram == nullptr) || (pInfo == nullptr))
43  return;
44 
45  pProgram->setStartTime ( pInfo->GetScheduledStartTime());
46  pProgram->setEndTime ( pInfo->GetScheduledEndTime ());
47  pProgram->setTitle ( pInfo->GetTitle() );
48  pProgram->setSubTitle ( pInfo->GetSubtitle() );
49  pProgram->setCategory ( pInfo->GetCategory() );
50  pProgram->setCatType ( pInfo->GetCategoryTypeString());
51  pProgram->setRepeat ( pInfo->IsRepeat() );
52  pProgram->setVideoProps( pInfo->GetVideoProperties() );
53  pProgram->setVideoPropNames( pInfo->GetVideoPropertyNames() );
54  pProgram->setAudioProps( pInfo->GetAudioProperties() );
55  pProgram->setAudioPropNames( pInfo->GetAudioPropertyNames() );
56  pProgram->setSubProps ( pInfo->GetSubtitleType() );
57  pProgram->setSubPropNames( pInfo->GetSubtitleTypeNames() );
58 
59  if (bDetails)
60  {
61  pProgram->setSeriesId ( pInfo->GetSeriesID() );
62  pProgram->setProgramId ( pInfo->GetProgramID() );
63  pProgram->setStars ( pInfo->GetStars() );
64  pProgram->setLastModified( pInfo->GetLastModifiedTime() );
65  pProgram->setProgramFlags( pInfo->GetProgramFlags() );
66  pProgram->setProgramFlagNames( pInfo->GetProgramFlagNames() );
67 
68  // ----
69  // DEPRECATED - See RecordingInfo instead
70  pProgram->setFileName ( pInfo->GetPathname() );
71  pProgram->setFileSize ( pInfo->GetFilesize() );
72  pProgram->setHostName ( pInfo->GetHostname() );
73  // ----
74 
75  if (pInfo->GetOriginalAirDate().isValid())
76  pProgram->setAirdate( pInfo->GetOriginalAirDate() );
77  else if (pInfo->GetYearOfInitialRelease() > 0)
78  {
79  QDate year;
80  year.setDate(pInfo->GetYearOfInitialRelease(), 1, 1);
81  pProgram->setAirdate( year );
82  }
83 
84  pProgram->setDescription( pInfo->GetDescription() );
85  pProgram->setInetref ( pInfo->GetInetRef() );
86  pProgram->setSeason ( pInfo->GetSeason() );
87  pProgram->setEpisode ( pInfo->GetEpisode() );
88  pProgram->setTotalEpisodes( pInfo->GetEpisodeTotal() );
89  }
90 
91  if (bIncCast)
92  V2FillCastMemberList( pProgram->Cast(), pInfo );
93  else
94  pProgram->enableCast(false);
95 
96  if (bIncChannel)
97  {
98  // Build Channel Child Element
99  if (!V2FillChannelInfo( pProgram->Channel(), pInfo->GetChanID(), bDetails ))
100  {
101  // The channel associated with a given recording may no longer exist
102  // however the ChanID is one half of the unique identifier for the
103  // recording and therefore MUST be included in the return data
104  pProgram->Channel()->setChanId(pInfo->GetChanID());
105  }
106  }
107  else
108  pProgram->enableChannel(false);
109 
110  // Build Recording Child Element
111 
112  if ( bIncRecording && pInfo->GetRecordingStatus() != RecStatus::Unknown )
113  {
114  V2RecordingInfo *pRecording = pProgram->Recording();
115 
116  const RecordingInfo pRecInfo(*pInfo);
117 
118  pRecording->setRecordedId ( pRecInfo.GetRecordingID() );
119  pRecording->setStatus ( pRecInfo.GetRecordingStatus() );
120  pRecording->setStatusName ( pRecInfo.GetRecordingStatus() );
121  pRecording->setPriority( pRecInfo.GetRecordingPriority() );
122  pRecording->setStartTs ( pRecInfo.GetRecordingStartTime() );
123  pRecording->setEndTs ( pRecInfo.GetRecordingEndTime() );
124 
125  if (bDetails)
126  {
127  pRecording->setFileName ( pRecInfo.GetPathname() );
128  pRecording->setFileSize ( pRecInfo.GetFilesize() );
129  pRecording->setHostName ( pRecInfo.GetHostname() );
130  pRecording->setLastModified( pRecInfo.GetLastModifiedTime() );
131 
132  pRecording->setRecordId ( pRecInfo.GetRecordingRuleID() );
133  pRecording->setRecGroup ( pRecInfo.GetRecordingGroup() );
134  pRecording->setPlayGroup ( pRecInfo.GetPlaybackGroup() );
135  pRecording->setStorageGroup( pRecInfo.GetStorageGroup() );
136  pRecording->setRecType ( pRecInfo.GetRecordingRuleType() );
137  pRecording->setDupInType ( pRecInfo.GetDuplicateCheckSource() );
138  pRecording->setDupMethod ( pRecInfo.GetDuplicateCheckMethod() );
139  pRecording->setEncoderId ( pRecInfo.GetInputID() );
140  pRecording->setEncoderName ( pRecInfo.GetInputName() );
141  pRecording->setProfile ( pRecInfo.GetProgramRecordingProfile() );
142  }
143  }
144  else
145  pProgram->enableRecording(false);
146 
147  if ( bIncArtwork && !pInfo->GetInetRef().isEmpty() )
148  V2FillArtworkInfoList( pProgram->Artwork(), pInfo->GetInetRef(), pInfo->GetSeason());
149  else
150  pProgram->enableArtwork(false);
151 }
152 
154 //
156 
158  uint nChanID,
159  bool bDetails /* = true */ )
160 {
161  ChannelInfo channel;
162  if (channel.Load(nChanID))
163  {
164  return V2FillChannelInfo(pChannel, channel, bDetails);
165  }
166 
167  return false;
168 }
169 
171 //
173 
175  const ChannelInfo &channelInfo,
176  bool bDetails /* = true */ )
177 {
178 
179  // TODO update V2ChannelInfo to match functionality of ChannelInfo,
180  // ultimately replacing it's progenitor?
181  pChannel->setChanId(channelInfo.m_chanId);
182  pChannel->setChanNum(channelInfo.m_chanNum);
183  pChannel->setCallSign(channelInfo.m_callSign);
184  if (!channelInfo.m_icon.isEmpty())
185  {
186  QString sIconURL = QString( "/Guide/GetChannelIcon?ChanId=%3")
187  .arg( channelInfo.m_chanId );
188  pChannel->setIconURL( sIconURL );
189  }
190  pChannel->setChannelName(channelInfo.m_name);
191  pChannel->setVisible(channelInfo.m_visible > kChannelNotVisible);
192  pChannel->setExtendedVisible(toRawString(channelInfo.m_visible));
193 
194  if (bDetails)
195  {
196  pChannel->setMplexId(channelInfo.m_mplexId);
197  pChannel->setServiceId(channelInfo.m_serviceId);
198  pChannel->setATSCMajorChan(channelInfo.m_atscMajorChan);
199  pChannel->setATSCMinorChan(channelInfo.m_atscMinorChan);
200  pChannel->setFormat(channelInfo.m_tvFormat);
201  pChannel->setFineTune(channelInfo.m_fineTune);
202  pChannel->setFrequencyId(channelInfo.m_freqId);
203  pChannel->setChanFilters(channelInfo.m_videoFilters);
204  pChannel->setSourceId(channelInfo.m_sourceId);
205  pChannel->setCommFree(channelInfo.m_commMethod == -2);
206  pChannel->setUseEIT(channelInfo.m_useOnAirGuide);
207  pChannel->setXMLTVID(channelInfo.m_xmltvId);
208  pChannel->setDefaultAuth(channelInfo.m_defaultAuthority);
209  pChannel->setServiceType(channelInfo.m_serviceType);
210  pChannel->setRecPriority(channelInfo.m_recPriority);
211  pChannel->setTimeOffset(channelInfo.m_tmOffset);
212  pChannel->setCommMethod(channelInfo.m_commMethod);
213 
214  QList<uint> groupIds = channelInfo.GetGroupIds();
215  QString sGroupIds;
216  for (int x = 0; x < groupIds.size(); x++)
217  {
218  if (x > 0)
219  sGroupIds += ",";
220 
221  sGroupIds += QString::number(groupIds.at(x));
222  }
223  pChannel->setChannelGroups(sGroupIds);
224 
225  QList<uint> inputIds = channelInfo.GetInputIds();
226  QString sInputIds;
227  for (int x = 0; x < inputIds.size(); x++)
228  {
229  if (x > 0)
230  sInputIds += ",";
231 
232  sInputIds += QString::number(inputIds.at(x));
233  }
234  pChannel->setInputs(sInputIds);
235  }
236 
237  return true;
238 }
239 
240 void V2FillChannelGroup(V2ChannelGroup* pGroup, const ChannelGroupItem& pGroupItem)
241 {
242  if (!pGroup)
243  return;
244 
245  pGroup->setGroupId(pGroupItem.m_grpId);
246  pGroup->setName(pGroupItem.m_name);
247  pGroup->setPassword(""); // Not currently supported
248 }
249 
251 //
253 
254 void V2FillRecRuleInfo( V2RecRule *pRecRule,
255  RecordingRule *pRule )
256 {
257  if ((pRecRule == nullptr) || (pRule == nullptr))
258  return;
259 
260  pRecRule->setId ( pRule->m_recordID );
261  pRecRule->setParentId ( pRule->m_parentRecID );
262  pRecRule->setInactive ( pRule->m_isInactive );
263  pRecRule->setTitle ( pRule->m_title );
264  pRecRule->setSubTitle ( pRule->m_subtitle );
265  pRecRule->setDescription ( pRule->m_description );
266  pRecRule->setSeason ( pRule->m_season );
267  pRecRule->setEpisode ( pRule->m_episode );
268  pRecRule->setCategory ( pRule->m_category );
269  pRecRule->setStartTime ( QDateTime(pRule->m_startdate,
270  pRule->m_starttime, Qt::UTC));
271  pRecRule->setEndTime ( QDateTime(pRule->m_enddate,
272  pRule->m_endtime, Qt::UTC));
273  pRecRule->setSeriesId ( pRule->m_seriesid );
274  pRecRule->setProgramId ( pRule->m_programid );
275  pRecRule->setInetref ( pRule->m_inetref );
276  pRecRule->setChanId ( pRule->m_channelid );
277  pRecRule->setCallSign ( pRule->m_station );
278  pRecRule->setFindDay ( pRule->m_findday );
279  pRecRule->setFindTime ( pRule->m_findtime );
280  pRecRule->setType ( toRawString(pRule->m_type) );
281  pRecRule->setSearchType ( toRawString(pRule->m_searchType));
282  pRecRule->setRecPriority ( pRule->m_recPriority );
283  pRecRule->setPreferredInput ( pRule->m_prefInput );
284  pRecRule->setStartOffset ( pRule->m_startOffset );
285  pRecRule->setEndOffset ( pRule->m_endOffset );
286  pRecRule->setDupMethod ( toRawString(pRule->m_dupMethod) );
287  pRecRule->setDupIn ( toRawString(pRule->m_dupIn) );
288  pRecRule->setNewEpisOnly ( newEpifromDupIn(pRule->m_dupIn) );
289  pRecRule->setFilter ( pRule->m_filter );
290  pRecRule->setRecProfile ( pRule->m_recProfile );
291  pRecRule->setRecGroup ( RecordingInfo::GetRecgroupString(pRule->m_recGroupID) );
292  pRecRule->setStorageGroup ( pRule->m_storageGroup );
293  pRecRule->setPlayGroup ( pRule->m_playGroup );
294  pRecRule->setAutoExpire ( pRule->m_autoExpire );
295  pRecRule->setMaxEpisodes ( pRule->m_maxEpisodes );
296  pRecRule->setMaxNewest ( pRule->m_maxNewest );
297  pRecRule->setAutoCommflag ( pRule->m_autoCommFlag );
298  pRecRule->setAutoTranscode ( pRule->m_autoTranscode );
299  pRecRule->setAutoMetaLookup ( pRule->m_autoMetadataLookup );
300  pRecRule->setAutoUserJob1 ( pRule->m_autoUserJob1 );
301  pRecRule->setAutoUserJob2 ( pRule->m_autoUserJob2 );
302  pRecRule->setAutoUserJob3 ( pRule->m_autoUserJob3 );
303  pRecRule->setAutoUserJob4 ( pRule->m_autoUserJob4 );
304  pRecRule->setTranscoder ( pRule->m_transcoder );
305  pRecRule->setNextRecording ( pRule->m_nextRecording );
306  pRecRule->setLastRecorded ( pRule->m_lastRecorded );
307  pRecRule->setLastDeleted ( pRule->m_lastDeleted );
308  pRecRule->setAverageDelay ( pRule->m_averageDelay );
309  pRecRule->setAutoExtend ( toString(pRule->m_autoExtend) );
310 }
311 
312 void V2FillArtworkInfoList( V2ArtworkInfoList *pArtworkInfoList,
313  const QString &sInetref,
314  uint nSeason )
315 {
316  ArtworkMap map = GetArtwork(sInetref, nSeason);
317  for (auto i = map.cbegin(); i != map.cend(); ++i)
318  {
319  V2ArtworkInfo *pArtInfo = pArtworkInfoList->AddNewArtworkInfo();
320  pArtInfo->setFileName(i.value().url);
321  switch (i.key())
322  {
323  case kArtworkFanart:
324  pArtInfo->setStorageGroup("Fanart");
325  pArtInfo->setType("fanart");
326  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
327  "&FileName=%2")
328  .arg("Fanart",
329  QString(QUrl::toPercentEncoding(
330  QUrl(i.value().url).path()))));
331  break;
332  case kArtworkBanner:
333  pArtInfo->setStorageGroup("Banners");
334  pArtInfo->setType("banner");
335  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
336  "&FileName=%2")
337  .arg("Banners",
338  QString(QUrl::toPercentEncoding(
339  QUrl(i.value().url).path()))));
340  break;
341  case kArtworkCoverart:
342  default:
343  pArtInfo->setStorageGroup("Coverart");
344  pArtInfo->setType("coverart");
345  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
346  "&FileName=%2")
347  .arg("Coverart",
348  QString(QUrl::toPercentEncoding(
349  QUrl(i.value().url).path()))));
350  break;
351  }
352  }
353 }
354 
355 void V2FillGenreList(V2GenreList* pGenreList, int videoID)
356 {
357  if (!pGenreList)
358  return;
359 
360  MSqlQuery query(MSqlQuery::InitCon());
361  query.prepare("SELECT genre from videogenre "
362  "LEFT JOIN videometadatagenre ON videometadatagenre.idgenre = videogenre.intid "
363  "WHERE idvideo = :ID "
364  "ORDER BY genre;");
365  query.bindValue(":ID", videoID);
366 
367  if (query.exec() && query.size() > 0)
368  {
369  while (query.next())
370  {
371  V2Genre *pGenre = pGenreList->AddNewGenre();
372  QString genre = query.value(0).toString();
373  pGenre->setName(genre);
374  }
375  }
376 }
377 
378 
380  V2VideoMetadataInfo *pVideoMetadataInfo,
382  bool bDetails)
383 {
384  pVideoMetadataInfo->setId(pMetadata->GetID());
385  pVideoMetadataInfo->setTitle(pMetadata->GetTitle());
386  pVideoMetadataInfo->setSubTitle(pMetadata->GetSubtitle());
387  pVideoMetadataInfo->setTagline(pMetadata->GetTagline());
388  pVideoMetadataInfo->setDirector(pMetadata->GetDirector());
389  pVideoMetadataInfo->setStudio(pMetadata->GetStudio());
390  pVideoMetadataInfo->setDescription(pMetadata->GetPlot());
391  pVideoMetadataInfo->setCertification(pMetadata->GetRating());
392  pVideoMetadataInfo->setInetref(pMetadata->GetInetRef());
393  pVideoMetadataInfo->setCollectionref(pMetadata->GetCollectionRef());
394  pVideoMetadataInfo->setHomePage(pMetadata->GetHomepage());
395  pVideoMetadataInfo->setReleaseDate(
396  QDateTime(pMetadata->GetReleaseDate(),
397  QTime(0,0),Qt::LocalTime).toUTC());
398  pVideoMetadataInfo->setAddDate(
399  QDateTime(pMetadata->GetInsertdate(),
400  QTime(0,0),Qt::LocalTime).toUTC());
401  pVideoMetadataInfo->setUserRating(pMetadata->GetUserRating());
402  pVideoMetadataInfo->setChildID(pMetadata->GetChildID());
403  pVideoMetadataInfo->setLength(pMetadata->GetLength().count());
404  pVideoMetadataInfo->setPlayCount(pMetadata->GetPlayCount());
405  pVideoMetadataInfo->setSeason(pMetadata->GetSeason());
406  pVideoMetadataInfo->setEpisode(pMetadata->GetEpisode());
407  pVideoMetadataInfo->setParentalLevel(pMetadata->GetShowLevel());
408  pVideoMetadataInfo->setVisible(pMetadata->GetBrowse());
409  pVideoMetadataInfo->setWatched(pMetadata->GetWatched());
410  pVideoMetadataInfo->setProcessed(pMetadata->GetProcessed());
411  pVideoMetadataInfo->setContentType(ContentTypeToString(
412  pMetadata->GetContentType()));
413  pVideoMetadataInfo->setFileName(pMetadata->GetFilename());
414  pVideoMetadataInfo->setHash(pMetadata->GetHash());
415  pVideoMetadataInfo->setHostName(pMetadata->GetHost());
416  pVideoMetadataInfo->setCoverart(pMetadata->GetCoverFile());
417  pVideoMetadataInfo->setFanart(pMetadata->GetFanart());
418  pVideoMetadataInfo->setBanner(pMetadata->GetBanner());
419  pVideoMetadataInfo->setScreenshot(pMetadata->GetScreenshot());
420  pVideoMetadataInfo->setTrailer(pMetadata->GetTrailer());
421 
422  if (bDetails)
423  {
424  if (!pMetadata->GetFanart().isEmpty())
425  {
426  V2ArtworkInfo *pArtInfo =
427  pVideoMetadataInfo->Artwork()->AddNewArtworkInfo();
428  pArtInfo->setStorageGroup("Fanart");
429  pArtInfo->setType("fanart");
430  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
431  "&FileName=%2")
432  .arg("Fanart",
433  QString(
434  QUrl::toPercentEncoding(pMetadata->GetFanart()))));
435  }
436  if (!pMetadata->GetCoverFile().isEmpty())
437  {
438  V2ArtworkInfo *pArtInfo =
439  pVideoMetadataInfo->Artwork()->AddNewArtworkInfo();
440  pArtInfo->setStorageGroup("Coverart");
441  pArtInfo->setType("coverart");
442  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
443  "&FileName=%2")
444  .arg("Coverart",
445  QString(
446  QUrl::toPercentEncoding(pMetadata->GetCoverFile()))));
447  }
448  if (!pMetadata->GetBanner().isEmpty())
449  {
450  V2ArtworkInfo *pArtInfo =
451  pVideoMetadataInfo->Artwork()->AddNewArtworkInfo();
452  pArtInfo->setStorageGroup("Banners");
453  pArtInfo->setType("banner");
454  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
455  "&FileName=%2")
456  .arg("Banners",
457  QString(
458  QUrl::toPercentEncoding(pMetadata->GetBanner()))));
459  }
460  if (!pMetadata->GetScreenshot().isEmpty())
461  {
462  V2ArtworkInfo *pArtInfo =
463  pVideoMetadataInfo->Artwork()->AddNewArtworkInfo();
464  pArtInfo->setStorageGroup("Screenshots");
465  pArtInfo->setType("screenshot");
466  pArtInfo->setURL(QString("/Content/GetImageFile?StorageGroup=%1"
467  "&FileName=%2")
468  .arg("Screenshots",
469  QString(
470  QUrl::toPercentEncoding(pMetadata->GetScreenshot()))));
471  }
472  }
473 
474  V2FillGenreList(pVideoMetadataInfo->Genres(), pVideoMetadataInfo->GetId());
475 }
476 
478 //
480 
482  MusicMetadata *pMetadata, bool bDetails)
483 {
484  pVideoMetadataInfo->setId(pMetadata->ID());
485  pVideoMetadataInfo->setArtist(pMetadata->Artist());
486  pVideoMetadataInfo->setCompilationArtist(pMetadata->CompilationArtist());
487  pVideoMetadataInfo->setAlbum(pMetadata->Album());
488  pVideoMetadataInfo->setTitle(pMetadata->Title());
489  pVideoMetadataInfo->setTrackNo(pMetadata->Track());
490  pVideoMetadataInfo->setGenre(pMetadata->Genre());
491  pVideoMetadataInfo->setYear(pMetadata->Year());
492  pVideoMetadataInfo->setPlayCount(pMetadata->PlayCount());
493  pVideoMetadataInfo->setLength(pMetadata->Length().count());
494  pVideoMetadataInfo->setRating(pMetadata->Rating());
495  pVideoMetadataInfo->setFileName(pMetadata->Filename());
496  pVideoMetadataInfo->setHostName(pMetadata->Hostname());
497  pVideoMetadataInfo->setLastPlayed(pMetadata->LastPlay());
498  pVideoMetadataInfo->setCompilation(pMetadata->Compilation());
499 
500  if (bDetails)
501  {
502  //TODO add coverart here
503  }
504 }
505 
506 void V2FillInputInfo(V2Input* input, const InputInfo& inputInfo)
507 {
508  input->setId(inputInfo.m_inputId);
509  input->setInputName(inputInfo.m_name);
510  input->setCardId(inputInfo.m_inputId);
511  input->setSourceId(inputInfo.m_sourceId);
512  input->setDisplayName(inputInfo.m_displayName);
513  input->setLiveTVOrder(inputInfo.m_liveTvOrder);
514  input->setScheduleOrder(inputInfo.m_scheduleOrder);
515  input->setRecPriority(inputInfo.m_recPriority);
516  input->setQuickTune(inputInfo.m_quickTune);
517 }
518 
519 
520 
522  ProgramInfo* pInfo)
523 {
524  if (!pCastMemberList || !pInfo)
525  return;
526 
527  MSqlQuery query(MSqlQuery::InitCon());
528 
529  QString table;
530  if (pInfo->GetFilesize() > 0) // FIXME: This shouldn't be the way to determine what is or isn't a recording!
531  table = "recordedcredits";
532  else
533  table = "credits";
534 
535  query.prepare(QString("SELECT role, people.name, roles.name FROM %1"
536  " AS credits"
537  " LEFT JOIN people ON"
538  " credits.person = people.person"
539  " LEFT JOIN roles ON"
540  " credits.roleid = roles.roleid"
541  " WHERE credits.chanid = :CHANID"
542  " AND credits.starttime = :STARTTIME"
543  " ORDER BY role, priority;").arg(table));
544 
545  query.bindValue(":CHANID", pInfo->GetChanID());
546  query.bindValue(":STARTTIME", pInfo->GetScheduledStartTime());
547 
548  if (query.exec() && query.size() > 0)
549  {
550  QMap<QString, QString> translations;
551  translations["ACTOR"] = QObject::tr("Actors");
552  translations["DIRECTOR"] = QObject::tr("Director");
553  translations["PRODUCER"] = QObject::tr("Producer");
554  translations["EXECUTIVE_PRODUCER"] = QObject::tr("Executive Producer");
555  translations["WRITER"] = QObject::tr("Writer");
556  translations["GUEST_STAR"] = QObject::tr("Guest Star");
557  translations["HOST"] = QObject::tr("Host");
558  translations["ADAPTER"] = QObject::tr("Adapter");
559  translations["PRESENTER"] = QObject::tr("Presenter");
560  translations["COMMENTATOR"] = QObject::tr("Commentator");
561  translations["GUEST"] = QObject::tr("Guest");
562 
563  while (query.next())
564  {
565  V2CastMember *pCastMember = pCastMemberList->AddNewCastMember();
566 
567  QString role = query.value(0).toString();
568  pCastMember->setTranslatedRole(translations.value(role.toUpper()));
569  pCastMember->setRole(role); // role is invalid after this call.
570  /* The people.name column uses utf8_bin collation.
571  * Qt-MySQL drivers use QVariant::ByteArray for string-type
572  * MySQL fields marked with the BINARY attribute (those using a
573  * *_bin collation) and QVariant::String for all others.
574  * Since QVariant::toString() uses QString::fromAscii()
575  * (through QVariant::convert()) when the QVariant's type is
576  * QVariant::ByteArray, we have to use QString::fromUtf8()
577  * explicitly to prevent corrupting characters.
578  * The following code should be changed to use the simpler
579  * toString() approach, as above, if we do a DB update to
580  * coalesce the people.name values that differ only in case and
581  * change the collation to utf8_general_ci, to match the
582  * majority of other columns, or we'll have the same problem in
583  * reverse.
584  */
585  pCastMember->setName(QString::fromUtf8(query.value(1)
586  .toByteArray().constData()));
587  pCastMember->setCharacterName(QString::fromUtf8(query.value(2)
588  .toByteArray().constData()));
589  }
590  }
591 
592 }
593 
594 
595 void V2FillCutList(V2CutList* pCutList, ProgramInfo* rInfo, int marktype)
596 {
597  frm_dir_map_t markMap;
598  frm_dir_map_t::const_iterator it;
599 
600  if (rInfo && rInfo->GetChanID())
601  {
602  rInfo->QueryCutList(markMap);
603 
604  for (it = markMap.cbegin(); it != markMap.cend(); ++it)
605  {
606  bool isend = (*it) == MARK_CUT_END || (*it) == MARK_COMM_END;
607  if (marktype == 0)
608  {
609  V2Cutting *pCutting = pCutList->AddNewCutting();
610  pCutting->setMark(*it);
611  pCutting->setOffset(it.key());
612  }
613  else if (marktype == 1)
614  {
615  uint64_t offset = 0;
616  if (rInfo->QueryKeyFramePosition(&offset, it.key(), isend))
617  {
618  V2Cutting *pCutting = pCutList->AddNewCutting();
619  pCutting->setMark(*it);
620  pCutting->setOffset(offset);
621  }
622  }
623  else if (marktype == 2)
624  {
625  uint64_t offset = 0;
626  if (rInfo->QueryKeyFrameDuration(&offset, it.key(), isend))
627  {
628  V2Cutting *pCutting = pCutList->AddNewCutting();
629  pCutting->setMark(*it);
630  pCutting->setOffset(offset);
631  }
632  }
633  }
634  }
635 }
636 
637 void V2FillCommBreak(V2CutList* pCutList, ProgramInfo* rInfo, int marktype)
638 {
639  frm_dir_map_t markMap;
640  frm_dir_map_t::const_iterator it;
641 
642  if (rInfo)
643  {
644  rInfo->QueryCommBreakList(markMap);
645 
646  for (it = markMap.cbegin(); it != markMap.cend(); ++it)
647  {
648  bool isend = (*it) == MARK_CUT_END || (*it) == MARK_COMM_END;
649  if (marktype == 0)
650  {
651  V2Cutting *pCutting = pCutList->AddNewCutting();
652  pCutting->setMark(*it);
653  pCutting->setOffset(it.key());
654  }
655  else if (marktype == 1)
656  {
657  uint64_t offset = 0;
658  if (rInfo->QueryKeyFramePosition(&offset, it.key(), isend))
659  {
660  V2Cutting *pCutting = pCutList->AddNewCutting();
661  pCutting->setMark(*it);
662  pCutting->setOffset(offset);
663  }
664  }
665  else if (marktype == 2)
666  {
667  uint64_t offset = 0;
668  if (rInfo->QueryKeyFrameDuration(&offset, it.key(), isend))
669  {
670  V2Cutting *pCutting = pCutList->AddNewCutting();
671  pCutting->setMark(*it);
672  pCutting->setOffset(offset);
673  }
674  }
675  }
676  }
677 }
678 
680 //
682 
683 void V2FillSeek(V2CutList* pCutList, RecordingInfo* rInfo, MarkTypes marktype)
684 {
685  frm_pos_map_t markMap;
686  frm_pos_map_t::const_iterator it;
687 
688  if (rInfo && rInfo->GetChanID())
689  {
690  rInfo->QueryPositionMap(markMap, marktype);
691 
692  for (it = markMap.cbegin(); it != markMap.cend(); ++it)
693  {
694  V2Cutting *pCutting = pCutList->AddNewCutting();
695  pCutting->setMark(it.key());
696  pCutting->setOffset(it.value());
697  }
698  }
699 }
700 
701 void FillEncoderList(QVariantList &list, QObject* parent)
702 {
703  QReadLocker tvlocker(&TVRec::s_inputsLock);
704  QList<InputInfo> inputInfoList = CardUtil::GetAllInputInfo(true);
705  for (auto * elink : qAsConst(gTVList))
706  {
707  if (elink != nullptr)
708  {
709  // V2Encoder *pEncoder = list->AddNewEncoder();
710  auto *pEncoder = new V2Encoder( parent );
711  list.append( QVariant::fromValue<QObject *>( pEncoder ));
712 
713  pEncoder->setId ( elink->GetInputID() );
714  pEncoder->setState ( elink->GetState() );
715  pEncoder->setLocal ( elink->IsLocal() );
716  pEncoder->setConnected ( elink->IsConnected() );
717  pEncoder->setSleepStatus ( elink->GetSleepStatus() );
718 
719  if (pEncoder->GetLocal())
720  pEncoder->setHostName( gCoreContext->GetHostName() );
721  else
722  pEncoder->setHostName( elink->GetHostName() );
723 
724  for (const auto & inputInfo : qAsConst(inputInfoList))
725  {
726  if (inputInfo.m_inputId == static_cast<uint>(elink->GetInputID()))
727  {
728  V2Input *input = pEncoder->AddNewInput();
729  V2FillInputInfo(input, inputInfo);
730  }
731  }
732 
733  bool progFound = false;
734  V2Program *pProgram = pEncoder->Recording();
735  switch ( pEncoder->GetState() )
736  {
740  {
741  ProgramInfo *pInfo = elink->GetRecording();
742 
743  if (pInfo)
744  {
745  progFound= true;
746  V2FillProgramInfo( pProgram, pInfo, true, true );
747  delete pInfo;
748  }
749 
750  break;
751  }
752 
753  default:
754  break;
755  }
756  if (!progFound)
757  pProgram->setProperty("isNull",QVariant(true));
758  }
759  }
760 }
761 
762 // Note - special value -999 for nRecStatus means all values less than 0.
763 // This is needed by BackendStatus API
764 int FillUpcomingList(QVariantList &list, QObject* parent,
765  int& nStartIndex,
766  int& nCount,
767  bool bShowAll,
768  int nRecordId,
769  int nRecStatus )
770 {
771  RecordingList recordingList; // Auto-delete deque
772  RecList tmpList; // Standard deque, objects must be deleted
773 
774  if (nRecordId <= 0)
775  nRecordId = -1;
776 
777  // For nRecStatus to be effective, showAll must be true.
778  if (nRecStatus != 0)
779  bShowAll = true;
780 
781  // NOTE: Fetching this information directly from the schedule is
782  // significantly faster than using ProgramInfo::LoadFromScheduler()
783  auto *scheduler = dynamic_cast<Scheduler*>(gCoreContext->GetScheduler());
784  if (scheduler)
785  scheduler->GetAllPending(tmpList, nRecordId);
786 
787  // Sort the upcoming into only those which will record
788  // NOLINTNEXTLINE(modernize-loop-convert)
789  for (auto it = tmpList.begin(); it < tmpList.end(); ++it)
790  {
791  if ((nRecStatus == -999
792  && (*it)->GetRecordingStatus() >= 0)
793  || (nRecStatus != 0 && nRecStatus != -999
794  && (*it)->GetRecordingStatus() != nRecStatus))
795  {
796  delete *it;
797  *it = nullptr;
798  continue;
799  }
800 
801  if (!bShowAll && ((((*it)->GetRecordingStatus() >= RecStatus::Pending) &&
802  ((*it)->GetRecordingStatus() <= RecStatus::WillRecord)) ||
803  ((*it)->GetRecordingStatus() == RecStatus::Offline) ||
804  ((*it)->GetRecordingStatus() == RecStatus::Conflict)) &&
805  ((*it)->GetRecordingEndTime() > MythDate::current()))
806  { // NOLINT(bugprone-branch-clone)
807  recordingList.push_back(new RecordingInfo(**it));
808  }
809  else if (bShowAll &&
810  ((*it)->GetRecordingEndTime() > MythDate::current()))
811  {
812  recordingList.push_back(new RecordingInfo(**it));
813  }
814 
815  delete *it;
816  *it = nullptr;
817  }
818 
819  // ----------------------------------------------------------------------
820  // Build Response
821  // ----------------------------------------------------------------------
822 
823  nStartIndex = (nStartIndex > 0) ? std::min( nStartIndex, (int)recordingList.size() ) : 0;
824  nCount = (nCount > 0) ? std::min( nCount, (int)recordingList.size() ) : recordingList.size();
825  int nEndIndex = std::min((nStartIndex + nCount), (int)recordingList.size() );
826 
827  for( int n = nStartIndex; n < nEndIndex; n++)
828  {
829  ProgramInfo *pInfo = recordingList[ n ];
830  auto *pProgram = new V2Program( parent );
831  list.append( QVariant::fromValue<QObject *>( pProgram ));
832  V2FillProgramInfo( pProgram, pInfo, true );
833  }
834 
835  return recordingList.size();
836 }
837 
838 void FillFrontendList(QVariantList &list, QObject* parent, bool OnLine)
839 {
840  QMap<QString, Frontend*> frontends;
841  if (OnLine)
842  frontends = gBackendContext->GetConnectedFrontends();
843  else
844  frontends = gBackendContext->GetFrontends();
845 
846  for (auto * fe : qAsConst(frontends))
847  {
848  auto *pFrontend = new V2Frontend( parent );
849  list.append( QVariant::fromValue<QObject *>( pFrontend ));
850  pFrontend->setName(fe->m_name);
851  pFrontend->setIP(fe->m_ip.toString());
852  int port = gCoreContext->GetNumSettingOnHost("FrontendStatusPort",
853  fe->m_name, 6547);
854  pFrontend->setPort(port);
855  pFrontend->setOnLine(fe->m_connectionCount > 0);
856  }
857 }
858 
859 
860 int V2CreateRecordingGroup(const QString& groupName)
861 {
862  int groupID = -1;
863  MSqlQuery query(MSqlQuery::InitCon());
864 
865  query.prepare("INSERT INTO recgroups SET recgroup = :NAME, "
866  "displayname = :DISPLAYNAME");
867  query.bindValue(":NAME", groupName);
868  query.bindValue(":DISPLAYNAME", groupName);
869 
870  if (query.exec())
871  groupID = query.lastInsertId().toInt();
872 
873  if (groupID <= 0)
874  LOG(VB_GENERAL, LOG_ERR, QString("Could not create recording group (%1). "
875  "Does it already exist?").arg(groupName));
876 
877  return groupID;
878 }
879 
880 DBCredits * V2jsonCastToCredits(const QJsonObject &cast)
881 {
882  int priority = 1;
883  auto* credits = new DBCredits;
884 
885  QJsonArray members = cast["CastMembers"].toArray();
886  for (const auto & m : members)
887  {
888  QJsonObject actor = m.toObject();
889  QString name = actor.value("Name").toString("");
890  QString character = actor.value("CharacterName").toString("");
891  QString role = actor.value("Role").toString("");
892 
893  credits->emplace_back(role, name, priority++, character);
894  }
895 
896  return credits;
897 }
898 
899 // Code copied from class VideoDevice
900 V2CaptureDeviceList* getV4l2List ( const QRegularExpression &driver, const QString & cardType )
901 {
902  auto* pList = new V2CaptureDeviceList();
903  uint minor_min = 0;
904  uint minor_max = 15;
905  QString card = QString();
906 
907  // /dev/v4l/video*
908  QDir dev("/dev/v4l", "video*", QDir::Name, QDir::System);
909  fillSelectionsFromDir(dev, minor_min, minor_max,
910  card, driver, false, pList, cardType);
911 
912  // /dev/video*
913  dev.setPath("/dev");
914  fillSelectionsFromDir(dev, minor_min, minor_max,
915  card, driver, false, pList, cardType);
916 
917  // /dev/dtv/video*
918  dev.setPath("/dev/dtv");
919  fillSelectionsFromDir(dev, minor_min, minor_max,
920  card, driver, false, pList, cardType);
921 
922  // /dev/dtv*
923  dev.setPath("/dev");
924  dev.setNameFilters(QStringList("dtv*"));
925  fillSelectionsFromDir(dev, minor_min, minor_max,
926  card, driver, false, pList, cardType);
927 
928  return pList;
929 }
930 
931 uint fillSelectionsFromDir(const QDir& dir,
932  uint minor_min, uint minor_max,
933  const QString& card, const QRegularExpression& driver,
934  bool allow_duplicates, V2CaptureDeviceList *pList,
935  const QString & cardType)
936 {
937  uint cnt = 0;
938  QMap<uint, uint> minorlist;
939  QFileInfoList entries = dir.entryInfoList();
940  for (const auto & fi : qAsConst(entries))
941  {
942  struct stat st {};
943  QString filepath = fi.absoluteFilePath();
944  int err = lstat(filepath.toLocal8Bit().constData(), &st);
945 
946  if (err)
947  {
948  LOG(VB_GENERAL, LOG_ERR,
949  QString("Could not stat file: %1").arg(filepath));
950  continue;
951  }
952 
953  // is this is a character device?
954  if (!S_ISCHR(st.st_mode))
955  continue;
956 
957  // is this device is in our minor range?
958  uint minor_num = minor(st.st_rdev);
959  if (minor_min > minor_num || minor_max < minor_num)
960  continue;
961 
962  // ignore duplicates if allow_duplicates not set
963  if (!allow_duplicates && minorlist[minor_num])
964  continue;
965 
966  // if the driver returns any info add this device to our list
967  QByteArray tmp = filepath.toLatin1();
968  int videofd = open(tmp.constData(), O_RDWR);
969  if (videofd >= 0)
970  {
971  QString card_name;
972  QString driver_name;
973  if (CardUtil::GetV4LInfo(videofd, card_name, driver_name))
974  {
975  auto match = driver.match(driver_name);
976  if ((!driver.pattern().isEmpty() || match.hasMatch()) &&
977  (card.isEmpty() || (card_name == card)))
978  {
979  auto* pDev = pList->AddCaptureDevice();
980  pDev->setCardType (cardType);
981  pDev->setVideoDevice (filepath);
982  pDev->setFrontendName(card_name);
983  QStringList inputs;
984  CardUtil::GetDeviceInputNames(filepath, cardType, inputs);
985  pDev->setInputNames(inputs);
986  inputs = CardUtil::ProbeAudioInputs(filepath);
987  pDev->setAudioDevices(inputs);
988  if (cardType == "HDPVR")
989  pDev->setChannelTimeout ( 15000 );
990  cnt++;
991  }
992  }
993  close(videofd);
994  }
995  // add to list of minors discovered to avoid duplicates
996  minorlist[minor_num] = 1;
997  }
998 
999  return cnt;
1000 }
1001 
1002 V2CaptureDeviceList* getFirewireList (const QString & cardType)
1003 {
1004  auto* pList = new V2CaptureDeviceList();
1005 
1006 #ifdef USING_FIREWIRE
1007  std::vector<AVCInfo> list = FirewireDevice::GetSTBList();
1008  for (auto & info : list)
1009  {
1010  auto* pDev = pList->AddCaptureDevice();
1011  pDev->setCardType (cardType);
1012  QString guid = info.GetGUIDString();
1013  pDev->setVideoDevice (guid);
1014  QString model = FirewireDevice::GetModelName(info.m_vendorid, info.m_modelid);
1015  pDev->setFirewireModel(model);
1016  pDev->setDescription(info.m_product_name);
1017  pDev->setSignalTimeout ( 2000 );
1018  pDev->setChannelTimeout ( 9000 );
1019  }
1020 #endif // USING_FIREWIRE
1021  return pList;
1022 }
ChannelInfo
Definition: channelinfo.h:31
V2FillGenreList
void V2FillGenreList(V2GenreList *pGenreList, int videoID)
Definition: v2serviceUtil.cpp:355
ChannelGroupItem::m_grpId
uint m_grpId
Definition: channelgroup.h:28
RecordingRule::m_channelid
int m_channelid
callsign?
Definition: recordingrule.h:99
Scheduler
Definition: scheduler.h:45
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:811
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:128
V2CaptureDeviceList::AddCaptureDevice
V2CaptureDevice * AddCaptureDevice()
Definition: v2captureCardList.h:117
RecordingRule::m_autoTranscode
bool m_autoTranscode
Definition: recordingrule.h:132
ChannelInfo::m_serviceType
uint m_serviceType
Definition: channelinfo.h:112
RecordingRule::m_enddate
QDate m_enddate
Definition: recordingrule.h:90
MusicMetadata::Title
QString Title() const
Definition: musicmetadata.h:162
RecordingRule::m_playGroup
QString m_playGroup
Definition: recordingrule.h:122
MythDate::toString
QString toString(const QDateTime &raw_dt, uint format)
Returns formatted string representing the time.
Definition: mythdate.cpp:84
MSqlQuery::size
int size(void) const
Definition: mythdbcon.h:215
RecordingRule::m_seriesid
QString m_seriesid
Definition: recordingrule.h:84
RecordingRule::m_parentRecID
int m_parentRecID
Definition: recordingrule.h:71
MusicMetadata::Filename
QString Filename(bool find=true)
Definition: musicmetadata.cpp:959
ProgramInfo::GetFilesize
virtual uint64_t GetFilesize(void) const
Definition: programinfo.cpp:6345
MARK_COMM_END
@ MARK_COMM_END
Definition: programtypes.h:60
backendcontext.h
V2FillProgramInfo
void V2FillProgramInfo(V2Program *pProgram, ProgramInfo *pInfo, bool bIncChannel, bool bDetails, bool bIncCast, bool bIncArtwork, bool bIncRecording)
Definition: v2serviceUtil.cpp:34
RecordingRule::m_description
QString m_description
Definition: recordingrule.h:81
MusicMetadata::Genre
QString Genre() const
Definition: musicmetadata.h:175
RecordingRule::m_autoCommFlag
bool m_autoCommFlag
Definition: recordingrule.h:131
RecordingRule::m_inetref
QString m_inetref
Definition: recordingrule.h:87
ProgramInfo::GetHostname
QString GetHostname(void) const
Definition: programinfo.h:421
ProgramInfo::GetInputName
QString GetInputName(void) const
Definition: programinfo.h:464
MythCoreContext::GetScheduler
MythScheduler * GetScheduler(void)
Definition: mythcorecontext.cpp:1874
RecordingRule::m_maxNewest
bool m_maxNewest
Definition: recordingrule.h:127
ProgramInfo::QueryPositionMap
void QueryPositionMap(frm_pos_map_t &posMap, MarkTypes type) const
Definition: programinfo.cpp:3763
RecordingRule::m_category
QString m_category
Definition: recordingrule.h:82
toRawString
QString toRawString(RecordingType rectype)
Converts "rectype" into an untranslated string.
Definition: recordingtypes.cpp:76
RecordingRule::m_nextRecording
QDateTime m_nextRecording
Definition: recordingrule.h:142
ChannelInfo::m_chanId
uint m_chanId
Definition: channelinfo.h:85
RecordingRule::m_starttime
QTime m_starttime
Definition: recordingrule.h:91
V2RecordingInfo
Definition: v2recording.h:23
V2ArtworkInfoList
Definition: v2artworkInfoList.h:22
V2Program::Recording
QObject Recording
Definition: v2programAndChannel.h:148
FillUpcomingList
int FillUpcomingList(QVariantList &list, QObject *parent, int &nStartIndex, int &nCount, bool bShowAll, int nRecordId, int nRecStatus)
Definition: v2serviceUtil.cpp:764
MusicMetadata::CompilationArtist
QString CompilationArtist() const
Definition: musicmetadata.h:138
V2FillCommBreak
void V2FillCommBreak(V2CutList *pCutList, ProgramInfo *rInfo, int marktype)
Definition: v2serviceUtil.cpp:637
simple_ref_ptr
Definition: quicksp.h:24
ChannelInfo::m_freqId
QString m_freqId
Definition: channelinfo.h:87
V2FillVideoMetadataInfo
void V2FillVideoMetadataInfo(V2VideoMetadataInfo *pVideoMetadataInfo, const VideoMetadataListManager::VideoMetadataPtr &pMetadata, bool bDetails)
Definition: v2serviceUtil.cpp:379
FirewireDevice::GetModelName
static QString GetModelName(uint vendor_id, uint model_id)
Definition: firewiredevice.cpp:350
ChannelGroupItem
Definition: channelgroup.h:15
RecordingInfo
Holds information on a TV Program one might wish to record.
Definition: recordinginfo.h:35
newEpifromDupIn
bool newEpifromDupIn(RecordingDupInType recdupin)
Definition: recordingtypes.cpp:211
MARK_CUT_END
@ MARK_CUT_END
Definition: programtypes.h:55
RecordingInfo::GetFilesize
uint64_t GetFilesize(void) const override
Definition: recordinginfo.cpp:1755
ProgramInfo::GetRecordingID
uint GetRecordingID(void) const
Definition: programinfo.h:446
ChannelInfo::m_fineTune
int m_fineTune
Definition: channelinfo.h:95
MSqlQuery::lastInsertId
QVariant lastInsertId()
Return the id of the last inserted row.
Definition: mythdbcon.cpp:934
RecordingRule::m_title
QString m_title
Definition: recordingrule.h:77
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:205
V2ChannelGroup
Definition: v2channelGroup.h:19
ProgramInfo::GetCategory
QString GetCategory(void) const
Definition: programinfo.h:369
RecordingRule::m_averageDelay
int m_averageDelay
Definition: recordingrule.h:141
GetArtwork
ArtworkMap GetArtwork(const QString &inetref, uint season, bool strict)
Definition: metadataimagehelper.cpp:23
frm_dir_map_t
QMap< uint64_t, MarkTypes > frm_dir_map_t
Frame # -> Mark map.
Definition: programtypes.h:118
RecordingRule::m_lastDeleted
QDateTime m_lastDeleted
Definition: recordingrule.h:144
RecStatus::Unknown
@ Unknown
Definition: recordingstatus.h:32
RecordingRule
Internal representation of a recording rule, mirrors the record table.
Definition: recordingrule.h:28
RecordingRule::m_endOffset
int m_endOffset
Definition: recordingrule.h:110
ChannelInfo::m_atscMajorChan
uint m_atscMajorChan
Definition: channelinfo.h:113
MusicMetadata::ID
IdType ID() const
Definition: musicmetadata.h:218
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:617
V2Frontend
Definition: v2frontend.h:18
ChannelInfo::m_name
QString m_name
Definition: channelinfo.h:92
MusicMetadata::Track
int Track() const
Definition: musicmetadata.h:199
ContentTypeToString
QString ContentTypeToString(VideoContentType type)
Definition: videoutils.cpp:300
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:39
ProgramInfo::GetScheduledEndTime
QDateTime GetScheduledEndTime(void) const
The scheduled end time of the program.
Definition: programinfo.h:397
ProgramInfo::QueryKeyFrameDuration
bool QueryKeyFrameDuration(uint64_t *duration, uint64_t keyframe, bool backwards) const
Definition: programinfo.cpp:4217
firewiredevice.h
MusicMetadata
Definition: musicmetadata.h:80
MusicMetadata::Length
std::chrono::milliseconds Length() const
Definition: musicmetadata.h:205
gBackendContext
BackendContext * gBackendContext
Definition: backendcontext.cpp:9
recordingtypes.h
RecordingRule::m_dupIn
RecordingDupInType m_dupIn
Definition: recordingrule.h:114
RecordingRule::m_isInactive
bool m_isInactive
Recording rule is enabled?
Definition: recordingrule.h:74
ProgramInfo::GetRecordingEndTime
QDateTime GetRecordingEndTime(void) const
Approximate time the recording should have ended, did end, or is intended to end.
Definition: programinfo.h:412
ProgramInfo::GetProgramFlags
uint32_t GetProgramFlags(void) const
Definition: programinfo.h:470
ProgramInfo::GetRecordingGroup
QString GetRecordingGroup(void) const
Definition: programinfo.h:419
getV4l2List
V2CaptureDeviceList * getV4l2List(const QRegularExpression &driver, const QString &cardType)
Definition: v2serviceUtil.cpp:900
MusicMetadata::Artist
QString Artist() const
Definition: musicmetadata.h:126
ProgramInfo::GetRecordingPriority
int GetRecordingPriority(void) const
Definition: programinfo.h:440
V2CaptureDeviceList
Definition: v2captureCardList.h:97
RecordingRule::m_season
uint m_season
Definition: recordingrule.h:94
FirewireDevice::GetSTBList
static std::vector< AVCInfo > GetSTBList(void)
Definition: firewiredevice.cpp:363
V2Program::Channel
QObject Channel
Definition: v2programAndChannel.h:147
ChannelInfo::m_icon
QString m_icon
Definition: channelinfo.h:93
scheduler.h
MythDate::current
QDateTime current(bool stripped)
Returns current Date and Time in UTC.
Definition: mythdate.cpp:14
ProgramInfo::GetRecordingStartTime
QDateTime GetRecordingStartTime(void) const
Approximate time the recording started.
Definition: programinfo.h:404
ProgramInfo::GetPathname
QString GetPathname(void) const
Definition: programinfo.h:343
FillFrontendList
void FillFrontendList(QVariantList &list, QObject *parent, bool OnLine)
Definition: v2serviceUtil.cpp:838
close
#define close
Definition: compat.h:43
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
programtypes.h
DBCredits
std::vector< DBPerson > DBCredits
Definition: programdata.h:73
kState_WatchingRecording
@ kState_WatchingRecording
Watching Recording is the state for when we are watching an in progress recording,...
Definition: tv.h:80
V2CutList::AddNewCutting
V2Cutting * AddNewCutting()
Definition: v2cutList.h:43
ProgramInfo::IsRepeat
bool IsRepeat(void) const
Definition: programinfo.h:487
RecStatus::WillRecord
@ WillRecord
Definition: recordingstatus.h:31
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:492
ProgramInfo::GetInetRef
QString GetInetRef(void) const
Definition: programinfo.h:437
ProgramInfo::GetVideoPropertyNames
QString GetVideoPropertyNames(void) const
Definition: programinfo.cpp:1509
RecordingRule::m_startOffset
int m_startOffset
Definition: recordingrule.h:109
ProgramInfo::GetYearOfInitialRelease
uint GetYearOfInitialRelease(void) const
Definition: programinfo.h:423
ChannelInfo::m_commMethod
int m_commMethod
Definition: channelinfo.h:119
V2FillInputInfo
void V2FillInputInfo(V2Input *input, const InputInfo &inputInfo)
Definition: v2serviceUtil.cpp:506
ChannelInfo::m_useOnAirGuide
bool m_useOnAirGuide
Definition: channelinfo.h:108
RecordingRule::m_episode
uint m_episode
Definition: recordingrule.h:95
InputInfo::m_recPriority
int m_recPriority
Definition: inputinfo.h:53
minor
#define minor(X)
Definition: compat.h:78
programinfo.h
getFirewireList
V2CaptureDeviceList * getFirewireList(const QString &cardType)
Definition: v2serviceUtil.cpp:1002
ProgramInfo::GetScheduledStartTime
QDateTime GetScheduledStartTime(void) const
The scheduled start time of program.
Definition: programinfo.h:390
ProgramInfo::GetRecordingStatus
RecStatus::Type GetRecordingStatus(void) const
Definition: programinfo.h:447
V2VideoMetadataInfo::Artwork
QObject Artwork
Definition: v2videoMetadataInfo.h:46
v2serviceUtil.h
InputInfo::m_liveTvOrder
uint m_liveTvOrder
order for live TV use
Definition: inputinfo.h:55
RecordingRule::m_autoUserJob4
bool m_autoUserJob4
Definition: recordingrule.h:136
CardUtil::GetV4LInfo
static bool GetV4LInfo(int videofd, QString &input, QString &driver, uint32_t &version, uint32_t &capabilities)
Definition: cardutil.cpp:2349
V2FillRecRuleInfo
void V2FillRecRuleInfo(V2RecRule *pRecRule, RecordingRule *pRule)
Definition: v2serviceUtil.cpp:254
ProgramInfo::GetProgramFlagNames
QString GetProgramFlagNames(void) const
Definition: programinfo.cpp:1498
ProgramInfo::GetSubtitleTypeNames
QString GetSubtitleTypeNames(void) const
Definition: programinfo.cpp:1503
ChannelInfo::GetGroupIds
QList< uint > GetGroupIds() const
Definition: channelinfo.h:57
v2encoder.h
FillEncoderList
void FillEncoderList(QVariantList &list, QObject *parent)
Definition: v2serviceUtil.cpp:701
ChannelInfo::m_atscMinorChan
uint m_atscMinorChan
Definition: channelinfo.h:114
RecordingInfo::GetRecgroupString
static QString GetRecgroupString(uint recGroupID)
Temporary helper during transition from string to ID.
Definition: recordinginfo.cpp:1705
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:549
ProgramInfo::GetTitle
QString GetTitle(void) const
Definition: programinfo.h:361
ProgramInfo::GetDescription
QString GetDescription(void) const
Definition: programinfo.h:365
compat.h
RecordingRule::m_autoUserJob2
bool m_autoUserJob2
Definition: recordingrule.h:134
BackendContext::GetFrontends
QMap< QString, Frontend * > GetFrontends() const
Definition: backendcontext.h:43
V2FillSeek
void V2FillSeek(V2CutList *pCutList, RecordingInfo *rInfo, MarkTypes marktype)
Definition: v2serviceUtil.cpp:683
ProgramInfo::GetEpisodeTotal
uint GetEpisodeTotal(void) const
Definition: programinfo.h:368
RecordingRule::m_findtime
QTime m_findtime
Time for timeslot rules.
Definition: recordingrule.h:101
V2FillCastMemberList
void V2FillCastMemberList(V2CastMemberList *pCastMemberList, ProgramInfo *pInfo)
Definition: v2serviceUtil.cpp:521
RecordingRule::m_lastRecorded
QDateTime m_lastRecorded
Definition: recordingrule.h:143
RecordingRule::m_autoExpire
bool m_autoExpire
Definition: recordingrule.h:126
V2Encoder
Definition: v2encoder.h:23
RecordingRule::m_recProfile
QString m_recProfile
Definition: recordingrule.h:120
ChannelInfo::m_chanNum
QString m_chanNum
Definition: channelinfo.h:86
ProgramInfo::QueryCutList
bool QueryCutList(frm_dir_map_t &delMap, bool loadAutosave=false) const
Definition: programinfo.cpp:3465
kArtworkFanart
@ kArtworkFanart
Definition: metadataimagehelper.h:12
RecordingRule::m_searchType
RecSearchType m_searchType
Definition: recordingrule.h:112
RecordingRule::m_type
RecordingType m_type
Definition: recordingrule.h:111
RecStatus::Conflict
@ Conflict
Definition: recordingstatus.h:39
MythCoreContext::GetNumSettingOnHost
int GetNumSettingOnHost(const QString &key, const QString &host, int defaultval=0)
Definition: mythcorecontext.cpp:942
RecordingRule::m_subtitle
QString m_subtitle
Definition: recordingrule.h:79
V2FillChannelGroup
void V2FillChannelGroup(V2ChannelGroup *pGroup, const ChannelGroupItem &pGroupItem)
Definition: v2serviceUtil.cpp:240
ProgramInfo::GetAudioProperties
uint GetAudioProperties(void) const
Definition: programinfo.h:497
V2CutList
Definition: v2cutList.h:21
ProgramInfo::GetPlaybackGroup
QString GetPlaybackGroup(void) const
Definition: programinfo.h:420
V2Genre
Definition: v2genre.h:21
RecordingRule::m_findday
int m_findday
Day of the week for once per week etc.
Definition: recordingrule.h:104
V2FillChannelInfo
bool V2FillChannelInfo(V2ChannelInfo *pChannel, uint nChanID, bool bDetails)
Definition: v2serviceUtil.cpp:157
ChannelInfo::m_tmOffset
int m_tmOffset
Definition: channelinfo.h:120
RecordingRule::m_filter
unsigned m_filter
Definition: recordingrule.h:115
V2Program::Artwork
QObject Artwork
Definition: v2programAndChannel.h:149
TVRec::s_inputsLock
static QReadWriteLock s_inputsLock
Definition: tv_rec.h:433
uint
unsigned int uint
Definition: compat.h:81
gTVList
QMap< int, EncoderLink * > gTVList
Definition: backendcontext.cpp:7
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:55
ProgramInfo::GetSeriesID
QString GetSeriesID(void) const
Definition: programinfo.h:435
ChannelGroupItem::m_name
QString m_name
Definition: channelgroup.h:29
V2ArtworkInfoList::AddNewArtworkInfo
V2ArtworkInfo * AddNewArtworkInfo()
Definition: v2artworkInfoList.h:46
V2CreateRecordingGroup
int V2CreateRecordingGroup(const QString &groupName)
Definition: v2serviceUtil.cpp:860
ProgramInfo::GetStorageGroup
QString GetStorageGroup(void) const
Definition: programinfo.h:422
RecordingRule::m_maxEpisodes
int m_maxEpisodes
Definition: recordingrule.h:125
RecStatus::Offline
@ Offline
Definition: recordingstatus.h:44
ProgramInfo::GetOriginalAirDate
QDate GetOriginalAirDate(void) const
Definition: programinfo.h:428
RecordingRule::m_programid
QString m_programid
Definition: recordingrule.h:85
channelutil.h
frm_pos_map_t
QMap< long long, long long > frm_pos_map_t
Frame # -> File offset map.
Definition: programtypes.h:45
InputInfo::m_inputId
uint m_inputId
unique key in DB for this input
Definition: inputinfo.h:49
ProgramInfo::GetVideoProperties
uint GetVideoProperties(void) const
Definition: programinfo.h:495
RecStatus::Pending
@ Pending
Definition: recordingstatus.h:17
RecordingRule::m_recGroupID
uint m_recGroupID
Definition: recordingrule.h:123
RecordingRule::m_endtime
QTime m_endtime
Definition: recordingrule.h:92
MusicMetadata::Album
QString Album() const
Definition: musicmetadata.h:150
InputInfo::m_quickTune
bool m_quickTune
Definition: inputinfo.h:56
BackendContext::GetConnectedFrontends
QMap< QString, Frontend * > GetConnectedFrontends() const
Definition: backendcontext.h:42
ProgramInfo::GetDuplicateCheckMethod
RecordingDupMethodType GetDuplicateCheckMethod(void) const
What should be compared to determine if two programs are the same?
Definition: programinfo.h:459
AutoDeleteDeque
Definition: autodeletedeque.h:8
channelinfo.h
ProgramInfo::GetInputID
uint GetInputID(void) const
Definition: programinfo.h:463
V2MusicMetadataInfo
Definition: v2musicMetadataInfo.h:22
InputInfo::m_scheduleOrder
uint m_scheduleOrder
Definition: inputinfo.h:54
InputInfo::m_sourceId
uint m_sourceId
associated channel listings source
Definition: inputinfo.h:48
recordinginfo.h
lstat
#define lstat
Definition: compat.h:121
RecordingRule::m_storageGroup
QString m_storageGroup
Definition: recordingrule.h:121
ProgramInfo::GetChanID
uint GetChanID(void) const
This is the unique key used in the database to locate tuning information.
Definition: programinfo.h:372
ProgramInfo::GetRecordingRuleType
RecordingType GetRecordingRuleType(void) const
Definition: programinfo.h:451
ProgramInfo::GetEpisode
uint GetEpisode(void) const
Definition: programinfo.h:367
RecordingRule::m_transcoder
int m_transcoder
Definition: recordingrule.h:130
RecordingRule::m_autoUserJob1
bool m_autoUserJob1
Definition: recordingrule.h:133
AutoDeleteDeque::push_back
void push_back(T info)
Definition: autodeletedeque.h:69
V2Program::Cast
QObject Cast
Definition: v2programAndChannel.h:150
ChannelInfo::m_serviceId
uint m_serviceId
Definition: channelinfo.h:111
ProgramInfo
Holds information on recordings and videos.
Definition: programinfo.h:67
channelgroup.h
RecordingRule::m_recordID
int m_recordID
Unique Recording Rule ID.
Definition: recordingrule.h:70
ProgramInfo::GetAudioPropertyNames
QString GetAudioPropertyNames(void) const
Definition: programinfo.cpp:1514
ProgramInfo::QueryKeyFramePosition
bool QueryKeyFramePosition(uint64_t *position, uint64_t keyframe, bool backwards) const
Definition: programinfo.cpp:4199
MusicMetadata::Hostname
QString Hostname(void)
Definition: musicmetadata.h:230
ProgramInfo::GetLastModifiedTime
QDateTime GetLastModifiedTime(void) const
Definition: programinfo.h:429
mythscheduler.h
V2CastMember
Definition: v2castMember.h:19
ProgramInfo::GetSeason
uint GetSeason(void) const
Definition: programinfo.h:366
cardutil.h
v2frontend.h
RecordingRule::m_dupMethod
RecordingDupMethodType m_dupMethod
Definition: recordingrule.h:113
ProgramInfo::GetCategoryTypeString
QString GetCategoryTypeString(void) const
Returns catType as a string.
Definition: programinfo.cpp:1887
V2FillMusicMetadataInfo
void V2FillMusicMetadataInfo(V2MusicMetadataInfo *pVideoMetadataInfo, MusicMetadata *pMetadata, bool bDetails)
Definition: v2serviceUtil.cpp:481
ChannelInfo::Load
bool Load(uint lchanid=-1)
Definition: channelinfo.cpp:131
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:887
MarkTypes
MarkTypes
Definition: programtypes.h:47
MusicMetadata::LastPlay
QDateTime LastPlay() const
Definition: musicmetadata.h:244
V2FillCutList
void V2FillCutList(V2CutList *pCutList, ProgramInfo *rInfo, int marktype)
Definition: v2serviceUtil.cpp:595
MusicMetadata::Compilation
bool Compilation() const
Definition: musicmetadata.h:252
ChannelInfo::m_sourceId
uint m_sourceId
Definition: channelinfo.h:89
CardUtil::ProbeAudioInputs
static QStringList ProbeAudioInputs(const QString &device, const QString &inputtype=QString())
Definition: cardutil.cpp:2536
RecList
std::deque< RecordingInfo * > RecList
Definition: mythscheduler.h:12
ChannelInfo::m_tvFormat
QString m_tvFormat
Definition: channelinfo.h:105
V2Program
Definition: v2programAndChannel.h:105
RecordingRule::m_autoExtend
AutoExtendType m_autoExtend
Definition: recordingrule.h:116
ChannelInfo::m_recPriority
int m_recPriority
Definition: channelinfo.h:98
tv_rec.h
kState_WatchingLiveTV
@ kState_WatchingLiveTV
Watching LiveTV is the state for when we are watching a recording and the user has control over the c...
Definition: tv.h:63
ProgramInfo::GetDuplicateCheckSource
RecordingDupInType GetDuplicateCheckSource(void) const
Where should we check for duplicates?
Definition: programinfo.h:455
MusicMetadata::PlayCount
int PlayCount() const
Definition: musicmetadata.h:248
InputInfo
Definition: inputinfo.h:14
kArtworkBanner
@ kArtworkBanner
Definition: metadataimagehelper.h:13
V2CastMemberList
Definition: v2castMemberList.h:13
ChannelInfo::m_xmltvId
QString m_xmltvId
Definition: channelinfo.h:97
V2CastMemberList::AddNewCastMember
V2CastMember * AddNewCastMember()
Definition: v2castMemberList.h:37
ArtworkMap
QMultiMap< VideoArtworkType, ArtworkInfo > ArtworkMap
Definition: metadataimagehelper.h:31
ProgramInfo::QueryCommBreakList
void QueryCommBreakList(frm_dir_map_t &frames) const
Definition: programinfo.cpp:3551
MythCoreContext::GetHostName
QString GetHostName(void)
Definition: mythcorecontext.cpp:837
ChannelInfo::m_videoFilters
QString m_videoFilters
Definition: channelinfo.h:96
Scheduler::GetAllPending
bool GetAllPending(RecList &retList, int recRuleId=0) const
Definition: scheduler.cpp:1741
MusicMetadata::Rating
int Rating() const
Definition: musicmetadata.h:239
V2GenreList
Definition: v2genreList.h:22
ProgramInfo::GetProgramID
QString GetProgramID(void) const
Definition: programinfo.h:436
ChannelInfo::GetInputIds
QList< uint > GetInputIds() const
Definition: channelinfo.h:67
RecordingRule::m_station
QString m_station
Definition: recordingrule.h:98
ProgramInfo::GetRecordingRuleID
uint GetRecordingRuleID(void) const
Definition: programinfo.h:449
fillSelectionsFromDir
uint fillSelectionsFromDir(const QDir &dir, uint minor_min, uint minor_max, const QString &card, const QRegularExpression &driver, bool allow_duplicates, V2CaptureDeviceList *pList, const QString &cardType)
Definition: v2serviceUtil.cpp:931
V2VideoMetadataInfo::Genres
QObject Genres
Definition: v2videoMetadataInfo.h:48
CardUtil::GetAllInputInfo
static QList< InputInfo > GetAllInputInfo(bool virtTuners)
Definition: cardutil.cpp:1733
RecordingRule::m_recPriority
int m_recPriority
Definition: recordingrule.h:107
CardUtil::GetDeviceInputNames
static void GetDeviceInputNames(const QString &device, const QString &inputtype, QStringList &inputs)
Definition: cardutil.cpp:2654
V2GenreList::AddNewGenre
V2Genre * AddNewGenre()
Definition: v2genreList.h:48
ProgramInfo::GetSubtitleType
uint GetSubtitleType(void) const
Definition: programinfo.h:493
RecordingRule::m_autoUserJob3
bool m_autoUserJob3
Definition: recordingrule.h:135
ChannelInfo::m_mplexId
uint m_mplexId
Definition: channelinfo.h:110
ChannelInfo::m_visible
ChannelVisibleType m_visible
Definition: channelinfo.h:106
V2FillArtworkInfoList
void V2FillArtworkInfoList(V2ArtworkInfoList *pArtworkInfoList, const QString &sInetref, uint nSeason)
Definition: v2serviceUtil.cpp:312
V2ArtworkInfo
Definition: v2artworkInfo.h:21
InputInfo::m_displayName
QString m_displayName
Definition: inputinfo.h:52
kArtworkCoverart
@ kArtworkCoverart
Definition: metadataimagehelper.h:11
kState_RecordingOnly
@ kState_RecordingOnly
Recording Only is a TVRec only state for when we are recording a program, but there is no one current...
Definition: tv.h:84
V2Input
Definition: v2input.h:20
videoutils.h
MusicMetadata::Year
int Year() const
Definition: musicmetadata.h:196
RecordingRule::m_startdate
QDate m_startdate
Definition: recordingrule.h:89
ChannelInfo::m_defaultAuthority
QString m_defaultAuthority
Definition: channelinfo.h:118
ChannelInfo::m_callSign
QString m_callSign
Definition: channelinfo.h:91
RecordingRule::m_autoMetadataLookup
bool m_autoMetadataLookup
Definition: recordingrule.h:137
V2ChannelInfo
Definition: v2programAndChannel.h:27
AutoDeleteDeque::size
size_t size(void) const
Definition: autodeletedeque.h:67
V2Cutting
Definition: v2cutting.h:19
RecordingRule::m_prefInput
int m_prefInput
Definition: recordingrule.h:108
kChannelNotVisible
@ kChannelNotVisible
Definition: channelinfo.h:24
V2jsonCastToCredits
DBCredits * V2jsonCastToCredits(const QJsonObject &cast)
Definition: v2serviceUtil.cpp:880
V2VideoMetadataInfo
Definition: v2videoMetadataInfo.h:9
InputInfo::m_name
QString m_name
input name
Definition: inputinfo.h:47
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:836
V2RecRule
Definition: v2recRule.h:12
ProgramInfo::GetSubtitle
QString GetSubtitle(void) const
Definition: programinfo.h:363
ProgramInfo::GetStars
float GetStars(void) const
Definition: programinfo.h:442