MythTV master
frequencytables.cpp
Go to the documentation of this file.
1#include <utility>
2
3#include <QChar> // Fix Qt6 GCC SFINAE warning
4#include <QMutex>
5
6#include "libmythbase/compat.h"
7
8#include "frequencies.h"
9#include "frequencytables.h"
10#include "channelutil.h"
11
12static bool frequencies_initialized = false;
13static QMutex frequencies_lock;
14static freq_table_map_t frequencies;
15
16static void init_freq_tables(freq_table_map_t& /*fmap*/);
17static freq_table_list_t get_matching_freq_tables_internal(
18 const QString &format, const QString &modulation, const QString &country);
19
20TransportScanItem::TransportScanItem()
21{
22 m_tuning.Clear();
23}
24
25TransportScanItem::TransportScanItem(uint sourceid,
26 const QString &_si_std,
27 QString _name,
28 uint _mplexid,
29 std::chrono::milliseconds _timeoutTune)
30 : m_mplexid(_mplexid), m_friendlyName(std::move(_name)),
31 m_sourceID(sourceid),
32 m_timeoutTune(_timeoutTune)
33{
34 m_tuning.Clear();
35 m_tuning.m_sistandard = _si_std;
36
37 if (_si_std == "analog")
38 {
39 m_tuning.m_sistandard = "analog";
40 m_tuning.m_modulation = DTVModulation::kModulationAnalog;
41 }
42}
43
44TransportScanItem::TransportScanItem(uint _sourceid,
45 QString _name,
46 const DTVMultiplex &_tuning,
47 std::chrono::milliseconds _timeoutTune)
48 : m_mplexid(0),
49 m_friendlyName(std::move(_name)),
50 m_sourceID(_sourceid),
51 m_timeoutTune(_timeoutTune),
52 m_tuning(_tuning)
53{
54}
55
56TransportScanItem::TransportScanItem(uint _sourceid,
57 QString _name,
58 DTVTunerType _tuner_type,
59 const DTVTransport &_tuning,
60 std::chrono::milliseconds _timeoutTune)
61 : m_mplexid(0),
62 m_friendlyName(std::move(_name)),
63 m_sourceID(_sourceid),
64 m_timeoutTune(_timeoutTune),
65 m_expectedChannels(_tuning.channels)
66{
67 m_tuning.Clear();
68
69 m_tuning.ParseTuningParams(
70 _tuner_type,
71 QString::number(_tuning.m_frequency), _tuning.m_inversion.toString(),
72 QString::number(_tuning.m_symbolRate), _tuning.m_fec.toString(),
73 _tuning.m_polarity.toString(), _tuning.m_hpCodeRate.toString(),
74 _tuning.m_lpCodeRate.toString(), _tuning.m_modulation.toString(),
75 _tuning.m_transMode.toString(), _tuning.m_guardInterval.toString(),
76 _tuning.m_hierarchy.toString(), _tuning.m_modulation.toString(),
77 _tuning.m_bandwidth.toString(), _tuning.m_modSys.toString(),
78 _tuning.m_rolloff.toString());
79}
80
81TransportScanItem::TransportScanItem(uint sourceid,
82 const QString &std,
83 QString strFmt,
84 uint freqNum,
85 uint freq,
86 const FrequencyTable &ft,
87 std::chrono::milliseconds timeoutTune)
88 : m_mplexid(0), m_friendlyName(std::move(strFmt)),
89 m_friendlyNum(freqNum), m_sourceID(sourceid),
90 m_timeoutTune(timeoutTune)
91{
92 m_tuning.Clear();
93
94 // Setup tuning parameters
95 m_tuning.m_frequency = freq;
96 m_tuning.m_sistandard = "dvb";
97 m_tuning.m_modulation = ft.m_modulation;
98
99 if (std.toLower() == "atsc")
100 {
101 m_tuning.m_sistandard = "atsc";
102 }
103 else if (std.toLower() == "analog")
104 {
105 m_tuning.m_sistandard = "analog";
106 m_tuning.m_modulation = DTVModulation::kModulationAnalog;
107 }
108
109 m_freqOffsets[1] = ft.m_offset1;
110 m_freqOffsets[2] = ft.m_offset2;
111
112 if (std == "dvbt")
113 {
114 m_tuning.m_inversion = ft.m_inversion;
115 m_tuning.m_bandwidth = ft.m_bandwidth;
116 m_tuning.m_hpCodeRate = ft.m_coderateHp;
117 m_tuning.m_lpCodeRate = ft.m_coderateLp;
118 m_tuning.m_transMode = ft.m_transMode;
119 m_tuning.m_guardInterval = ft.m_guardInterval;
120 m_tuning.m_hierarchy = ft.m_hierarchy;
121 }
122 else if (std == "dvbc" || std == "dvbs")
123 {
124 m_tuning.m_symbolRate = ft.m_symbolRate;
125 m_tuning.m_fec = ft.m_fecInner;
126 }
127
128 // Do not use tuning information from database for the "Full Scan"
129 // m_mplexid = GetMultiplexIdFromDB();
130}
131
132TransportScanItem::TransportScanItem(uint _sourceid,
133 QString _name,
134 IPTVTuningData _tuning,
135 QString _channel,
136 std::chrono::milliseconds _timeoutTune) :
137 m_mplexid(0),
138 m_friendlyName(std::move(_name)),
139 m_sourceID(_sourceid),
140 m_timeoutTune(_timeoutTune),
141 m_iptvTuning(std::move(_tuning)), m_iptvChannel(std::move(_channel))
142{
143 m_tuning.Clear();
144 m_tuning.m_sistandard = "MPEG";
145}
146
150uint TransportScanItem::GetMultiplexIdFromDB(void) const
151{
152 int mplexid = 0;
153
154 for (uint i = 0; (i < offset_cnt()) && (mplexid <= 0); i++)
155 mplexid = ChannelUtil::GetMplexID(m_sourceID, freq_offset(i));
156
157 return mplexid < 0 ? 0 : mplexid;
158}
159
160uint64_t TransportScanItem::freq_offset(uint i) const
161{
162 auto freq = (int64_t) m_tuning.m_frequency;
163
164 return (uint64_t) (freq + m_freqOffsets[i]);
165}
166
167QString TransportScanItem::toString() const
168{
169 if (m_tuning.m_sistandard == "MPEG")
170 {
171 return m_iptvChannel + ": " + m_iptvTuning.GetDeviceKey();
172 }
173
174 QString str = QString("Transport Scan Item '%1' #%2").arg(m_friendlyName).arg(m_friendlyNum);
175 str += "\n\t";
176 str += QString("mplexid(%1) " ).arg(m_mplexid);
177 str += QString("standard(%1) " ).arg(m_tuning.m_sistandard);
178 str += QString("sourceid(%1) " ).arg(m_sourceID);
179 str += QString("useTimer(%1) " ).arg(static_cast<int>(m_useTimer));
180 str += QString("scanning(%1) " ).arg(static_cast<int>(m_scanning));
181 str += QString("timeoutTune(%3 msec) " ).arg(m_timeoutTune.count());
182 str += "\n\t";
183 str += QString("frequency(%1) " ).arg(m_tuning.m_frequency);
184 str += QString("offset[0..2]: %1 %2 %3 ").arg(m_freqOffsets[0]).arg(m_freqOffsets[1]).arg(m_freqOffsets[2]);
185
186 if (m_tuning.m_sistandard == "atsc" || m_tuning.m_sistandard == "analog")
187 {
188 str += QString("modulation(%1) " ).arg(m_tuning.m_modulation.toString());
189 }
190 else
191 {
192 str += QString("constellation(%1) " ).arg(m_tuning.m_modulation.toString());
193 str += QString("inv(%1) " ).arg(m_tuning.m_inversion.toString());
194 str += QString("bandwidth(%1) " ).arg(m_tuning.m_bandwidth.toString());
195 str += QString("hp(%1) " ).arg(m_tuning.m_hpCodeRate.toString());
196 str += QString("lp(%1) " ).arg(m_tuning.m_lpCodeRate.toString());
197 str += "\n\t";
198 str += QString("trans_mode(%1) " ).arg(m_tuning.m_transMode.toString());
199 str += QString("guard_int(%1) " ).arg(m_tuning.m_guardInterval.toString());
200 str += QString("hierarchy(%1) " ).arg(m_tuning.m_hierarchy.toString());
201 str += QString("symbol_rate(%1) " ).arg(m_tuning.m_symbolRate);
202 str += QString("fec(%1) " ).arg(m_tuning.m_fec.toString());
203 }
204 return str;
205}
206
207static bool init_freq_tables(void)
208{
209 if (!frequencies_initialized)
210 {
211 init_freq_tables(frequencies);
212 frequencies_initialized = true;
213 }
214 return true;
215}
216
217bool teardown_frequency_tables(void)
218{
219 QMutexLocker locker(&frequencies_lock);
220 if (frequencies_initialized)
221 {
222 frequencies.clear();
223 frequencies_initialized = false;
224 }
225 return true;
226}
227
228static freq_table_list_t get_matching_freq_tables_internal(
229 const QString &format, const QString &modulation, const QString &country)
230{
231 const freq_table_map_t &fmap = frequencies;
232
233 freq_table_list_t list;
234
235 QString lookup = QString("%1_%2_%3%4")
236 .arg(format, modulation, country);
237
238 freq_table_map_t::const_iterator it = fmap.begin();
239 for (uint i = 0; it != fmap.end(); i++)
240 {
241 it = fmap.find(lookup.arg(i));
242 if (it != fmap.end())
243 list.push_back(*it);
244 }
245
246 return list;
247}
248
249freq_table_list_t get_matching_freq_tables(
250 const QString &format, const QString &modulation, const QString &country)
251{
252 QMutexLocker locker(&frequencies_lock);
253 init_freq_tables();
254
255 freq_table_list_t list =
256 get_matching_freq_tables_internal(format, modulation, country);
257
258 freq_table_list_t new_list;
259 new_list.reserve(list.size());
260 for (auto & ft : list)
261 new_list.push_back(new FrequencyTable(*ft));
262
263 return new_list;
264}
265
266long long get_center_frequency(
267 const QString& format, const QString& modulation, const QString& country, int freqid)
268{
269 QMutexLocker locker(&frequencies_lock);
270 init_freq_tables();
271
272 freq_table_list_t list =
273 get_matching_freq_tables_internal(format, modulation, country);
274
275 for (auto & ft : list)
276 {
277 int min_freqid = ft->m_nameOffset;
278 int max_freqid = min_freqid +
279 ((ft->m_frequencyEnd - ft->m_frequencyStart) /
280 ft->m_frequencyStep);
281
282 if ((min_freqid <= freqid) && (freqid <= max_freqid))
283 return ft->m_frequencyStart +
284 (ft->m_frequencyStep * (freqid - min_freqid));
285 }
286 return -1;
287}
288
289int get_closest_freqid(
290 const QString& format, QString modulation, const QString& country, long long centerfreq)
291{
292 modulation = (modulation == "8vsb") ? "vsb8" : modulation;
293
294 freq_table_list_t list =
295 get_matching_freq_tables_internal(format, modulation, country);
296
297 for (auto & ft : list)
298 {
299 int min_freqid = ft->m_nameOffset;
300 int max_freqid = min_freqid +
301 ((ft->m_frequencyEnd - ft->m_frequencyStart) /
302 ft->m_frequencyStep);
303 int freqid =
304 ((centerfreq - ft->m_frequencyStart) /
305 ft->m_frequencyStep) + min_freqid;
306
307 if ((min_freqid <= freqid) && (freqid <= max_freqid))
308 return freqid;
309 }
310#if 0
311 LOG(VB_GENERAL, LOG_DEBUG,
312 QString("get_closest_freqid(%1, %2, %3, %4) Failed sz(%5)")
313 .arg(format) .arg(modulation) .arg(country) .arg(centerfreq)
314 .arg(list.size()));
315#endif
316 return -1;
317}
318
319
320//NOLINTNEXTLINE(cppcoreguidelines-macro-usage)
321#define FREQ(A,B, C,D, E,F,G, H, I) \
322 fmap[QString("atsc_%1_us%2").arg(A,B)] = \
323 new FrequencyTable((C)+(D), E, F, G, H, I);
324
325// The maximum channel defined in the US frequency tables (standard, HRC, IRC)
326static constexpr uint8_t US_MAX_CHAN { 158 };
327// Equation for computing EIA-542 frequency of channels > 99
328static constexpr uint64_t EIA_542_FREQUENCY(uint64_t bandwidth,
329 uint64_t offset,
330 uint64_t channel)
331{ return (bandwidth * (8 + channel)) + offset;}
332static_assert(EIA_542_FREQUENCY(6000000, 3000000, US_MAX_CHAN) == 999000000);
333static_assert(EIA_542_FREQUENCY(6000300, 1750000, US_MAX_CHAN) == 997799800);
334
335static void init_freq_tables(freq_table_map_t &fmap)
336{
337 // United Kingdom
338 fmap["dvbt_ofdm_gb0"] = new FrequencyTable(
339 474000000, 698000000, 8000000, "Channel %1", 21,
340 DTVInversion::kInversionOff,
341 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
342 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
343 DTVTransmitMode::kTransmissionModeAuto,
344 DTVGuardInterval::kGuardInterval_1_32, DTVHierarchy::kHierarchyNone,
345 DTVModulation::kModulationQAMAuto, 166670, -166670);
346
347 // Finland
348 fmap["dvbt_ofdm_fi0"] = new FrequencyTable(
349 474000000, 850000000, 8000000, "Channel %1", 21,
350 DTVInversion::kInversionOff,
351 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
352 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
353 DTVTransmitMode::kTransmissionModeAuto,
354 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
355 DTVModulation::kModulationQAMAuto, 0, 0);
356
357 // Sweden
358 fmap["dvbt_ofdm_se0"] = new FrequencyTable(
359 474000000, 850000000, 8000000, "Channel %1", 21,
360 DTVInversion::kInversionOff,
361 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
362 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
363 DTVTransmitMode::kTransmissionModeAuto,
364 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
365 DTVModulation::kModulationQAMAuto, 0, 0);
366
367 // Australia
368 fmap["dvbt_ofdm_au0"] = new FrequencyTable(
369 177500000, 226500000, 7000000, "Channel %1", 5,
370 DTVInversion::kInversionOff,
371 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
372 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
373 DTVTransmitMode::kTransmissionMode8K,
374 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
375 DTVModulation::kModulationQAMAuto, 125000, 0); // VHF 5-12
376 fmap["dvbt_ofdm_au1"] = new FrequencyTable(
377 529500000, 816500000, 7000000, "Channel %1", 28,
378 DTVInversion::kInversionOff,
379 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
380 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
381 DTVTransmitMode::kTransmissionMode8K,
382 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
383 DTVModulation::kModulationQAMAuto, 125000, 0); // UHF 28-69
384
385 // Germany (Deutschland)
386 fmap["dvbt_ofdm_de0"] = new FrequencyTable(
387 177500000, 226500000, 7000000, "Channel %1", 5,
388 DTVInversion::kInversionOff,
389 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
390 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
391 DTVTransmitMode::kTransmissionMode8K,
392 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
393 DTVModulation::kModulationQAMAuto, 0, 0); // VHF 5-12, deprecated
394 fmap["dvbt_ofdm_de1"] = new FrequencyTable(
395 474000000, 826000000, 8000000, "Channel %1", 21,
396 DTVInversion::kInversionOff,
397 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
398 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
399 DTVTransmitMode::kTransmissionModeAuto,
400 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
401 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 21-65
402
403 // Israel
404 fmap["dvbt_ofdm_il0"] = new FrequencyTable(
405 514000000, 514000000+1, 8000000, "Channel %1", 26,
406 DTVInversion::kInversionOff,
407 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
408 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
409 DTVTransmitMode::kTransmissionMode8K,
410 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
411 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 26 - central Israel
412 fmap["dvbt_ofdm_il1"] = new FrequencyTable(
413 538000000, 538000000+1, 8000000, "Channel %1", 29,
414 DTVInversion::kInversionOff,
415 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
416 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
417 DTVTransmitMode::kTransmissionModeAuto,
418 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
419 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 29 - North and Eilat area
420
421 // Italy (Italia)
422 fmap["dvbt_ofdm_it0"] = new FrequencyTable(
423 177500000, 226500000, 7000000, "Channel %1", 5,
424 DTVInversion::kInversionOff,
425 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
426 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
427 DTVTransmitMode::kTransmissionMode8K,
428 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
429 DTVModulation::kModulationQAMAuto, 0, 0); // VHF 5-12, deprecated
430 fmap["dvbt_ofdm_it1"] = new FrequencyTable(
431 474000000, 858000000, 8000000, "Channel %1", 21,
432 DTVInversion::kInversionOff,
433 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
434 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
435 DTVTransmitMode::kTransmissionModeAuto,
436 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
437 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 21-65
438
439 // Czech Republic
440 fmap["dvbt_ofdm_cz0"] = new FrequencyTable(
441 474000000, 858000000, 8000000, "Channel %1", 21,
442 DTVInversion::kInversionOff,
443 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_2_3,
444 DTVCodeRate::kFEC_2_3, DTVModulation::kModulationQAM64,
445 DTVTransmitMode::kTransmissionMode8K,
446 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
447 DTVModulation::kModulationQAM64, 0, 0); // UHF 21-69
448
449 // Greece (Hellas)
450 fmap["dvbt_ofdm_gr0"] = new FrequencyTable(
451 174000000, 230000000, 7000000, "Channel %1", 5,
452 DTVInversion::kInversionAuto,
453 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
454 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
455 DTVTransmitMode::kTransmissionModeAuto,
456 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyAuto,
457 DTVModulation::kModulationQAMAuto, 0, 0); // VHF 5-12, deprecated
458 fmap["dvbt_ofdm_gr1"] = new FrequencyTable(
459 474000000, 866000000, 8000000, "Channel %1", 21,
460 DTVInversion::kInversionAuto,
461 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
462 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
463 DTVTransmitMode::kTransmissionModeAuto,
464 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
465 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 21-65
466
467 // Spain
468 fmap["dvbt_ofdm_es0"] = new FrequencyTable(
469 474000000, 858000000, 8000000, "Channel %1", 21,
470 DTVInversion::kInversionOff,
471 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
472 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
473 DTVTransmitMode::kTransmissionModeAuto,
474 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
475 DTVModulation::kModulationQAMAuto, 125000, 0); // UHF 21-69
476
477 // New Zealand
478 fmap["dvbt_ofdm_nz0"] = new FrequencyTable(
479 474000000, 690000000, 8000000, "Channel %1", 21,
480 DTVInversion::kInversionOff,
481 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_3_4,
482 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAM64,
483 DTVTransmitMode::kTransmissionMode8K,
484 DTVGuardInterval::kGuardInterval_1_16, DTVHierarchy::kHierarchyNone,
485 DTVModulation::kModulationQAM64, 0 , 0); // UHF 21-48
486
487 // France
488 fmap["dvbt_ofdm_fr0"] = new FrequencyTable(
489 474000000, 850000000, 8000000, "Channel %1", 21,
490 DTVInversion::kInversionOff,
491 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
492 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
493 DTVTransmitMode::kTransmissionMode8K,
494 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
495 DTVModulation::kModulationQAMAuto, 167000, -166000);
496
497 // Denmark
498 fmap["dvbt_ofdm_dk0"] = new FrequencyTable(
499 474000000, 858000000, 8000000, "Channel %1", 21,
500 DTVInversion::kInversionOff,
501 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_2_3,
502 DTVCodeRate::kFECNone, DTVModulation::kModulationQAM64,
503 DTVTransmitMode::kTransmissionMode8K,
504 DTVGuardInterval::kGuardInterval_1_4, DTVHierarchy::kHierarchyNone,
505 DTVModulation::kModulationQAM64, 0, 0);
506
507 // Netherlands
508 fmap["dvbt_ofdm_nl0"] = new FrequencyTable(
509 474000000, 690000000, 8000000, "Channel %1", 21,
510 DTVInversion::kInversionOff,
511 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
512 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
513 DTVTransmitMode::kTransmissionModeAuto,
514 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
515 DTVModulation::kModulationQAMAuto, 0, 0); // UHF 21-48
516
517 // Chile (ISDB-Tb)
518 fmap["dvbt_ofdm_cl0"] = new FrequencyTable(
519 473000000, 803000000, 6000000, "Channel %1", 14,
520 DTVInversion::kInversionAuto,
521 DTVBandwidth::kBandwidthAuto, DTVCodeRate::kFEC_3_4,
522 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
523 DTVTransmitMode::kTransmissionModeAuto,
524 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
525 DTVModulation::kModulationQAMAuto, 143000, 0);
526
527 // DVB-C Germany
528 fmap["dvbc_qam_de0"] = new FrequencyTable(
529 73000000, 73000000, 8000000, "Channel D%1", 73,
530 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
531 6900000, 0, 0);
532 fmap["dvbc_qam_de1"] = new FrequencyTable(
533 81000000, 81000000, 8000000, "Channel D%1", 81,
534 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
535 6900000, 0, 0);
536 fmap["dvbc_qam_de2"] = new FrequencyTable(
537 113000000, 121000000, 8000000, "Channel S0%1", 2,
538 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
539 6900000, 0, 0);
540 fmap["dvbc_qam_de3"] = new FrequencyTable(
541 306000000, 466000000, 8000000, "Channel S%1", 21,
542 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
543 6900000, 0, 0);
544 fmap["dvbc_qam_de4"] = new FrequencyTable(
545 474000000, 858000000, 8000000, "Channel %1", 21,
546 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
547 6900000, 0, 0);
548
549 // DVB-C Netherlands
550 fmap["dvbc_qam_nl0"] = new FrequencyTable(
551 474000000, 474000000, 8000000, "Channel %1", 21,
552 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
553 6875000, 0, 0);
554
555 // DVB-C United Kingdom
556 fmap["dvbc_qam_gb0"] = new FrequencyTable(
557 12324000, 12324000+1, 10, "Channel %1", 1,
558 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAMAuto,
559 29500000, 0, 0);
560 fmap["dvbc_qam_gb1"] = new FrequencyTable(
561 459000000, 459000000+1, 10, "Channel %1", 2,
562 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAM64,
563 6952000, 0, 0);
564
565 // DVB-C Unknown (British Forces ?)
566 fmap["dvbc_qam_bf0"] = new FrequencyTable(
567 203000000, 795000000, 100000, "BF Channel %1", 1,
568 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
569 6900000, 0, 0);
570 fmap["dvbc_qam_bf1"] = new FrequencyTable(
571 194750000, 794750000, 100000, "BF Channel %1", 1 + ((795000-203000) / 100),
572 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
573 6900000, 0, 0);
574
575//#define DEBUG_DVB_OFFSETS
576#ifdef DEBUG_DVB_OFFSETS
577 // UHF 24-36
578 fmap["atsc_vsb8_us0"] = new FrequencyTable(
579 533000000, 605000000, 6000000, "xATSC Channel %1", 24,
580 DTVInversion::kInversionOff,
581 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
582 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
583 DTVTransmitMode::kTransmissionMode8K,
584 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
585 DTVModulation::kModulation8VSB, -100000, 100000);
586#else // if !DEBUG_DVB_OFFSETS
587 // USA Terrestrial (center frequency, subtract 1.75 MHz for visual carrier)
588 // VHF 2-4
589 fmap["atsc_vsb8_us0"] = new FrequencyTable(
590 "ATSC Channel %1", 2, 57000000, 69000000, 6000000,
591 DTVModulation::kModulation8VSB);
592 // VHF 5-6
593 fmap["atsc_vsb8_us1"] = new FrequencyTable(
594 "ATSC Channel %1", 5, 79000000, 85000000, 6000000,
595 DTVModulation::kModulation8VSB);
596 // VHF 7-13
597 fmap["atsc_vsb8_us2"] = new FrequencyTable(
598 "ATSC Channel %1", 7, 177000000, 213000000, 6000000,
599 DTVModulation::kModulation8VSB);
600 // UHF 14-36
601 fmap["atsc_vsb8_us3"] = new FrequencyTable(
602 "ATSC Channel %1", 14, 473000000, 605000000, 6000000,
603 DTVModulation::kModulation8VSB);
604#endif // !DEBUG_DVB_OFFSETS
605
606 const std::array<const QString,4> modStr {
607 "vsb8", "qam256", "qam128", "qam64" };
608 const std::array<const DTVModulation::Types,4> mod {
609 DTVModulation::kModulation8VSB,
610 DTVModulation::kModulationQAM256,
611 DTVModulation::kModulationQAM128,
612 DTVModulation::kModulationQAM64, };
613 const std::array<const QString,4> desc {
614 "ATSC ", "QAM-256 ", "QAM-128 ", "QAM-64 ", };
615
616 for (uint i = 0; i < 4; i++)
617 {
618 // USA Cable, T13 to T14 and ch 2 to US_MAX_CHAN
619 FREQ(modStr[i], "cable0", desc[i], "Channel T-%1",
620 13, 44750000, 50750000, 6000000, mod[i]); // T13-T14
621 FREQ(modStr[i], "cable1", desc[i], "Channel %1",
622 2, 57000000, 69000000, 6000000, mod[i]); // 2-4
623 FREQ(modStr[i], "cable2", desc[i], "Channel %1",
624 5, 79000000, 85000000, 6000000, mod[i]); // 5-6
625 FREQ(modStr[i], "cable3", desc[i], "Channel %1",
626 7, 177000000, 213000000, 6000000, mod[i]); // 7-13
627 FREQ(modStr[i], "cable4", desc[i], "Channel %1",
628 14, 123000000, 171000000, 6000000, mod[i]); // 14-22
629 FREQ(modStr[i], "cable5", desc[i], "Channel %1",
630 23, 219000000, 645000000, 6000000, mod[i]); // 23-94
631 FREQ(modStr[i], "cable6", desc[i], "Channel %1",
632 95, 93000000, 117000000, 6000000, mod[i]); // 95-99
633 // The center frequency of any EIA-542 std cable channel over 99 is
634 // Frequency_MHz = ( 6 * ( 8 + channel_designation ) ) + 3
635 FREQ(modStr[i], "cable7", desc[i], "Channel %1",
636 100, 651000000,
637 EIA_542_FREQUENCY(6000000, 3000000, US_MAX_CHAN),
638 6000000, mod[i]); // 100-US_MAX_CHAN
639
640 // USA Cable, QAM 256 ch 78 to US_MAX_CHAN
641 FREQ(modStr[i], "cablehigh0", desc[i], "Channel %1",
642 78, 549000000, 645000000, 6000000, mod[i]); // 78-94
643 FREQ(modStr[i], "cablehigh1", desc[i], "Channel %1",
644 100, 651000000,
645 EIA_542_FREQUENCY(6000000, 3000000, US_MAX_CHAN),
646 6000000, mod[i]); // 100-US_MAX_CHAN
647
648 // USA Cable HRC, ch 1 to US_MAX_CHAN
649 FREQ(modStr[i], "hrc0", desc[i], "HRC %1",
650 1, 73753600, 73753601, 6000300, mod[i]); // 1
651 FREQ(modStr[i], "hrc1", desc[i], "HRC %1",
652 2, 55752700, 67753300, 6000300, mod[i]); // 2-4
653 FREQ(modStr[i], "hrc2", desc[i], "HRC %1",
654 5, 79753900, 85754200, 6000300, mod[i]); // 5-6
655 FREQ(modStr[i], "hrc3", desc[i], "HRC %1",
656 7, 175758700, 211760500, 6000300, mod[i]); // 7-13
657 FREQ(modStr[i], "hrc4", desc[i], "HRC %1",
658 14, 121756000, 169758400, 6000300, mod[i]); // 14-22
659 FREQ(modStr[i], "hrc5", desc[i], "HRC %1",
660 23, 217760800, 643782100, 6000300, mod[i]); // 23-94
661 FREQ(modStr[i], "hrc6", desc[i], "HRC %1",
662 95, 91754500, 115755700, 6000300, mod[i]); // 95-99
663 // The center frequency of any EIA-542 HRC cable channel over 99 is
664 // Frequency_MHz = ( 6.0003 * ( 8 + channel_designation ) ) + 1.75
665 FREQ(modStr[i], "hrc7", desc[i], "HRC %1",
666 100, 649782400,
667 EIA_542_FREQUENCY(6000300, 1750000, US_MAX_CHAN),
668 6000300, mod[i]); // 100-US_MAX_CHAN
669
670 // USA Cable HRC, ch 76-94 and 100-US_MAX_CHAN
671 // Channels 95-99 are low frequency despite high channel numbers
672 FREQ(modStr[i], "hrchigh0", desc[i], "HRC %1",
673 76, 535776700, 643782100, 6000300, mod[i]); // 76-94
674 FREQ(modStr[i], "hrchigh1", desc[i], "HRC %1",
675 100, 649782400,
676 EIA_542_FREQUENCY(6000300, 1750000, US_MAX_CHAN),
677 6000300, mod[i]); // 100-US_MAX_CHAN
678
679 // USA Cable IRC, ch 1 to US_MAX_CHAN
680 FREQ(modStr[i], "irc0", desc[i], "IRC %1",
681 1, 75012500, 75012501, 6000000, mod[i]); // 1
682 FREQ(modStr[i], "irc1", desc[i], "IRC %1",
683 2, 57012500, 69012500, 6000000, mod[i]); // 2-4
684 FREQ(modStr[i], "irc2", desc[i], "IRC %1",
685 5, 81012500, 87012500, 6000000, mod[i]); // 5-6
686 FREQ(modStr[i], "irc3", desc[i], "IRC %1",
687 7, 177012500, 213012500, 6000000, mod[i]); // 7-13
688 FREQ(modStr[i], "irc4", desc[i], "IRC %1",
689 14, 123012500, 171012500, 6000000, mod[i]); // 14-22
690 FREQ(modStr[i], "irc5", desc[i], "IRC %1",
691 23, 219012500, 327012500, 6000000, mod[i]); // 23-41
692 FREQ(modStr[i], "irc6", desc[i], "IRC %1",
693 42, 333025000, 333025001, 6000000, mod[i]); // 42
694 FREQ(modStr[i], "irc7", desc[i], "IRC %1",
695 43, 339012500, 645012500, 6000000, mod[i]); // 43-94
696 FREQ(modStr[i], "irc8", desc[i], "IRC %1",
697 95, 93012500, 105012500, 6000000, mod[i]); // 95-97
698 FREQ(modStr[i], "irc9", desc[i], "IRC %1",
699 98, 111025000, 117025000, 6000000, mod[i]); // 98-99
700 // The center frequency of any EIA-542 IRC cable channel over 99 is
701 // Frequency_MHz = ( 6 * ( 8 + channel_designation ) ) + 3.0125
702 FREQ(modStr[i], "irc10", desc[i], "IRC %1",
703 100, 651012500,
704 EIA_542_FREQUENCY(6000000, 3012500, US_MAX_CHAN),
705 6000000, mod[i]); // 100-US_MAX_CHAN
706
707 // USA Cable IRC, ch 76-94 and 100-125
708 // Channels 95-99 are low frequency despite high channel numbers
709 FREQ(modStr[i], "irchigh0", desc[i], "IRC %1",
710 76, 537012500, 645012500, 6000000, mod[i]); // 76-94
711 FREQ(modStr[i], "irchigh1", desc[i], "IRC %1",
712 100, 651012500,
713 EIA_542_FREQUENCY(6000000, 3012500, US_MAX_CHAN),
714 6000000, mod[i]); // 100-US_MAX_CHAN
715 }
716
717 // create old school frequency tables...
718 for (const auto & [name, list] : gChanLists)
719 {
720 for (uint i = 0; i < (uint)list.size(); i++)
721 {
722 uint64_t freq = (list[i].freq * 1000LL) + 1750000;
723 fmap[QString("analog_analog_%1%2").arg(name).arg(i)] =
724 new FrequencyTable(
725 QString("%1 %2").arg(name, list[i].name), i+2,
726 freq, freq + 3000000,
727 6000000, DTVModulation::kModulationAnalog);
728 }
729 }
730}
ChannelUtil::GetMplexID
static uint GetMplexID(uint sourceid, const QString &channum)
Definition: channelutil.cpp:467
DTVBandwidth::toString
QString toString() const
Definition: dtvconfparserhelpers.h:271
DTVCodeRate::toString
QString toString() const
Definition: dtvconfparserhelpers.h:344
DTVGuardInterval::toString
QString toString() const
Definition: dtvconfparserhelpers.h:543
DTVHierarchy::toString
QString toString() const
Definition: dtvconfparserhelpers.h:596
DTVInversion::toString
QString toString() const
Definition: dtvconfparserhelpers.h:208
DTVModulation::toString
QString toString() const
Definition: dtvconfparserhelpers.h:415
DTVMultiplex::ParseTuningParams
bool ParseTuningParams(DTVTunerType type, const QString &frequency, const QString &inversion, const QString &symbolrate, const QString &fec, const QString &polarity, const QString &hp_code_rate, const QString &lp_code_rate, const QString &ofdm_modulation, const QString &trans_mode, const QString &guard_interval, const QString &hierarchy, const QString &modulation, const QString &bandwidth, const QString &mod_sys, const QString &rolloff)
Definition: dtvmultiplex.cpp:448
DTVMultiplex::m_hierarchy
DTVHierarchy m_hierarchy
Definition: dtvmultiplex.h:103
DTVMultiplex::m_fec
DTVCodeRate m_fec
Definition: dtvmultiplex.h:105
DTVMultiplex::m_inversion
DTVInversion m_inversion
Definition: dtvmultiplex.h:96
DTVMultiplex::m_hpCodeRate
DTVCodeRate m_hpCodeRate
Definition: dtvmultiplex.h:98
DTVMultiplex::m_symbolRate
uint64_t m_symbolRate
Definition: dtvmultiplex.h:95
DTVMultiplex::m_transMode
DTVTransmitMode m_transMode
Definition: dtvmultiplex.h:101
DTVMultiplex::m_modulation
DTVModulation m_modulation
Definition: dtvmultiplex.h:100
DTVMultiplex::m_modSys
DTVModulationSystem m_modSys
Definition: dtvmultiplex.h:106
DTVMultiplex::m_rolloff
DTVRollOff m_rolloff
Definition: dtvmultiplex.h:107
DTVMultiplex::m_guardInterval
DTVGuardInterval m_guardInterval
Definition: dtvmultiplex.h:102
DTVMultiplex::Clear
void Clear(void)
Definition: dtvmultiplex.h:34
DTVMultiplex::m_bandwidth
DTVBandwidth m_bandwidth
Definition: dtvmultiplex.h:97
DTVMultiplex::m_frequency
uint64_t m_frequency
Definition: dtvmultiplex.h:94
DTVMultiplex::m_lpCodeRate
DTVCodeRate m_lpCodeRate
Definition: dtvmultiplex.h:99
DTVMultiplex::m_sistandard
QString m_sistandard
Definition: dtvmultiplex.h:111
DTVMultiplex::m_polarity
DTVPolarity m_polarity
Definition: dtvmultiplex.h:104
DTVPolarity::toString
QString toString() const
Definition: dtvconfparserhelpers.h:635
DTVRollOff::toString
QString toString() const
Definition: dtvconfparserhelpers.h:771
DTVTransmitMode::toString
QString toString() const
Definition: dtvconfparserhelpers.h:478
FrequencyTable::m_guardInterval
DTVGuardInterval m_guardInterval
Definition: frequencytables.h:114
FrequencyTable::m_modulation
DTVModulation m_modulation
Definition: frequencytables.h:103
FrequencyTable::m_fecInner
DTVCodeRate m_fecInner
Definition: frequencytables.h:119
FrequencyTable::m_bandwidth
DTVBandwidth m_bandwidth
Definition: frequencytables.h:109
FrequencyTable::m_inversion
DTVInversion m_inversion
Definition: frequencytables.h:108
FrequencyTable::m_transMode
DTVTransmitMode m_transMode
Definition: frequencytables.h:113
FrequencyTable::m_coderateLp
DTVCodeRate m_coderateLp
Definition: frequencytables.h:111
FrequencyTable::m_coderateHp
DTVCodeRate m_coderateHp
Definition: frequencytables.h:110
FrequencyTable::m_hierarchy
DTVHierarchy m_hierarchy
Definition: frequencytables.h:115
IPTVTuningData::GetDeviceKey
QString GetDeviceKey(void) const
Definition: iptvtuningdata.h:100
TransportScanItem::offset_cnt
uint offset_cnt() const
Definition: frequencytables.h:162
TransportScanItem::freq_offset
uint64_t freq_offset(uint i) const
Definition: frequencytables.cpp:160
TransportScanItem::m_iptvTuning
IPTVTuningData m_iptvTuning
Definition: frequencytables.h:191
TransportScanItem::m_freqOffsets
std::array< int, 3 > m_freqOffsets
Definition: frequencytables.h:187
TransportScanItem::m_tuning
DTVMultiplex m_tuning
Definition: frequencytables.h:190
TransportScanItem::toString
QString toString() const
Definition: frequencytables.cpp:167
TransportScanItem::GetMultiplexIdFromDB
uint GetMultiplexIdFromDB(void) const
Fetches mplexid if it exists, based on the frequency and sourceid.
Definition: frequencytables.cpp:150
TransportScanItem::m_timeoutTune
std::chrono::milliseconds m_timeoutTune
Timeout to tune to a frequency.
Definition: frequencytables.h:188
uint
unsigned int uint
Definition: compat.h:60
freq
static const std::array< const uint32_t, 4 > freq
Definition: element.cpp:45
gChanLists
const CHANLISTS_vec gChanLists
Definition: frequencies.cpp:2215
frequencies
static freq_table_map_t frequencies
Definition: frequencytables.cpp:14
FREQ
#define FREQ(A, B, C, D, E, F, G, H, I)
Definition: frequencytables.cpp:321
teardown_frequency_tables
bool teardown_frequency_tables(void)
Definition: frequencytables.cpp:217
EIA_542_FREQUENCY
static constexpr uint64_t EIA_542_FREQUENCY(uint64_t bandwidth, uint64_t offset, uint64_t channel)
Definition: frequencytables.cpp:328
get_center_frequency
long long get_center_frequency(const QString &format, const QString &modulation, const QString &country, int freqid)
Definition: frequencytables.cpp:266
get_matching_freq_tables
freq_table_list_t get_matching_freq_tables(const QString &format, const QString &modulation, const QString &country)
Definition: frequencytables.cpp:249
get_matching_freq_tables_internal
static freq_table_list_t get_matching_freq_tables_internal(const QString &format, const QString &modulation, const QString &country)
Definition: frequencytables.cpp:228
init_freq_tables
static void init_freq_tables(freq_table_map_t &)
Definition: frequencytables.cpp:335
frequencies_lock
static QMutex frequencies_lock
Definition: frequencytables.cpp:13
US_MAX_CHAN
static constexpr uint8_t US_MAX_CHAN
Definition: frequencytables.cpp:326
frequencies_initialized
static bool frequencies_initialized
Definition: frequencytables.cpp:12
get_closest_freqid
int get_closest_freqid(const QString &format, QString modulation, const QString &country, long long centerfreq)
Definition: frequencytables.cpp:289
freq_table_map_t
QMap< QString, const FrequencyTable * > freq_table_map_t
Definition: frequencytables.h:24
freq_table_list_t
std::vector< const FrequencyTable * > freq_table_list_t
Definition: frequencytables.h:25
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:39
Generated on Sun Aug 30 2026 03:16:24 for MythTV by doxygen 1.9.4