MythTV  master
recordingprofile.cpp
Go to the documentation of this file.
1 
2 #include "recordingprofile.h"
3 
4 #include "cardutil.h"
6 #include "libmythbase/mythdb.h"
8 #include "v4l2util.h"
9 #include <utility>
10 
12 {
13  QString idTag(":WHEREID");
14  QString query("id = " + idTag);
15 
16  bindings.insert(idTag, m_parent.getProfileNum());
17 
18  return query;
19 }
20 
22 {
23  protected:
25  const RecordingProfile &parentProfile,
26  const QString& name) :
27  SimpleDBStorage(_setting, "codecparams", "value"),
28  m_parent(parentProfile), m_codecName(name)
29  {
30  _setting->setName(name);
31  }
32 
33  QString GetSetClause(MSqlBindings &bindings) const override; // SimpleDBStorage
34  QString GetWhereClause(MSqlBindings &bindings) const override; // SimpleDBStorage
35 
37  QString m_codecName;
38 };
39 
41 {
42  QString profileTag(":SETPROFILE");
43  QString nameTag(":SETNAME");
44  QString valueTag(":SETVALUE");
45 
46  QString query("profile = " + profileTag + ", name = " + nameTag
47  + ", value = " + valueTag);
48 
49  bindings.insert(profileTag, m_parent.getProfileNum());
50  bindings.insert(nameTag, m_codecName);
51  bindings.insert(valueTag, m_user->GetDBValue());
52 
53  return query;
54 }
55 
57 {
58  QString profileTag(":WHEREPROFILE");
59  QString nameTag(":WHERENAME");
60 
61  QString query("profile = " + profileTag + " AND name = " + nameTag);
62 
63  bindings.insert(profileTag, m_parent.getProfileNum());
64  bindings.insert(nameTag, m_codecName);
65 
66  return query;
67 }
68 
70 {
71  public:
72  explicit AudioCodecName(const RecordingProfile &parent) :
74  new RecordingProfileStorage(this, parent, "audiocodec"))
75  {
76  setLabel(QObject::tr("Codec"));
77  setName("audiocodec");
78  }
79 };
80 
82 {
83  public:
84  explicit MP3Quality(const RecordingProfile &parent) :
85  MythUISpinBoxSetting(this, 1, 9, 1),
86  CodecParamStorage(this, parent, "mp3quality")
87  {
88  setLabel(QObject::tr("MP3 quality"));
89  setValue(7);
90  setHelpText(QObject::tr("The higher the slider number, the lower the "
91  "quality of the audio. Better quality audio (lower "
92  "numbers) requires more CPU."));
93  };
94 };
95 
97 {
98  public:
99  explicit BTTVVolume(const RecordingProfile& parent) :
100  MythUISpinBoxSetting(this, 0, 100, 1),
101  CodecParamStorage(this, parent, "volume")
102  {
103  setLabel(QObject::tr("Volume (%)"));
104  setValue(90);
105  setHelpText(QObject::tr("Recording volume of the capture card."));
106  };
107 };
108 
110 {
111  public:
112  explicit SampleRate(const RecordingProfile &parent, bool analog = true) :
113  MythUIComboBoxSetting(this), CodecParamStorage(this, parent, "samplerate")
114  {
115  setLabel(QObject::tr("Sampling rate"));
116  setHelpText(QObject::tr("Sets the audio sampling rate for your DSP. "
117  "Ensure that you choose a sampling rate appropriate "
118  "for your device. btaudio may only allow 32000."));
119 
120  m_rates.push_back(32000);
121  m_rates.push_back(44100);
122  m_rates.push_back(48000);
123 
124  m_allowedRate[48000] = true;
125  for (uint i = 0; analog && (i < m_rates.size()); i++)
126  m_allowedRate[m_rates[i]] = true;
127 
128  };
129 
130  void Load(void) override // StandardSetting
131  {
133  QString val = getValue();
134 
135  clearSelections();
136  for (uint rate : m_rates)
137  {
138  if (m_allowedRate[rate])
139  addSelection(QString::number(rate));
140  }
141 
142  int which = getValueIndex(val);
143  setValue(std::max(which,0));
144 
145  if (m_allowedRate.size() <= 1)
146  setEnabled(false);
147  }
148 
149  void addSelection(const QString &label,
150  const QString& value = QString(),
151  bool select = false)
152  {
153  QString val = value.isEmpty() ? label : value;
154  uint rate = val.toUInt();
155  if (m_allowedRate[rate])
156  {
157  MythUIComboBoxSetting::addSelection(label, value, select);
158  }
159  else
160  {
161  LOG(VB_GENERAL, LOG_ERR, QString("SampleRate: ") +
162  QString("Attempted to add a rate %1 Hz, which is "
163  "not in the list of allowed rates.").arg(rate));
164  }
165  }
166 
167  std::vector<uint> m_rates;
168  QMap<uint,bool> m_allowedRate;
169 };
170 
172 {
173  public:
175  bool layer1, bool layer2, bool layer3) :
176  MythUIComboBoxSetting(this), CodecParamStorage(this, parent, "mpeg2audtype"),
177  m_allowLayer1(layer1), m_allowLayer2(layer2), m_allowLayer3(layer3)
178  {
179  setLabel(QObject::tr("Type"));
180 
181  if (m_allowLayer1)
182  addSelection("Layer I");
183  if (m_allowLayer2)
184  addSelection("Layer II");
185  if (m_allowLayer3)
186  addSelection("Layer III");
187 
188  uint allowed_cnt = 0;
189  allowed_cnt += ((m_allowLayer1) ? 1 : 0);
190  allowed_cnt += ((m_allowLayer2) ? 1 : 0);
191  allowed_cnt += ((m_allowLayer3) ? 1 : 0);
192 
193  if (1 == allowed_cnt)
194  setEnabled(false);
195 
196  setHelpText(QObject::tr("Sets the audio type"));
197  }
198 
199  void Load(void) override // StandardSetting
200  {
202  QString val = getValue();
203 
204  if ((val == "Layer I") && !m_allowLayer1)
205  {
206  val = (m_allowLayer2) ? "Layer II" :
207  ((m_allowLayer3) ? "Layer III" : val);
208  }
209 
210  if ((val == "Layer II") && !m_allowLayer2)
211  {
212  val = (m_allowLayer3) ? "Layer III" :
213  ((m_allowLayer1) ? "Layer I" : val);
214  }
215 
216  if ((val == "Layer III") && !m_allowLayer3)
217  {
218  val = (m_allowLayer2) ? "Layer II" :
219  ((m_allowLayer1) ? "Layer I" : val);
220  }
221 
222  if (getValue() != val)
223  {
224  int which = getValueIndex(val);
225  if (which >= 0)
226  setValue(which);
227  }
228  }
229 
230  private:
234 };
235 
237 {
238  public:
239  explicit MPEG2audBitrateL1(const RecordingProfile &parent) :
240  MythUIComboBoxSetting(this),
241  CodecParamStorage(this, parent, "mpeg2audbitratel1")
242  {
243  setLabel(QObject::tr("Bitrate"));
244 
245  addSelection("32 kbps", "32");
246  addSelection("64 kbps", "64");
247  addSelection("96 kbps", "96");
248  addSelection("128 kbps", "128");
249  addSelection("160 kbps", "160");
250  addSelection("192 kbps", "192");
251  addSelection("224 kbps", "224");
252  addSelection("256 kbps", "256");
253  addSelection("288 kbps", "288");
254  addSelection("320 kbps", "320");
255  addSelection("352 kbps", "352");
256  addSelection("384 kbps", "384");
257  addSelection("416 kbps", "416");
258  addSelection("448 kbps", "448");
259  setValue(13);
260  setHelpText(QObject::tr("Sets the audio bitrate"));
261  };
262 };
263 
265 {
266  public:
267  explicit MPEG2audBitrateL2(const RecordingProfile &parent) :
268  MythUIComboBoxSetting(this),
269  CodecParamStorage(this, parent, "mpeg2audbitratel2")
270  {
271  setLabel(QObject::tr("Bitrate"));
272 
273  addSelection("32 kbps", "32");
274  addSelection("48 kbps", "48");
275  addSelection("56 kbps", "56");
276  addSelection("64 kbps", "64");
277  addSelection("80 kbps", "80");
278  addSelection("96 kbps", "96");
279  addSelection("112 kbps", "112");
280  addSelection("128 kbps", "128");
281  addSelection("160 kbps", "160");
282  addSelection("192 kbps", "192");
283  addSelection("224 kbps", "224");
284  addSelection("256 kbps", "256");
285  addSelection("320 kbps", "320");
286  addSelection("384 kbps", "384");
287  setValue(13);
288  setHelpText(QObject::tr("Sets the audio bitrate"));
289  };
290 };
291 
293 {
294  public:
295  explicit MPEG2audBitrateL3(const RecordingProfile &parent) :
296  MythUIComboBoxSetting(this),
297  CodecParamStorage(this, parent, "mpeg2audbitratel3")
298  {
299  setLabel(QObject::tr("Bitrate"));
300 
301  addSelection("32 kbps", "32");
302  addSelection("40 kbps", "40");
303  addSelection("48 kbps", "48");
304  addSelection("56 kbps", "56");
305  addSelection("64 kbps", "64");
306  addSelection("80 kbps", "80");
307  addSelection("96 kbps", "96");
308  addSelection("112 kbps", "112");
309  addSelection("128 kbps", "128");
310  addSelection("160 kbps", "160");
311  addSelection("192 kbps", "192");
312  addSelection("224 kbps", "224");
313  addSelection("256 kbps", "256");
314  addSelection("320 kbps", "320");
315  setValue(10);
316  setHelpText(QObject::tr("Sets the audio bitrate"));
317  };
318 };
319 
321 {
322  public:
323  explicit MPEG2audVolume(const RecordingProfile &parent) :
324  MythUISpinBoxSetting(this, 0, 100, 1),
325  CodecParamStorage(this, parent, "mpeg2audvolume")
326  {
327 
328  setLabel(QObject::tr("Volume (%)"));
329  setValue(90);
330  setHelpText(QObject::tr("Volume of the recording "));
331  };
332 };
333 
335 {
336  public:
338  bool layer1, bool layer2, bool layer3,
339  uint default_layer)
340  {
341  const std::array<const QString,3> layers { "Layer I", "Layer II", "Layer III", };
342 
343  setLabel(QObject::tr("Bitrate Settings"));
344 
345  auto *audType = new MPEG2audType(parent, layer1, layer2, layer3);
346 
347  addChild(audType);
348 
349  addTargetedChild(layers[0], new MPEG2audBitrateL1(parent));
350  addTargetedChild(layers[1], new MPEG2audBitrateL2(parent));
351  addTargetedChild(layers[2], new MPEG2audBitrateL3(parent));
352 
353  uint desired_layer = std::max(std::min(3U, default_layer), 1U) - 1;
354  int which = audType->getValueIndex(layers[desired_layer]);
355  if (which >= 0)
356  audType->setValue(which);
357  };
358 };
359 
361 {
362  public:
363  explicit MPEG2Language(const RecordingProfile &parent) :
364  MythUIComboBoxSetting(this), CodecParamStorage(this, parent, "mpeg2language")
365  {
366  setLabel(QObject::tr("SAP/Bilingual"));
367 
368  addSelection(QObject::tr("Main Language"), "0");
369  addSelection(QObject::tr("SAP Language"), "1");
370  addSelection(QObject::tr("Dual"), "2");
371 
372  setValue(0);
373  setHelpText(QObject::tr(
374  "Chooses the language(s) to record when "
375  "two languages are broadcast. Only Layer II "
376  "supports the recording of two languages (Dual)."
377  "Requires ivtv 0.4.0 or later."));
378  };
379 };
380 
382 {
383  public:
384  explicit BitrateMode(const RecordingProfile& parent,
385  const QString& setting = "mpeg2bitratemode") :
386  MythUIComboBoxSetting(this),
387  CodecParamStorage(this, parent, setting)
388  {
389  setLabel(QObject::tr("Bitrate Mode"));
390 
391  addSelection("Variable Bitrate", "0");
392  addSelection("Constant Bitrate", "1");
393  setValue(0);
394  setHelpText(QObject::tr("Bitrate mode"));
395  }
396 };
397 
399 {
400  public:
402  [[maybe_unused]] V4L2util* v4l2) :
403  m_parent(parentProfile)
404  {
405  setName(QObject::tr("Audio Quality"));
406 
409 
410  QString label("MP3");
414 
415  label = "MPEG-2 Hardware Encoder";
416  m_codecName->addTargetedChild(label, new SampleRate(m_parent, false));
419  (m_parent, false, true, false, 2));
422 
423  label = "Uncompressed";
426 
427  m_codecName->addTargetedChild("AC3 Hardware Encoder",
428  new GroupSetting());
429 
430  m_codecName->addTargetedChild("AAC Hardware Encoder",
431  new GroupSetting());
432 
433 #ifdef USING_V4L2
434  if (v4l2)
435  {
436  // Dynamically create user options based on the
437  // capabilties the driver reports.
438 
440 
441  if (v4l2->GetOptions(options))
442  {
443  /* StandardSetting cannot handle multiple 'targets' pointing
444  * to the same setting configuration, so we need to do
445  * this in two passes. */
446 
447  for (const auto & option : qAsConst(options))
448  {
449  if (option.m_category == DriverOption::AUDIO_ENCODING)
450  {
451  for (const auto & Imenu : qAsConst(option.m_menu))
452  {
453  if (!Imenu.isEmpty())
454  m_v4l2codecs << "V4L2:" + Imenu;
455  }
456  }
457  }
458 
459  for (auto Icodec = m_v4l2codecs.begin(); Icodec < m_v4l2codecs.end(); ++Icodec)
460  {
461  for (const auto & option : qAsConst(options))
462  {
463  if (option.m_category == DriverOption::AUDIO_BITRATE_MODE)
464  {
465  m_codecName->addTargetedChild(*Icodec,
466  new BitrateMode(m_parent, "audbitratemode"));
467  }
468  else if (option.m_category ==
470  {
471  m_codecName->addTargetedChild(*Icodec,
472  new SampleRate(m_parent, false));
473  }
474  else if (option.m_category ==
476  {
477  m_codecName->addTargetedChild(*Icodec,
478  new MPEG2Language(m_parent));
479  }
480  else if (option.m_category == DriverOption::AUDIO_BITRATE)
481  {
482  bool layer1 = false;
483  bool layer2 = false;
484  bool layer3 = false;
485 
486  for (const auto & Imenu : qAsConst(option.m_menu))
487  {
488  if (Imenu.indexOf("Layer III") >= 0)
489  layer3 = true;
490  else if (Imenu.indexOf("Layer II") >= 0)
491  layer2 = true;
492  else if (Imenu.indexOf("Layer I") >= 0)
493  layer1 = true;
494  }
495 
496  if (layer1 || layer2 || layer3)
497  {
498  m_codecName->addTargetedChild(*Icodec,
500  layer1,
501  layer2,
502  layer3, 2));
503  }
504  }
505  else if (option.m_category == DriverOption::VOLUME)
506  {
507  m_codecName->addTargetedChild(*Icodec,
508  new MPEG2audVolume(m_parent));
509  }
510  }
511  }
512  }
513  }
514 #endif // USING_V4L2
515  }
516 
517  void selectCodecs(const QString & groupType)
518  {
519  if (!groupType.isNull())
520  {
521  if (groupType == "MPEG")
522  m_codecName->addSelection("MPEG-2 Hardware Encoder");
523  else if (groupType == "HDPVR")
524  {
525  m_codecName->addSelection("AC3 Hardware Encoder");
526  m_codecName->addSelection("AAC Hardware Encoder");
527  }
528  else if (groupType.startsWith("V4L2:"))
529  {
530  for (const auto & codec : qAsConst(m_v4l2codecs))
531  m_codecName->addSelection(codec);
532  }
533  else
534  {
535  // V4L, TRANSCODE (and any undefined types)
536  m_codecName->addSelection("MP3");
537  m_codecName->addSelection("Uncompressed");
538  }
539  }
540  else
541  {
542  m_codecName->addSelection("MP3");
543  m_codecName->addSelection("Uncompressed");
544  m_codecName->addSelection("MPEG-2 Hardware Encoder");
545  }
546  }
547 private:
550  QStringList m_v4l2codecs;
551 };
552 
554 {
555  public:
556  explicit VideoCodecName(const RecordingProfile &parent) :
558  new RecordingProfileStorage(this, parent, "videocodec"))
559  {
560  setLabel(QObject::tr("Codec"));
561  setName("videocodec");
562  }
563 };
564 
566 {
567  public:
568  explicit RTjpegQuality(const RecordingProfile &parent) :
569  MythUISpinBoxSetting(this, 1, 255, 1),
570  CodecParamStorage(this, parent, "rtjpegquality")
571  {
572  setLabel(QObject::tr("RTjpeg Quality"));
573  setValue(170);
574  setHelpText(QObject::tr("Higher is better quality."));
575  };
576 };
577 
579 {
580  public:
581  explicit RTjpegLumaFilter(const RecordingProfile &parent) :
582  MythUISpinBoxSetting(this, 0, 31, 1),
583  CodecParamStorage(this, parent, "rtjpeglumafilter")
584  {
585  setLabel(QObject::tr("Luma filter"));
586  setValue(0);
587  setHelpText(QObject::tr("Lower is better."));
588  };
589 };
590 
592 {
593  public:
594  explicit RTjpegChromaFilter(const RecordingProfile &parent) :
595  MythUISpinBoxSetting(this, 0, 31, 1),
596  CodecParamStorage(this, parent, "rtjpegchromafilter")
597  {
598  setLabel(QObject::tr("Chroma filter"));
599  setValue(0);
600  setHelpText(QObject::tr("Lower is better."));
601  };
602 };
603 
605 {
606  public:
607  explicit MPEG4bitrate(const RecordingProfile &parent) :
608  MythUISpinBoxSetting(this, 100, 8000, 100),
609  CodecParamStorage(this, parent, "mpeg4bitrate")
610  {
611  setLabel(QObject::tr("Bitrate (kb/s)"));
612  setValue(2200);
613  setHelpText(QObject::tr("Bitrate in kilobits/second. As a guide, "
614  "2200 kb/s is approximately 1 GB/hr."));
615  };
616 };
617 
619 {
620  public:
621  explicit ScaleBitrate(const RecordingProfile &parent) :
622  MythUICheckBoxSetting(this),
623  CodecParamStorage(this, parent, "scalebitrate")
624  {
625  setLabel(QObject::tr("Scale bitrate for frame size"));
626  setValue(true);
627  setHelpText(QObject::tr("If set, the bitrate specified will be used "
628  "for 640x480. If other resolutions are used, the "
629  "bitrate will be scaled appropriately."));
630  };
631 };
632 
634 {
635  public:
636  explicit MPEG4MinQuality(const RecordingProfile &parent) :
637  MythUISpinBoxSetting(this, 1, 31, 1),
638  CodecParamStorage(this, parent, "mpeg4minquality")
639  {
640  setLabel(QObject::tr("Minimum quality"));
641  setValue(15);
642  setHelpText(QObject::tr("Modifying the default may have severe "
643  "consequences."));
644  };
645 };
646 
648 {
649  public:
650  explicit MPEG4MaxQuality(const RecordingProfile &parent) :
651  MythUISpinBoxSetting(this, 1, 31, 1),
652  CodecParamStorage(this, parent, "mpeg4maxquality")
653  {
654  setLabel(QObject::tr("Maximum quality"));
655  setValue(2);
656  setHelpText(QObject::tr("Modifying the default may have severe "
657  "consequences."));
658  };
659 };
660 
662 {
663  public:
664  explicit MPEG4QualDiff(const RecordingProfile &parent) :
665  MythUISpinBoxSetting(this, 1, 31, 1),
666  CodecParamStorage(this, parent, "mpeg4qualdiff")
667  {
668 
669  setLabel(QObject::tr("Max quality difference between frames"));
670  setValue(3);
671  setHelpText(QObject::tr("Modifying the default may have severe "
672  "consequences."));
673  };
674 };
675 
677 {
678  public:
679  explicit MPEG4OptionIDCT(const RecordingProfile &parent) :
680  MythUICheckBoxSetting(this),
681  CodecParamStorage(this, parent, "mpeg4optionidct")
682  {
683  setLabel(QObject::tr("Enable interlaced DCT encoding"));
684  setValue(false);
685  setHelpText(QObject::tr("If set, the MPEG4 encoder will use "
686  "interlaced DCT encoding. You may want this when encoding "
687  "interlaced video; however, this is experimental and may "
688  "cause damaged video."));
689  };
690 };
691 
693 {
694  public:
695  explicit MPEG4OptionIME(const RecordingProfile &parent) :
696  MythUICheckBoxSetting(this),
697  CodecParamStorage(this, parent, "mpeg4optionime")
698  {
699  setLabel(QObject::tr("Enable interlaced motion estimation"));
700  setValue(false);
701  setHelpText(QObject::tr("If set, the MPEG4 encoder will use "
702  "interlaced motion estimation. You may want this when "
703  "encoding interlaced video; however, this is experimental "
704  "and may cause damaged video."));
705  };
706 };
707 
709 {
710  public:
711  explicit MPEG4OptionVHQ(const RecordingProfile &parent) :
712  MythUICheckBoxSetting(this),
713  CodecParamStorage(this, parent, "mpeg4optionvhq")
714  {
715  setLabel(QObject::tr("Enable high-quality encoding"));
716  setValue(false);
717  setHelpText(QObject::tr("If set, the MPEG4 encoder will use "
718  "'high-quality' encoding options. This requires much "
719  "more processing, but can result in better video."));
720  };
721 };
722 
724 {
725  public:
726  explicit MPEG4Option4MV(const RecordingProfile &parent) :
727  MythUICheckBoxSetting(this),
728  CodecParamStorage(this, parent, "mpeg4option4mv")
729  {
730  setLabel(QObject::tr("Enable 4MV encoding"));
731  setValue(false);
732  setHelpText(QObject::tr("If set, the MPEG4 encoder will use '4MV' "
733  "motion-vector encoding. This requires "
734  "much more processing, but can result in better "
735  "video. It is highly recommended that the HQ option is "
736  "enabled if 4MV is enabled."));
737  };
738 };
739 
741 {
742  public:
743  explicit EncodingThreadCount(const RecordingProfile &parent) :
744  MythUISpinBoxSetting(this, 1, 8, 1),
745  CodecParamStorage(this, parent, "encodingthreadcount")
746  {
747 
748  setLabel(QObject::tr("Number of threads"));
749  setValue(1);
750  setHelpText(
751  QObject::tr("Threads to use for software encoding.") + " " +
752  QObject::tr("Set to a value less than or equal to the "
753  "number of processors on the backend that "
754  "will be doing the encoding."));
755  };
756 };
757 
759 {
760  public:
761  explicit AverageBitrate(const RecordingProfile &parent,
762  const QString& setting = "mpeg2bitrate",
763  uint min_br = 1000, uint max_br = 16000,
764  uint default_br = 4500, uint increment = 100,
765  QString label = QString()) :
766  MythUISpinBoxSetting(this, min_br, max_br, increment),
767  CodecParamStorage(this, parent, setting)
768  {
769  if (label.isEmpty())
770  label = QObject::tr("Avg. Bitrate (kb/s)");
771  setLabel(label);
772  setValue(default_br);
773  setHelpText(QObject::tr(
774  "Average bitrate in kilobits/second. As a guide, "
775  "2200 kb/s is approximately 1 GB/hour."));
776  };
777 };
778 
780 {
781  public:
782  explicit PeakBitrate(const RecordingProfile &parent,
783  const QString& setting = "mpeg2maxbitrate",
784  uint min_br = 1000, uint max_br = 16000,
785  uint default_br = 6000, uint increment = 100,
786  QString label = QString()) :
787  MythUISpinBoxSetting(this, min_br, max_br, increment),
788  CodecParamStorage(this, parent, setting)
789  {
790  if (label.isEmpty())
791  label = QObject::tr("Max. Bitrate (kb/s)");
792  setLabel(label);
793  setValue(default_br);
794  setHelpText(QObject::tr("Maximum bitrate in kilobits/second. "
795  "As a guide, 2200 kb/s is approximately 1 GB/hour."));
796  };
797 };
798 
800 {
801  public:
802  explicit MPEG2streamType(const RecordingProfile &parent,
803  uint minopt = 0, uint maxopt = 8, uint defopt = 0) :
804  MythUIComboBoxSetting(this),
805  CodecParamStorage(this, parent, "mpeg2streamtype")
806  {
807  if (maxopt > 8) maxopt = 8;
808 
809  setLabel(QObject::tr("Stream Type"));
810 
811  const std::array<const QString,9> options { "MPEG-2 PS", "MPEG-2 TS",
812  "MPEG-1 VCD", "PES AV",
813  "PES V", "PES A",
814  "DVD", "DVD-Special 1", "DVD-Special 2" };
815 
816  for (uint idx = minopt; idx <= maxopt; ++idx)
817  addSelection(options[idx]);
818 
819  setValue(defopt - minopt);
820  setHelpText(QObject::tr("Sets the type of stream generated by "
821  "your PVR."));
822  };
823 };
824 
826 {
827  public:
828  explicit MPEG2aspectRatio(const RecordingProfile &parent,
829  uint minopt = 0, uint maxopt = 8, uint defopt = 0) :
830  MythUIComboBoxSetting(this),
831  CodecParamStorage(this, parent, "mpeg2aspectratio")
832  {
833  if (maxopt > 3) maxopt = 3;
834 
835  setLabel(QObject::tr("Aspect Ratio"));
836 
837  const std::array<const QString,4> options { QObject::tr("Square"), "4:3",
838  "16:9", "2.21:1" };
839 
840  for (uint idx = minopt; idx <= maxopt; ++idx)
841  addSelection(options[idx]);
842 
843  setValue(defopt);
844  setHelpText(QObject::tr("Sets the aspect ratio of stream generated "
845  "by your PVR."));
846  };
847 };
848 
850 {
851  public:
852  explicit HardwareMJPEGQuality(const RecordingProfile &parent) :
853  MythUISpinBoxSetting(this, 0, 100, 1),
854  CodecParamStorage(this, parent, "hardwaremjpegquality")
855  {
856  setLabel(QObject::tr("Quality"));
857  setValue("100");
858  };
859 };
860 
862  public CodecParamStorage
863 {
864  public:
865  explicit HardwareMJPEGHDecimation(const RecordingProfile &parent) :
866  MythUIComboBoxSetting(this),
867  CodecParamStorage(this, parent, "hardwaremjpeghdecimation")
868  {
869  setLabel(QObject::tr("Horizontal Decimation"));
870  addSelection("1");
871  addSelection("2");
872  addSelection("4");
873  setValue(2);
874  };
875 };
876 
878  public CodecParamStorage
879 {
880  public:
881  explicit HardwareMJPEGVDecimation(const RecordingProfile &parent) :
882  MythUIComboBoxSetting(this),
883  CodecParamStorage(this, parent, "hardwaremjpegvdecimation") {
884  setLabel(QObject::tr("Vertical Decimation"));
885  addSelection("1");
886  addSelection("2");
887  addSelection("4");
888  setValue(2);
889  };
890 };
891 
893 {
894  public:
896  [[maybe_unused]] V4L2util* v4l2) :
897  m_parent(parentProfile)
898  {
899  setName(QObject::tr("Video Compression"));
900 
903 
904  QString label("RTjpeg");
908 
909  label = "MPEG-4";
915 
918 
921 #ifdef USING_FFMPEG_THREADS
923 #endif
924 
925  label = "MPEG-2";
928  //m_codecName->addTargetedChild(label, new MPEG4MaxQuality(m_parent));
929  //m_codecName->addTargetedChild(label, new MPEG4MinQuality(m_parent));
930  //m_codecName->addTargetedChild(label, new MPEG4QualDiff(m_parent));
931  //m_codecName->addTargetedChild(label, new MPEG4OptionVHQ(m_parent));
932  //m_codecName->addTargetedChild(label, new MPEG4Option4MV(m_parent));
933 #ifdef USING_FFMPEG_THREADS
935 #endif
936 
937  label = "Hardware MJPEG";
941 
942  label = "MPEG-2 Hardware Encoder";
947 
948  label = "MPEG-4 AVC Hardware Encoder";
949  auto *h0 = new GroupSetting();
950  h0->setLabel(QObject::tr("Low Resolution"));
951  h0->addChild(new AverageBitrate(m_parent, "low_mpeg4avgbitrate",
952  1000, 13500, 4500, 500));
953  h0->addChild(new PeakBitrate(m_parent, "low_mpeg4peakbitrate",
954  1100, 20200, 6000, 500));
955  m_codecName->addTargetedChild(label, h0);
956 
957  auto *h1 = new GroupSetting();
958  h1->setLabel(QObject::tr("Medium Resolution"));
959  h1->addChild(new AverageBitrate(m_parent, "medium_mpeg4avgbitrate",
960  1000, 13500, 9000, 500));
961  h1->addChild(new PeakBitrate(m_parent, "medium_mpeg4peakbitrate",
962  1100, 20200, 11000, 500));
963  m_codecName->addTargetedChild(label, h1);
964 
965  auto *h2 = new GroupSetting();
966  h2->setLabel(QObject::tr("High Resolution"));
967  h2->addChild(new AverageBitrate(m_parent, "high_mpeg4avgbitrate",
968  1000, 13500, 13500, 500));
969  h2->addChild(new PeakBitrate(m_parent, "high_mpeg4peakbitrate",
970  1100, 20200, 20200, 500));
971  m_codecName->addTargetedChild(label, h2);
972 
973 #ifdef USING_V4L2
974  if (v4l2)
975  {
977 
978  if (v4l2->GetOptions(options))
979  {
980  /* StandardSetting cannot handle multiple 'targets' pointing
981  * to the same setting configuration, so we need to do
982  * this in two passes. */
983 
984  for (const auto & option : qAsConst(options))
985  {
986  if (option.m_category == DriverOption::VIDEO_ENCODING)
987  {
988  for (const auto & Imenu : qAsConst(option.m_menu))
989  {
990  if (!Imenu.isEmpty())
991  m_v4l2codecs << "V4L2:" + Imenu;
992  }
993  }
994  }
995 
996  for (auto Icodec = m_v4l2codecs.begin(); Icodec < m_v4l2codecs.end(); ++Icodec)
997  {
998  auto* bit_low = new GroupSetting();
999  auto* bit_medium = new GroupSetting();
1000  auto* bit_high = new GroupSetting();
1001  bool dynamic_res = !v4l2->UserAdjustableResolution();
1002 
1003  for (auto & option : options)
1004  {
1005  if (option.m_category == DriverOption::STREAM_TYPE)
1006  {
1007  m_codecName->addTargetedChild(*Icodec,
1009  option.m_minimum,
1010  option.m_maximum,
1011  option.m_defaultValue));
1012  }
1013  else if (option.m_category == DriverOption::VIDEO_ASPECT)
1014  {
1015  m_codecName->addTargetedChild(*Icodec,
1017  option.m_minimum,
1018  option.m_maximum,
1019  option.m_defaultValue));
1020  }
1021  else if (option.m_category ==
1023  {
1024  if (dynamic_res)
1025  {
1026  bit_low->addChild(new BitrateMode(m_parent,
1027  "low_mpegbitratemode"));
1028  bit_medium->addChild(new BitrateMode(m_parent,
1029  "medium_mpegbitratemode"));
1030  bit_high->addChild(new BitrateMode(m_parent,
1031  "medium_mpegbitratemode"));
1032  }
1033  else
1034  bit_low->addChild(new BitrateMode(m_parent));
1035  }
1036  else if (option.m_category == DriverOption::VIDEO_BITRATE)
1037  {
1038  if (dynamic_res)
1039  {
1040  bit_low->setLabel(QObject::tr("Low Resolution"));
1041  bit_low->addChild(new AverageBitrate(m_parent,
1042  "low_mpegavgbitrate",
1043  option.m_minimum / 1000,
1044  option.m_maximum / 1000,
1045  option.m_defaultValue / 1000,
1046  option.m_step / 1000));
1047 
1048  bit_medium->setLabel(QObject::
1049  tr("Medium Resolution"));
1050  bit_medium->addChild(new AverageBitrate(m_parent,
1051  "medium_mpegavgbitrate",
1052  option.m_minimum / 1000,
1053  option.m_maximum / 1000,
1054  option.m_defaultValue / 1000,
1055  option.m_step / 1000));
1056 
1057  bit_high->setLabel(QObject::
1058  tr("High Resolution"));
1059  bit_high->addChild(new AverageBitrate(m_parent,
1060  "high_mpegavgbitrate",
1061  option.m_minimum / 1000,
1062  option.m_maximum / 1000,
1063  option.m_defaultValue / 1000,
1064  option.m_step / 1000));
1065  }
1066  else
1067  {
1068  bit_low->setLabel(QObject::tr("Bitrate"));
1069  bit_low->addChild(new AverageBitrate(m_parent,
1070  "mpeg2bitrate",
1071  option.m_minimum / 1000,
1072  option.m_maximum / 1000,
1073  option.m_defaultValue / 1000,
1074  option.m_step / 1000));
1075  }
1076  }
1077  else if (option.m_category ==
1079  {
1080  if (dynamic_res)
1081  {
1082  bit_low->addChild(new PeakBitrate(m_parent,
1083  "low_mpegpeakbitrate",
1084  option.m_minimum / 1000,
1085  option.m_maximum / 1000,
1086  option.m_defaultValue / 1000,
1087  option.m_step / 1000));
1088  bit_medium->addChild(new PeakBitrate(m_parent,
1089  "medium_mpegpeakbitrate",
1090  option.m_minimum / 1000,
1091  option.m_maximum / 1000,
1092  option.m_defaultValue / 1000,
1093  option.m_step / 1000));
1094  bit_high->addChild(new PeakBitrate(m_parent,
1095  "high_mpegpeakbitrate",
1096  option.m_minimum / 1000,
1097  option.m_maximum / 1000,
1098  option.m_defaultValue / 1000,
1099  option.m_step / 1000));
1100  }
1101  else
1102  {
1103  bit_low->addChild(new PeakBitrate(m_parent,
1104  "mpeg2maxbitrate",
1105  option.m_minimum / 1000,
1106  option.m_maximum / 1000,
1107  option.m_defaultValue / 1000,
1108  option.m_step / 1000));
1109  }
1110  }
1111  }
1112 
1113  m_codecName->addTargetedChild(*Icodec, bit_low);
1114  if (dynamic_res)
1115  {
1116  m_codecName->addTargetedChild(*Icodec, bit_medium);
1117  m_codecName->addTargetedChild(*Icodec, bit_high);
1118  }
1119  else
1120  {
1121  // These are only referenced when dynamic_res is true.
1122  delete bit_medium;
1123  delete bit_high;
1124  }
1125  }
1126  }
1127  }
1128 #endif // USING_V4L2
1129  }
1130 
1131  void selectCodecs(const QString& groupType)
1132  {
1133  if (!groupType.isNull())
1134  {
1135  if (groupType == "HDPVR")
1136  m_codecName->addSelection("MPEG-4 AVC Hardware Encoder");
1137  else if (groupType.startsWith("V4L2:"))
1138  {
1139  for (const auto & codec : qAsConst(m_v4l2codecs))
1140  m_codecName->addSelection(codec);
1141  }
1142  else if (groupType == "MPEG")
1143  m_codecName->addSelection("MPEG-2 Hardware Encoder");
1144  else if (groupType == "MJPEG")
1145  m_codecName->addSelection("Hardware MJPEG");
1146  else if (groupType == "GO7007")
1147  {
1148  m_codecName->addSelection("MPEG-4");
1149  m_codecName->addSelection("MPEG-2");
1150  }
1151  else
1152  {
1153  // V4L, TRANSCODE (and any undefined types)
1154  m_codecName->addSelection("RTjpeg");
1155  m_codecName->addSelection("MPEG-4");
1156  }
1157  }
1158  else
1159  {
1160  m_codecName->addSelection("RTjpeg");
1161  m_codecName->addSelection("MPEG-4");
1162  m_codecName->addSelection("Hardware MJPEG");
1163  m_codecName->addSelection("MPEG-2 Hardware Encoder");
1164  }
1165  }
1166 
1167 private:
1170  QStringList m_v4l2codecs;
1171 };
1172 
1174 {
1175  public:
1176  explicit AutoTranscode(const RecordingProfile &parent) :
1177  MythUICheckBoxSetting(this),
1178  CodecParamStorage(this, parent, "autotranscode")
1179  {
1180  setLabel(QObject::tr("Enable auto-transcode after recording"));
1181  setValue(false);
1182  setHelpText(QObject::tr("Automatically transcode when a recording is "
1183  "made using this profile and the recording's "
1184  "schedule is configured to allow transcoding."));
1185  };
1186 };
1187 
1189 {
1190  public:
1191  explicit TranscodeResize(const RecordingProfile &parent) :
1192  MythUICheckBoxSetting(this),
1193  CodecParamStorage(this, parent, "transcoderesize")
1194  {
1195  setLabel(QObject::tr("Resize video while transcoding"));
1196  setValue(false);
1197  setHelpText(QObject::tr("Allows the transcoder to "
1198  "resize the video during transcoding."));
1199  };
1200 };
1201 
1203 {
1204  public:
1205  explicit TranscodeLossless(const RecordingProfile &parent) :
1206  MythUICheckBoxSetting(this),
1207  CodecParamStorage(this, parent, "transcodelossless")
1208  {
1209  setLabel(QObject::tr("Lossless transcoding"));
1210  setValue(false);
1211  setHelpText(QObject::tr("Only reencode where absolutely needed "
1212  "(normally only around cutpoints). Otherwise "
1213  "keep audio and video formats identical to "
1214  "the source. This should result in the "
1215  "highest quality, but won't save as much "
1216  "space."));
1217  };
1218 };
1219 
1221 {
1222  public:
1223  explicit RecordingTypeStream(const RecordingProfile &parent) :
1224  MythUIComboBoxSetting(this), CodecParamStorage(this, parent, "recordingtype")
1225  {
1226  setLabel(QObject::tr("Recording Type"));
1227 
1228  QString msg = QObject::tr(
1229  "This option allows you to filter out unwanted streams. "
1230  "'Normal' will record all relevant streams including "
1231  "interactive television data. 'TV Only' will record only "
1232  "audio, video and subtitle streams. ");
1233  setHelpText(msg);
1234 
1235  addSelection(QObject::tr("Normal"), "all");
1236  addSelection(QObject::tr("TV Only"), "tv");
1237  addSelection(QObject::tr("Audio Only"), "audio");
1238  setValue(0);
1239  };
1240 };
1241 
1243 {
1244  public:
1245  explicit RecordFullTSStream(const RecordingProfile &parent) :
1246  MythUIComboBoxSetting(this), CodecParamStorage(this, parent, "recordmpts")
1247  {
1248  setLabel(QObject::tr("Record Full TS?"));
1249 
1250  QString msg = QObject::tr(
1251  "If set, extra files will be created for each recording with "
1252  "the name of the recording followed by '.ts.raw'. "
1253  "These extra files represent the full contents of the transport "
1254  "stream used to generate the recording. (For debugging purposes)");
1255  setHelpText(msg);
1256 
1257  addSelection(QObject::tr("Yes"), "1");
1258  addSelection(QObject::tr("No"), "0");
1259  setValue(1);
1260  };
1261 };
1262 
1264 {
1265  public:
1266  explicit TranscodeFilters(const RecordingProfile &parent) :
1267  MythUITextEditSetting(this),
1268  CodecParamStorage(this, parent, "transcodefilters")
1269  {
1270  setLabel(QObject::tr("Custom filters"));
1271  setHelpText(QObject::tr("Filters used when transcoding with this "
1272  "profile. This value must be blank to perform "
1273  "lossless transcoding. Format: "
1274  "[[<filter>=<options>,]...]"
1275  ));
1276  };
1277 };
1278 
1279 class ImageSize : public GroupSetting
1280 {
1281  public:
1283  {
1284  public:
1285  Width(const RecordingProfile &parent,
1286  uint defaultwidth, uint maxwidth,
1287  bool transcoding = false) :
1288  MythUISpinBoxSetting(this, transcoding ? 0 : 160,
1289  maxwidth, 16, 0,
1290  transcoding ? QObject::tr("Auto") : QString()),
1291  CodecParamStorage(this, parent, "width")
1292  {
1293  setLabel(QObject::tr("Width"));
1294  setValue(defaultwidth);
1295 
1296  QString help = (transcoding) ?
1297  QObject::tr("If the width is set to 'Auto', the width "
1298  "will be calculated based on the height and "
1299  "the recording's physical aspect ratio.") :
1300  QObject::tr("Width to use for encoding. "
1301  "Note: PVR-x50 cards may produce ghosting if "
1302  "this is not set to 720 or 768 for NTSC and "
1303  "PAL, respectively.");
1304 
1305  setHelpText(help);
1306  };
1307  };
1308 
1310  {
1311  public:
1312  Height(const RecordingProfile &parent,
1313  uint defaultheight, uint maxheight,
1314  bool transcoding = false):
1315  MythUISpinBoxSetting(this, transcoding ? 0 : 160,
1316  maxheight, 16, 0,
1317  transcoding ? QObject::tr("Auto") : QString()),
1318  CodecParamStorage(this, parent, "height")
1319  {
1320  setLabel(QObject::tr("Height"));
1321  setValue(defaultheight);
1322 
1323  QString help = (transcoding) ?
1324  QObject::tr("If the height is set to 'Auto', the height "
1325  "will be calculated based on the width and "
1326  "the recording's physical aspect ratio.") :
1327  QObject::tr("Height to use for encoding. "
1328  "Note: PVR-x50 cards may produce ghosting if "
1329  "this is not set to 480 or 576 for NTSC and "
1330  "PAL, respectively.");
1331 
1332  setHelpText(help);
1333  };
1334  };
1335 
1337  const QString& tvFormat, const QString& profName)
1338  {
1339  setLabel(QObject::tr("Image size"));
1340 
1341  QSize defaultsize(768, 576);
1342  QSize maxsize(768, 576);
1343  bool transcoding = profName.startsWith("Transcoders");
1344  bool ivtv = profName.startsWith("IVTV MPEG-2 Encoders");
1345 
1346  if (transcoding)
1347  {
1348  maxsize = QSize(1920, 1088);
1349  if (tvFormat.toLower() == "ntsc" || tvFormat.toLower() == "atsc")
1350  defaultsize = QSize(480, 480);
1351  else
1352  defaultsize = QSize(480, 576);
1353  }
1354  else if (tvFormat.startsWith("ntsc", Qt::CaseInsensitive))
1355  {
1356  maxsize = QSize(720, 480);
1357  defaultsize = (ivtv) ? QSize(720, 480) : QSize(480, 480);
1358  }
1359  else if (tvFormat.toLower() == "atsc")
1360  {
1361  maxsize = QSize(1920, 1088);
1362  defaultsize = QSize(1920, 1088);
1363  }
1364  else
1365  {
1366  maxsize = QSize(768, 576);
1367  defaultsize = (ivtv) ? QSize(720, 576) : QSize(480, 576);
1368  }
1369 
1370  addChild(new Width(parent, defaultsize.width(),
1371  maxsize.width(), transcoding));
1372  addChild(new Height(parent, defaultsize.height(),
1373  maxsize.height(), transcoding));
1374  };
1375 };
1376 
1377 // id and name will be deleted by ConfigurationGroup's destructor
1378 RecordingProfile::RecordingProfile(const QString& profName)
1379  : m_id(new ID()),
1380  m_name(new Name(*this)),
1381  m_profileName(profName)
1382 {
1383  // This must be first because it is needed to load/save the other settings
1384  addChild(m_id);
1385 
1386  setLabel(profName);
1387  addChild(m_name);
1388 
1389  m_trFilters = nullptr;
1390  m_trLossless = nullptr;
1391  m_trResize = nullptr;
1392 
1393  if (!profName.isEmpty())
1394  {
1395  if (profName.startsWith("Transcoders"))
1396  {
1397  m_trFilters = new TranscodeFilters(*this);
1398  m_trLossless = new TranscodeLossless(*this);
1399  m_trResize = new TranscodeResize(*this);
1403  }
1404  else
1405  addChild(new AutoTranscode(*this));
1406  }
1407  else
1408  {
1409  m_trFilters = new TranscodeFilters(*this);
1410  m_trLossless = new TranscodeLossless(*this);
1411  m_trResize = new TranscodeResize(*this);
1415  addChild(new AutoTranscode(*this));
1416  }
1417 };
1418 
1420 {
1421 #ifdef USING_V4L2
1422  delete m_v4l2util;
1423  m_v4l2util = nullptr;
1424 #endif
1425 }
1426 
1427 void RecordingProfile::ResizeTranscode(const QString & /*val*/)
1428 {
1429  if (m_imageSize)
1431 }
1432 
1433 void RecordingProfile::SetLosslessTranscode(const QString & /*val*/)
1434 {
1435  bool lossless = m_trLossless->boolValue();
1436  bool show_size = (lossless) ? false : m_trResize->boolValue();
1437  if (m_imageSize)
1438  m_imageSize->setEnabled(show_size);
1439  m_videoSettings->setEnabled(! lossless);
1440  m_audioSettings->setEnabled(! lossless);
1441  m_trResize->setEnabled(! lossless);
1442  m_trFilters->setEnabled(! lossless);
1443 }
1444 
1445 void RecordingProfile::loadByID(int profileId)
1446 {
1447  MSqlQuery result(MSqlQuery::InitCon());
1448  result.prepare(
1449  "SELECT cardtype, profilegroups.name "
1450  "FROM profilegroups, recordingprofiles "
1451  "WHERE profilegroups.id = recordingprofiles.profilegroup AND "
1452  " recordingprofiles.id = :PROFILEID");
1453  result.bindValue(":PROFILEID", profileId);
1454 
1455  QString type;
1456  QString name;
1457  if (!result.exec())
1458  {
1459  MythDB::DBError("RecordingProfile::loadByID -- cardtype", result);
1460  }
1461  else if (result.next())
1462  {
1463  type = result.value(0).toString();
1464  name = result.value(1).toString();
1465  }
1466 
1467  CompleteLoad(profileId, type, name);
1468 }
1469 
1470 void RecordingProfile::FiltersChanged(const QString &val)
1471 {
1472  // If there are filters, we cannot do lossless transcoding
1473  if (!val.trimmed().isEmpty())
1474  {
1475  m_trLossless->setValue(false);
1476  m_trLossless->setEnabled(false);
1477  }
1478  else
1479  {
1480  m_trLossless->setEnabled(true);
1481  }
1482 }
1483 
1484 bool RecordingProfile::loadByType(const QString &name, const QString &card,
1485  [[maybe_unused]] const QString &videodev)
1486 {
1487  QString hostname = gCoreContext->GetHostName().toLower();
1488  QString cardtype = card;
1489  uint profileId = 0;
1490 
1491 #ifdef USING_V4L2
1492  if (cardtype == "V4L2ENC")
1493  {
1494  m_v4l2util = new V4L2util(videodev);
1495  if (m_v4l2util->IsOpen())
1496  cardtype = m_v4l2util->ProfileName();
1497  }
1498 #endif
1499 
1500  MSqlQuery result(MSqlQuery::InitCon());
1501  result.prepare(
1502  "SELECT recordingprofiles.id, profilegroups.hostname, "
1503  " profilegroups.is_default "
1504  "FROM recordingprofiles, profilegroups "
1505  "WHERE profilegroups.id = recordingprofiles.profilegroup AND "
1506  " profilegroups.cardtype = :CARDTYPE AND "
1507  " recordingprofiles.name = :NAME");
1508  result.bindValue(":CARDTYPE", cardtype);
1509  result.bindValue(":NAME", name);
1510 
1511  if (!result.exec())
1512  {
1513  MythDB::DBError("RecordingProfile::loadByType()", result);
1514  return false;
1515  }
1516 
1517  while (result.next())
1518  {
1519  if (result.value(1).toString().toLower() == hostname)
1520  {
1521  profileId = result.value(0).toUInt();
1522  }
1523  else if (result.value(2).toInt() == 1)
1524  {
1525  profileId = result.value(0).toUInt();
1526  break;
1527  }
1528  }
1529 
1530  if (profileId)
1531  {
1532  CompleteLoad(profileId, cardtype, name);
1533  return true;
1534  }
1535 
1536  return false;
1537 }
1538 
1539 bool RecordingProfile::loadByGroup(const QString &name, const QString &group)
1540 {
1541  MSqlQuery result(MSqlQuery::InitCon());
1542  result.prepare(
1543  "SELECT recordingprofiles.id, cardtype "
1544  "FROM recordingprofiles, profilegroups "
1545  "WHERE recordingprofiles.profilegroup = profilegroups.id AND "
1546  " profilegroups.name = :GROUPNAME AND "
1547  " recordingprofiles.name = :NAME");
1548  result.bindValue(":GROUPNAME", group);
1549  result.bindValue(":NAME", name);
1550 
1551  if (!result.exec())
1552  {
1553  MythDB::DBError("RecordingProfile::loadByGroup()", result);
1554  return false;
1555  }
1556 
1557  if (result.next())
1558  {
1559  uint profileId = result.value(0).toUInt();
1560  QString type = result.value(1).toString();
1561 
1562  CompleteLoad(profileId, type, name);
1563  return true;
1564  }
1565 
1566  return false;
1567 }
1568 
1569 void RecordingProfile::CompleteLoad(int profileId, const QString &type,
1570  const QString &name)
1571 {
1572  if (m_profileName.isEmpty())
1573  m_profileName = name;
1574 
1576 
1577  if (m_isEncoder)
1578  {
1579 #ifdef USING_V4L2
1580  if (type.startsWith("V4L2:"))
1581  {
1582  QStringList devices = CardUtil::GetVideoDevices("V4L2ENC");
1583  if (!devices.isEmpty())
1584  {
1585  for (const auto & device : qAsConst(devices))
1586  {
1587  delete m_v4l2util;
1588  m_v4l2util = new V4L2util(device);
1589  if (m_v4l2util->IsOpen() &&
1590  m_v4l2util->DriverName() == type.mid(5))
1591  break;
1592  delete m_v4l2util;
1593  m_v4l2util = nullptr;
1594  }
1595  }
1596  }
1597 #endif
1598 
1599  QString tvFormat = gCoreContext->GetSetting("TVFormat");
1600  // TODO: When mpegrecorder is removed, don't check for "HDPVR' anymore...
1601  if (type != "HDPVR" &&
1602  (!m_v4l2util
1603 #ifdef USING_V4L2
1605 #endif
1606  ))
1607  {
1608  addChild(new ImageSize(*this, tvFormat, m_profileName));
1609  }
1611  m_v4l2util);
1613 
1615  m_v4l2util);
1617 
1618  if (!m_profileName.isEmpty() && m_profileName.startsWith("Transcoders"))
1619  {
1620  connect(m_trResize, qOverload<const QString&>(&StandardSetting::valueChanged),
1622  connect(m_trLossless, qOverload<const QString&>(&StandardSetting::valueChanged),
1624  connect(m_trFilters, qOverload<const QString&>(&StandardSetting::valueChanged),
1626  }
1627  }
1628 
1629  // Cards that can receive additional streams such as EIT and MHEG
1631  {
1632  addChild(new RecordingTypeStream(*this));
1633  }
1634 
1636  {
1637  addChild(new RecordFullTSStream(*this));
1638  }
1639 
1640  m_id->setValue(profileId);
1641  Load();
1642 }
1643 
1645 {
1646  if (m_videoSettings)
1648  if (m_audioSettings)
1650 }
1651 
1653  m_group(id), m_labelName(std::move(profName))
1654 {
1655  if (!m_labelName.isEmpty())
1657 }
1658 
1660 {
1661  clearSettings();
1662  auto *newProfile = new ButtonStandardSetting(tr("(Create new profile)"));
1664  addChild(newProfile);
1667 }
1668 
1670 {
1671  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
1672  auto *settingdialog = new MythTextInputDialog(popupStack,
1673  tr("Enter the name of the new profile"));
1674 
1675  if (settingdialog->Create())
1676  {
1677  connect(settingdialog, &MythTextInputDialog::haveResult,
1679  popupStack->AddScreen(settingdialog);
1680  }
1681  else
1682  {
1683  delete settingdialog;
1684  }
1685 }
1686 
1687 void RecordingProfileEditor::CreateNewProfile(const QString& profName)
1688 {
1689  MSqlQuery query(MSqlQuery::InitCon());
1690  query.prepare(
1691  "INSERT INTO recordingprofiles "
1692  "(name, videocodec, audiocodec, profilegroup) "
1693  "VALUES "
1694  "(:NAME, :VIDEOCODEC, :AUDIOCODEC, :PROFILEGROUP);");
1695  query.bindValue(":NAME", profName);
1696  query.bindValue(":VIDEOCODEC", "MPEG-4");
1697  query.bindValue(":AUDIOCODEC", "MP3");
1698  query.bindValue(":PROFILEGROUP", m_group);
1699  if (!query.exec())
1700  {
1701  MythDB::DBError("RecordingProfileEditor::open", query);
1702  }
1703  else
1704  {
1705  query.prepare(
1706  "SELECT id "
1707  "FROM recordingprofiles "
1708  "WHERE name = :NAME AND profilegroup = :PROFILEGROUP;");
1709  query.bindValue(":NAME", profName);
1710  query.bindValue(":PROFILEGROUP", m_group);
1711  if (!query.exec())
1712  {
1713  MythDB::DBError("RecordingProfileEditor::open", query);
1714  }
1715  else
1716  {
1717  if (query.next())
1718  {
1719  auto* profile = new RecordingProfile(profName);
1720 
1721  profile->loadByID(query.value(0).toInt());
1722  profile->setCodecTypes();
1723  addChild(profile);
1724  emit settingsChanged(this);
1725  }
1726  }
1727  }
1728 }
1729 
1731  bool foldautodetect)
1732 {
1733  if (!group)
1734  {
1735  for (const auto & name : kAvailProfiles)
1736  {
1737  auto *profile = new GroupSetting();
1738  profile->setLabel(name);
1739  setting->addChild(profile);
1740  }
1741  return;
1742  }
1743 
1744  MSqlQuery result(MSqlQuery::InitCon());
1745  result.prepare(
1746  "SELECT name, id "
1747  "FROM recordingprofiles "
1748  "WHERE profilegroup = :GROUP "
1749  "ORDER BY id");
1750  result.bindValue(":GROUP", group);
1751 
1752  if (!result.exec())
1753  {
1754  MythDB::DBError("RecordingProfile::fillSelections 1", result);
1755  return;
1756  }
1757  if (!result.next())
1758  {
1759  return;
1760  }
1761 
1762  if (group == RecordingProfile::TranscoderGroup && foldautodetect)
1763  {
1764  auto *profile = new GroupSetting();
1765  profile->setLabel(QObject::tr("Autodetect"));
1766  setting->addChild(profile);
1767  }
1768 
1769  do
1770  {
1771  QString name = result.value(0).toString();
1772  QString id = result.value(1).toString();
1773 
1774  if (group == RecordingProfile::TranscoderGroup)
1775  {
1776  if (name == "RTjpeg/MPEG4" || name == "MPEG2")
1777  {
1778  if (!foldautodetect)
1779  {
1780  auto *profile =
1781  new RecordingProfile(QObject::tr("Autodetect from %1")
1782  .arg(name));
1783  profile->loadByID(id.toInt());
1784  profile->setCodecTypes();
1785  setting->addChild(profile);
1786  }
1787  }
1788  else
1789  {
1790  auto *profile = new RecordingProfile(name);
1791  profile->loadByID(id.toInt());
1792  profile->setCodecTypes();
1793  setting->addChild(profile);
1794  }
1795  continue;
1796  }
1797 
1798  auto *profile = new RecordingProfile(name);
1799  profile->loadByID(id.toInt());
1800  profile->setCodecTypes();
1801  setting->addChild(profile);
1802  }
1803  while (result.next());
1804 }
1805 
1807 {
1808  QMap<int, QString> profiles;
1809 
1810  if (!group)
1811  {
1812  for (uint i = 0; !kAvailProfiles[i].isEmpty(); i++)
1813  profiles[i] = kAvailProfiles[i];
1814  return profiles;
1815  }
1816 
1817  MSqlQuery query(MSqlQuery::InitCon());
1818  query.prepare(
1819  "SELECT name, id "
1820  "FROM recordingprofiles "
1821  "WHERE profilegroup = :GROUPID "
1822  "ORDER BY id");
1823  query.bindValue(":GROUPID", group);
1824 
1825  if (!query.exec())
1826  {
1827  MythDB::DBError("RecordingProfile::GetProfileMap()", query);
1828  return profiles;
1829  }
1830  if (!query.next())
1831  {
1832  LOG(VB_GENERAL, LOG_WARNING,
1833  "RecordingProfile::fillselections, Warning: "
1834  "Failed to locate recording id for recording group.");
1835  return profiles;
1836  }
1837 
1838  if (group == RecordingProfile::TranscoderGroup)
1839  {
1841  profiles[id] = QObject::tr("Transcode using Autodetect");
1842  }
1843 
1844  do
1845  {
1846  QString name = query.value(0).toString();
1847  int id = query.value(1).toInt();
1848 
1849  if (group == RecordingProfile::TranscoderGroup)
1850  {
1851  /* RTjpeg/MPEG4 and MPEG2 are used by "Autodetect". */
1852  if (name != "RTjpeg/MPEG4" && name != "MPEG2")
1853  {
1854  QString lbl = QObject::tr("Transcode using \"%1\"").arg(name);
1855  profiles[id] = lbl;
1856  }
1857  continue;
1858  }
1859 
1860  QString lbl = QObject::tr("Record using the \"%1\" profile").arg(name);
1861  profiles[id] = lbl;
1862  } while (query.next());
1863 
1864  return profiles;
1865 }
1866 
1868 {
1870 }
1871 
1872 QString RecordingProfile::groupType(void) const
1873 {
1874  MSqlQuery result(MSqlQuery::InitCon());
1875  result.prepare(
1876  "SELECT profilegroups.cardtype "
1877  "FROM profilegroups, recordingprofiles "
1878  "WHERE profilegroups.id = recordingprofiles.profilegroup AND "
1879  " recordingprofiles.id = :ID");
1880  result.bindValue(":ID", getProfileNum());
1881 
1882  if (!result.exec())
1883  MythDB::DBError("RecordingProfile::groupType", result);
1884  else if (result.next())
1885  return result.value(0).toString();
1886 
1887  return {};
1888 }
1889 
1891 {
1892  MSqlQuery result(MSqlQuery::InitCon());
1893  result.prepare(
1894  "SELECT name "
1895  "FROM recordingprofiles "
1896  "WHERE id = :ID");
1897 
1898  result.bindValue(":ID", id);
1899 
1900  if (!result.exec())
1901  MythDB::DBError("RecordingProfile::getName", result);
1902  else if (result.next())
1903  return result.value(0).toString();
1904 
1905  return {};
1906 }
1907 
1909 {
1910  return true;
1911 }
1912 
1914 {
1915  MSqlQuery result(MSqlQuery::InitCon());
1916  result.prepare(
1917  "DELETE "
1918  "FROM recordingprofiles "
1919  "WHERE id = :ID");
1920 
1921  result.bindValue(":ID", m_id->getValue());
1922 
1923  if (!result.exec())
1924  MythDB::DBError("RecordingProfile::deleteEntry", result);
1925 
1926 }
1927 
1928 
1929 /* vim: set expandtab tabstop=4 shiftwidth=4: */
RecordingProfile::m_isEncoder
bool m_isEncoder
Definition: recordingprofile.h:149
MPEG2audType::m_allowLayer2
bool m_allowLayer2
Definition: recordingprofile.cpp:232
ImageSize::Width
Definition: recordingprofile.cpp:1282
MSqlBindings
QMap< QString, QVariant > MSqlBindings
typedef for a map of string -> string bindings for generic queries.
Definition: mythdbcon.h:101
TranscodeLossless::TranscodeLossless
TranscodeLossless(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1205
MPEG2AudioBitrateSettings::MPEG2AudioBitrateSettings
MPEG2AudioBitrateSettings(const RecordingProfile &parent, bool layer1, bool layer2, bool layer3, uint default_layer)
Definition: recordingprofile.cpp:337
SampleRate::m_allowedRate
QMap< uint, bool > m_allowedRate
Definition: recordingprofile.cpp:168
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
HardwareMJPEGVDecimation::HardwareMJPEGVDecimation
HardwareMJPEGVDecimation(const RecordingProfile &parent)
Definition: recordingprofile.cpp:881
MythUIComboBoxSetting::clearSelections
void clearSelections()
Definition: standardsettings.cpp:514
RecordingProfile::m_profileName
QString m_profileName
Definition: recordingprofile.h:148
EncodingThreadCount
Definition: recordingprofile.cpp:740
StandardSetting::setName
virtual void setName(const QString &name)
Definition: standardsettings.cpp:253
kAvailProfiles
const std::array< QString, 4 > kAvailProfiles
Definition: recordingprofile.h:11
MPEG2audBitrateL2::MPEG2audBitrateL2
MPEG2audBitrateL2(const RecordingProfile &parent)
Definition: recordingprofile.cpp:267
RecordFullTSStream::RecordFullTSStream
RecordFullTSStream(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1245
StandardSetting::setValue
virtual void setValue(const QString &newValue)
Definition: standardsettings.cpp:170
RecordingProfile::m_audioSettings
AudioCompressionSettings * m_audioSettings
Definition: recordingprofile.h:147
MPEG2audBitrateL3::MPEG2audBitrateL3
MPEG2audBitrateL3(const RecordingProfile &parent)
Definition: recordingprofile.cpp:295
DriverOption::Options
QMap< category_t, DriverOption > Options
Definition: driveroption.h:20
mythdb.h
MPEG4MinQuality::MPEG4MinQuality
MPEG4MinQuality(const RecordingProfile &parent)
Definition: recordingprofile.cpp:636
CardUtil::GetVideoDevices
static QStringList GetVideoDevices(const QString &rawtype, QString hostname=QString())
Returns the videodevices of the matching inputs, duplicates removed.
Definition: cardutil.cpp:396
AudioCompressionSettings
Definition: recordingprofile.cpp:398
RecordingProfile::RecProfileGroup
RecProfileGroup
Definition: recordingprofile.h:107
TranscodeLossless
Definition: recordingprofile.cpp:1202
DBStorage::m_user
StorageUser * m_user
Definition: mythstorage.h:50
DriverOption::VIDEO_ENCODING
@ VIDEO_ENCODING
Definition: driveroption.h:9
TranscodeResize
Definition: recordingprofile.cpp:1188
HardwareMJPEGQuality
Definition: recordingprofile.cpp:849
V4L2util::DriverName
QString DriverName(void) const
Definition: v4l2util.h:48
VideoCompressionSettings::m_parent
const RecordingProfile & m_parent
Definition: recordingprofile.cpp:1168
AudioCodecName::AudioCodecName
AudioCodecName(const RecordingProfile &parent)
Definition: recordingprofile.cpp:72
MPEG2audType::Load
void Load(void) override
Definition: recordingprofile.cpp:199
MPEG2Language::MPEG2Language
MPEG2Language(const RecordingProfile &parent)
Definition: recordingprofile.cpp:363
ButtonStandardSetting
Definition: standardsettings.h:450
RecordingProfile::m_id
ID * m_id
Definition: recordingprofile.h:140
RecordingProfile::m_trFilters
TranscodeFilters * m_trFilters
Definition: recordingprofile.h:145
RecordingProfileEditor::ShowNewProfileDialog
void ShowNewProfileDialog() const
Definition: recordingprofile.cpp:1669
RecordingProfile::loadByGroup
virtual bool loadByGroup(const QString &name, const QString &group)
Definition: recordingprofile.cpp:1539
SampleRate::addSelection
void addSelection(const QString &label, const QString &value=QString(), bool select=false)
Definition: recordingprofile.cpp:149
PeakBitrate
Definition: recordingprofile.cpp:779
TranscodeResize::TranscodeResize
TranscodeResize(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1191
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:205
MythScreenStack
Definition: mythscreenstack.h:16
RecordingProfile::GetTranscodingProfiles
static QMap< int, QString > GetTranscodingProfiles()
Definition: recordingprofile.cpp:1867
CodecParamStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: recordingprofile.cpp:56
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:617
RecordingProfileStorage::m_parent
const RecordingProfile & m_parent
Definition: recordingprofile.h:33
AverageBitrate::AverageBitrate
AverageBitrate(const RecordingProfile &parent, const QString &setting="mpeg2bitrate", uint min_br=1000, uint max_br=16000, uint default_br=4500, uint increment=100, QString label=QString())
Definition: recordingprofile.cpp:761
MPEG4bitrate::MPEG4bitrate
MPEG4bitrate(const RecordingProfile &parent)
Definition: recordingprofile.cpp:607
StandardSetting::clearSettings
virtual void clearSettings()
Definition: standardsettings.cpp:160
RecordingProfile::loadByID
virtual void loadByID(int id)
Definition: recordingprofile.cpp:1445
StorageUser::GetDBValue
virtual QString GetDBValue(void) const =0
RecordingProfile::setCodecTypes
void setCodecTypes()
Definition: recordingprofile.cpp:1644
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:39
RecordingProfile::~RecordingProfile
~RecordingProfile(void) override
Definition: recordingprofile.cpp:1419
RecordingProfileStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: recordingprofile.cpp:11
HardwareMJPEGQuality::HardwareMJPEGQuality
HardwareMJPEGQuality(const RecordingProfile &parent)
Definition: recordingprofile.cpp:852
StandardSetting::addTargetedChild
void addTargetedChild(const QString &value, StandardSetting *setting)
Definition: standardsettings.cpp:117
RecordingProfile::getName
QString getName(void) const
Definition: recordingprofile.h:100
RecordingProfile::deleteEntry
void deleteEntry(void) override
Definition: recordingprofile.cpp:1913
SampleRate::SampleRate
SampleRate(const RecordingProfile &parent, bool analog=true)
Definition: recordingprofile.cpp:112
SampleRate
Definition: recordingprofile.cpp:109
GroupSetting::GroupSetting
GroupSetting()=default
SimpleDBStorage
Definition: mythstorage.h:55
MP3Quality
Definition: recordingprofile.cpp:81
AudioCompressionSettings::m_codecName
AudioCodecName * m_codecName
Definition: recordingprofile.cpp:549
MythTextInputDialog::haveResult
void haveResult(QString)
DriverOption::VIDEO_BITRATE_PEAK
@ VIDEO_BITRATE_PEAK
Definition: driveroption.h:11
ButtonStandardSetting::clicked
void clicked()
RecordingProfile::m_videoSettings
VideoCompressionSettings * m_videoSettings
Definition: recordingprofile.h:146
MPEG4MinQuality
Definition: recordingprofile.cpp:633
ScaleBitrate::ScaleBitrate
ScaleBitrate(const RecordingProfile &parent)
Definition: recordingprofile.cpp:621
StandardSetting::settingsChanged
void settingsChanged(StandardSetting *selectedSetting=nullptr)
StandardSetting::addChild
virtual void addChild(StandardSetting *child)
Definition: standardsettings.cpp:71
AverageBitrate
Definition: recordingprofile.cpp:758
MPEG2streamType::MPEG2streamType
MPEG2streamType(const RecordingProfile &parent, uint minopt=0, uint maxopt=8, uint defopt=0)
Definition: recordingprofile.cpp:802
BTTVVolume::BTTVVolume
BTTVVolume(const RecordingProfile &parent)
Definition: recordingprofile.cpp:99
RecordingProfile::RecordingProfile
RecordingProfile(const QString &profName=QString())
Definition: recordingprofile.cpp:1378
MPEG2audBitrateL1
Definition: recordingprofile.cpp:236
mythlogging.h
RecordingTypeStream
Definition: recordingprofile.cpp:1220
DriverOption::AUDIO_SAMPLERATE
@ AUDIO_SAMPLERATE
Definition: driveroption.h:12
MPEG2streamType
Definition: recordingprofile.cpp:799
MPEG2Language
Definition: recordingprofile.cpp:360
MPEG4bitrate
Definition: recordingprofile.cpp:604
hardwareprofile.scan.profile
profile
Definition: scan.py:99
MythUIComboBoxSetting
Definition: standardsettings.h:218
AudioCodecName
Definition: recordingprofile.cpp:69
RecordingProfile::m_v4l2util
V4L2util * m_v4l2util
Definition: recordingprofile.h:151
CardUtil::IsEncoder
static bool IsEncoder(const QString &rawtype)
Definition: cardutil.h:135
MPEG2audVolume
Definition: recordingprofile.cpp:320
V4L2util::UserAdjustableResolution
bool UserAdjustableResolution(void) const
Definition: v4l2util.cpp:707
SampleRate::m_rates
std::vector< uint > m_rates
Definition: recordingprofile.cpp:167
MPEG2audBitrateL3
Definition: recordingprofile.cpp:292
TranscodeFilters
Definition: recordingprofile.cpp:1263
RTjpegChromaFilter
Definition: recordingprofile.cpp:591
v4l2util.h
RecordingProfile::groupType
QString groupType(void) const
Definition: recordingprofile.cpp:1872
MPEG2audType::MPEG2audType
MPEG2audType(const RecordingProfile &parent, bool layer1, bool layer2, bool layer3)
Definition: recordingprofile.cpp:174
RecordingProfileEditor::m_group
int m_group
Definition: recordingprofile.h:170
MPEG4MaxQuality
Definition: recordingprofile.cpp:647
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:549
RecordingProfile::m_trLossless
TranscodeLossless * m_trLossless
Definition: recordingprofile.h:144
MythDB::DBError
static void DBError(const QString &where, const MSqlQuery &query)
Definition: mythdb.cpp:226
RecordingProfile::m_trResize
TranscodeResize * m_trResize
Definition: recordingprofile.h:143
StandardSetting::Load
virtual void Load(void)
Definition: standardsettings.cpp:214
CodecParamStorage::CodecParamStorage
CodecParamStorage(StandardSetting *_setting, const RecordingProfile &parentProfile, const QString &name)
Definition: recordingprofile.cpp:24
MPEG2AudioBitrateSettings
Definition: recordingprofile.cpp:334
VideoCompressionSettings::m_v4l2codecs
QStringList m_v4l2codecs
Definition: recordingprofile.cpp:1170
VideoCompressionSettings
Definition: recordingprofile.cpp:892
RTjpegLumaFilter
Definition: recordingprofile.cpp:578
StandardSetting::setHelpText
virtual void setHelpText(const QString &str)
Definition: standardsettings.h:37
RecordingProfileEditor::Load
void Load(void) override
Definition: recordingprofile.cpp:1659
MPEG4OptionIDCT::MPEG4OptionIDCT
MPEG4OptionIDCT(const RecordingProfile &parent)
Definition: recordingprofile.cpp:679
RecordingProfile::m_name
Name * m_name
Definition: recordingprofile.h:141
MythUIComboBoxSetting::getValueIndex
int getValueIndex(const QString &value) const
Definition: standardsettings.cpp:488
VideoCompressionSettings::VideoCompressionSettings
VideoCompressionSettings(const RecordingProfile &parentProfile, [[maybe_unused]] V4L2util *v4l2)
Definition: recordingprofile.cpp:895
RecordingProfile::kTranscoderAutodetect
static const uint kTranscoderAutodetect
sentinel value
Definition: recordingprofile.h:132
MPEG4OptionIME::MPEG4OptionIME
MPEG4OptionIME(const RecordingProfile &parent)
Definition: recordingprofile.cpp:695
SampleRate::Load
void Load(void) override
Definition: recordingprofile.cpp:130
StandardSetting::getValue
virtual QString getValue(void) const
Definition: standardsettings.h:52
AutoTranscode
Definition: recordingprofile.cpp:1173
MPEG2aspectRatio
Definition: recordingprofile.cpp:825
MPEG4OptionVHQ::MPEG4OptionVHQ
MPEG4OptionVHQ(const RecordingProfile &parent)
Definition: recordingprofile.cpp:711
RecordingProfileEditor::CreateNewProfile
void CreateNewProfile(const QString &profName)
Definition: recordingprofile.cpp:1687
TranscodeFilters::TranscodeFilters
TranscodeFilters(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1266
CodecParamStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: recordingprofile.cpp:40
uint
unsigned int uint
Definition: compat.h:81
MPEG4MaxQuality::MPEG4MaxQuality
MPEG4MaxQuality(const RecordingProfile &parent)
Definition: recordingprofile.cpp:650
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:55
MPEG2audBitrateL1::MPEG2audBitrateL1
MPEG2audBitrateL1(const RecordingProfile &parent)
Definition: recordingprofile.cpp:239
RecordingProfile::ResizeTranscode
void ResizeTranscode(const QString &val)
Definition: recordingprofile.cpp:1427
MPEG4OptionIME
Definition: recordingprofile.cpp:692
MPEG2audType
Definition: recordingprofile.cpp:171
AudioCompressionSettings::AudioCompressionSettings
AudioCompressionSettings(const RecordingProfile &parentProfile, [[maybe_unused]] V4L2util *v4l2)
Definition: recordingprofile.cpp:401
AutoTranscode::AutoTranscode
AutoTranscode(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1176
MPEG2audBitrateL2
Definition: recordingprofile.cpp:264
RTjpegLumaFilter::RTjpegLumaFilter
RTjpegLumaFilter(const RecordingProfile &parent)
Definition: recordingprofile.cpp:581
StandardSetting::setLabel
virtual void setLabel(QString str)
Definition: standardsettings.h:34
StandardSetting::valueChanged
void valueChanged(const QString &newValue)
MPEG4Option4MV
Definition: recordingprofile.cpp:723
RecordingProfile::Name
Definition: recordingprofile.h:53
RecordingProfile::getProfileNum
int getProfileNum(void) const
Definition: recordingprofile.h:99
MPEG4Option4MV::MPEG4Option4MV
MPEG4Option4MV(const RecordingProfile &parent)
Definition: recordingprofile.cpp:726
DriverOption::STREAM_TYPE
@ STREAM_TYPE
Definition: driveroption.h:9
V4L2util::IsOpen
bool IsOpen(void) const
Definition: v4l2util.h:29
StandardSetting::setEnabled
virtual void setEnabled(bool enabled)
Definition: standardsettings.cpp:48
AudioCompressionSettings::selectCodecs
void selectCodecs(const QString &groupType)
Definition: recordingprofile.cpp:517
MythUIComboBoxSetting::addSelection
void addSelection(const QString &label, QString value=QString(), bool select=false)
Definition: standardsettings.cpp:499
RecordingProfileEditor::m_labelName
QString m_labelName
Definition: recordingprofile.h:171
RecordingProfile::CompleteLoad
virtual void CompleteLoad(int profileId, const QString &type, const QString &name)
Definition: recordingprofile.cpp:1569
BTTVVolume
Definition: recordingprofile.cpp:96
MythUITextEditSetting
Definition: standardsettings.h:146
ImageSize::Width::Width
Width(const RecordingProfile &parent, uint defaultwidth, uint maxwidth, bool transcoding=false)
Definition: recordingprofile.cpp:1285
V4L2util
Definition: v4l2util.h:16
AudioCompressionSettings::m_v4l2codecs
QStringList m_v4l2codecs
Definition: recordingprofile.cpp:550
DriverOption::AUDIO_LANGUAGE
@ AUDIO_LANGUAGE
Definition: driveroption.h:13
MPEG2audVolume::MPEG2audVolume
MPEG2audVolume(const RecordingProfile &parent)
Definition: recordingprofile.cpp:323
mythcorecontext.h
cardutil.h
ImageSize
Definition: recordingprofile.cpp:1279
MPEG4OptionVHQ
Definition: recordingprofile.cpp:708
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:887
VideoCodecName::VideoCodecName
VideoCodecName(const RecordingProfile &parent)
Definition: recordingprofile.cpp:556
std
Definition: mythchrono.h:23
MPEG2aspectRatio::MPEG2aspectRatio
MPEG2aspectRatio(const RecordingProfile &parent, uint minopt=0, uint maxopt=8, uint defopt=0)
Definition: recordingprofile.cpp:828
MPEG4OptionIDCT
Definition: recordingprofile.cpp:676
VideoCodecName
Definition: recordingprofile.cpp:553
RecordingProfile::loadByType
virtual bool loadByType(const QString &name, const QString &cardtype, const QString &videodev)
Definition: recordingprofile.cpp:1484
BitrateMode
Definition: recordingprofile.cpp:381
EncodingThreadCount::EncodingThreadCount
EncodingThreadCount(const RecordingProfile &parent)
Definition: recordingprofile.cpp:743
RecordingProfile::m_imageSize
ImageSize * m_imageSize
Definition: recordingprofile.h:142
HardwareMJPEGHDecimation::HardwareMJPEGHDecimation
HardwareMJPEGHDecimation(const RecordingProfile &parent)
Definition: recordingprofile.cpp:865
VideoCompressionSettings::m_codecName
VideoCodecName * m_codecName
Definition: recordingprofile.cpp:1169
CodecParamStorage::m_codecName
QString m_codecName
Definition: recordingprofile.cpp:37
MythUISpinBoxSetting
Definition: standardsettings.h:328
VideoCompressionSettings::selectCodecs
void selectCodecs(const QString &groupType)
Definition: recordingprofile.cpp:1131
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:104
DriverOption::VIDEO_ASPECT
@ VIDEO_ASPECT
Definition: driveroption.h:9
DriverOption::AUDIO_ENCODING
@ AUDIO_ENCODING
Definition: driveroption.h:12
DriverOption::VIDEO_BITRATE_MODE
@ VIDEO_BITRATE_MODE
Definition: driveroption.h:11
CardUtil::IsTunerSharingCapable
static bool IsTunerSharingCapable(const QString &rawtype)
Definition: cardutil.h:177
build_compdb.help
help
Definition: build_compdb.py:10
MPEG4QualDiff::MPEG4QualDiff
MPEG4QualDiff(const RecordingProfile &parent)
Definition: recordingprofile.cpp:664
RecordingProfile::ID
Definition: recordingprofile.h:45
MythMainWindow::GetStack
MythScreenStack * GetStack(const QString &Stackname)
Definition: mythmainwindow.cpp:323
V4L2util::ProfileName
QString ProfileName(void) const
Definition: v4l2util.h:50
SimpleDBStorage::Load
void Load(void) override
Definition: mythstorage.cpp:9
RTjpegQuality::RTjpegQuality
RTjpegQuality(const RecordingProfile &parent)
Definition: recordingprofile.cpp:568
RecordingProfile::FiltersChanged
void FiltersChanged(const QString &val)
Definition: recordingprofile.cpp:1470
StandardSetting
Definition: standardsettings.h:29
MythCoreContext::GetHostName
QString GetHostName(void)
Definition: mythcorecontext.cpp:837
recordingprofile.h
CardUtil::IsEITCapable
static bool IsEITCapable(const QString &rawtype)
Definition: cardutil.h:170
RecordingTypeStream::RecordingTypeStream
RecordingTypeStream(const RecordingProfile &parent)
Definition: recordingprofile.cpp:1223
RecordingProfile::GetProfiles
static QMap< int, QString > GetProfiles(RecProfileGroup group=AllGroups)
Definition: recordingprofile.cpp:1806
RecordingProfile
Definition: recordingprofile.h:41
musicbrainzngs.caa.hostname
string hostname
Definition: caa.py:17
HardwareMJPEGVDecimation
Definition: recordingprofile.cpp:877
MythUICheckBoxSetting
Definition: standardsettings.h:390
CodecParamStorage::m_parent
const RecordingProfile & m_parent
Definition: recordingprofile.cpp:36
DriverOption::VOLUME
@ VOLUME
Definition: driveroption.h:13
HardwareMJPEGHDecimation
Definition: recordingprofile.cpp:861
BitrateMode::BitrateMode
BitrateMode(const RecordingProfile &parent, const QString &setting="mpeg2bitratemode")
Definition: recordingprofile.cpp:384
MythTextInputDialog
Dialog prompting the user to enter a text string.
Definition: mythdialogbox.h:314
AudioCompressionSettings::m_parent
const RecordingProfile & m_parent
Definition: recordingprofile.cpp:548
RTjpegChromaFilter::RTjpegChromaFilter
RTjpegChromaFilter(const RecordingProfile &parent)
Definition: recordingprofile.cpp:594
MPEG2audType::m_allowLayer1
bool m_allowLayer1
Definition: recordingprofile.cpp:231
RecordingProfile::TranscoderGroup
@ TranscoderGroup
Definition: recordingprofile.h:115
DriverOption::AUDIO_BITRATE
@ AUDIO_BITRATE
Definition: driveroption.h:13
PeakBitrate::PeakBitrate
PeakBitrate(const RecordingProfile &parent, const QString &setting="mpeg2maxbitrate", uint min_br=1000, uint max_br=16000, uint default_br=6000, uint increment=100, QString label=QString())
Definition: recordingprofile.cpp:782
MythUICheckBoxSetting::setValue
void setValue(const QString &newValue) override
Definition: standardsettings.cpp:721
RecordingProfileEditor::RecordingProfileEditor
RecordingProfileEditor(int id, QString profName)
Definition: recordingprofile.cpp:1652
MythScreenStack::AddScreen
virtual void AddScreen(MythScreenType *screen, bool allowFade=true)
Definition: mythscreenstack.cpp:52
RecordingProfileStorage
Definition: recordingprofile.h:19
build_compdb.options
options
Definition: build_compdb.py:11
RecordingProfile::fillSelections
static void fillSelections(GroupSetting *setting, int group, bool foldautodetect=false)
Definition: recordingprofile.cpp:1730
ScaleBitrate
Definition: recordingprofile.cpp:618
MP3Quality::MP3Quality
MP3Quality(const RecordingProfile &parent)
Definition: recordingprofile.cpp:84
MythUIComboBoxSetting::setValue
void setValue(int value) override
Definition: standardsettings.cpp:479
DriverOption::AUDIO_BITRATE_MODE
@ AUDIO_BITRATE_MODE
Definition: driveroption.h:12
ImageSize::Height::Height
Height(const RecordingProfile &parent, uint defaultheight, uint maxheight, bool transcoding=false)
Definition: recordingprofile.cpp:1312
RecordingProfile::canDelete
bool canDelete(void) override
Definition: recordingprofile.cpp:1908
DriverOption::VIDEO_BITRATE
@ VIDEO_BITRATE
Definition: driveroption.h:11
MPEG2audType::m_allowLayer3
bool m_allowLayer3
Definition: recordingprofile.cpp:233
RecordingProfile::SetLosslessTranscode
void SetLosslessTranscode(const QString &val)
Definition: recordingprofile.cpp:1433
RTjpegQuality
Definition: recordingprofile.cpp:565
ImageSize::Height
Definition: recordingprofile.cpp:1309
ImageSize::ImageSize
ImageSize(const RecordingProfile &parent, const QString &tvFormat, const QString &profName)
Definition: recordingprofile.cpp:1336
RecordFullTSStream
Definition: recordingprofile.cpp:1242
GroupSetting
Definition: standardsettings.h:435
MPEG4QualDiff
Definition: recordingprofile.cpp:661
MythCoreContext::GetSetting
QString GetSetting(const QString &key, const QString &defaultval="")
Definition: mythcorecontext.cpp:897
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:836
CodecParamStorage
Definition: recordingprofile.cpp:21
MythUICheckBoxSetting::boolValue
bool boolValue()
Definition: standardsettings.h:403