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