00001 #include <QMutex>
00002
00003 #include "frequencies.h"
00004 #include "frequencytables.h"
00005 #include "channelutil.h"
00006 #include "compat.h"
00007
00008 static bool frequencies_initialized = false;
00009 static QMutex frequencies_lock;
00010 static freq_table_map_t frequencies;
00011
00012 static void init_freq_tables(freq_table_map_t&);
00013 static freq_table_list_t get_matching_freq_tables_internal(
00014 const QString &format, const QString &modulation, const QString &country);
00015
00016 TransportScanItem::TransportScanItem()
00017 : mplexid((uint)-1), FriendlyName(""),
00018 friendlyNum(0), SourceID(0), UseTimer(false),
00019 scanning(false), timeoutTune(1000)
00020 {
00021 memset(freq_offsets, 0, sizeof(int)*3);
00022
00023 tuning.Clear();
00024 }
00025
00026 TransportScanItem::TransportScanItem(uint sourceid,
00027 const QString &_si_std,
00028 const QString &_name,
00029 uint _mplexid,
00030 uint _timeoutTune)
00031 : mplexid(_mplexid), FriendlyName(_name),
00032 friendlyNum(0), SourceID(sourceid), UseTimer(false),
00033 scanning(false), timeoutTune(_timeoutTune)
00034 {
00035 memset(freq_offsets, 0, sizeof(int)*3);
00036
00037 tuning.Clear();
00038 tuning.sistandard = _si_std;
00039
00040 if (_si_std == "analog")
00041 {
00042 tuning.sistandard = "analog";
00043 tuning.modulation = DTVModulation::kModulationAnalog;
00044 }
00045 }
00046
00047 TransportScanItem::TransportScanItem(uint _sourceid,
00048 const QString &_name,
00049 DTVMultiplex &_tuning,
00050 uint _timeoutTune)
00051 : mplexid(0),
00052 FriendlyName(_name), friendlyNum(0),
00053 SourceID(_sourceid), UseTimer(false),
00054 scanning(false), timeoutTune(_timeoutTune)
00055 {
00056 memset(freq_offsets, 0, sizeof(int)*3);
00057 tuning = _tuning;
00058 }
00059
00060 TransportScanItem::TransportScanItem(uint _sourceid,
00061 const QString &_name,
00062 DTVTunerType _tuner_type,
00063 const DTVTransport &_tuning,
00064 uint _timeoutTune)
00065 : mplexid(0),
00066 FriendlyName(_name), friendlyNum(0),
00067 SourceID(_sourceid), UseTimer(false),
00068 scanning(false), timeoutTune(_timeoutTune)
00069 {
00070 memset(freq_offsets, 0, sizeof(int)*3);
00071 expectedChannels = _tuning.channels;
00072
00073 tuning.Clear();
00074
00075 tuning.ParseTuningParams(
00076 _tuner_type,
00077 QString::number(_tuning.frequency), _tuning.inversion.toString(),
00078 QString::number(_tuning.symbolrate), _tuning.fec.toString(),
00079 _tuning.polarity.toString(), _tuning.hp_code_rate.toString(),
00080 _tuning.lp_code_rate.toString(), _tuning.modulation.toString(),
00081 _tuning.trans_mode.toString(), _tuning.guard_interval.toString(),
00082 _tuning.hierarchy.toString(), _tuning.modulation.toString(),
00083 _tuning.bandwidth.toString(), _tuning.mod_sys.toString(),
00084 _tuning.rolloff.toString());
00085 }
00086
00087 TransportScanItem::TransportScanItem(uint sourceid,
00088 const QString &std,
00089 const QString &fn,
00090 uint fnum,
00091 uint freq,
00092 const FrequencyTable &ft,
00093 uint tuneTO)
00094 : mplexid(0), FriendlyName(fn),
00095 friendlyNum(fnum), SourceID(sourceid), UseTimer(false),
00096 scanning(false), timeoutTune(tuneTO)
00097 {
00098 memset(freq_offsets, 0, sizeof(int)*3);
00099
00100 tuning.Clear();
00101
00102
00103 tuning.frequency = freq;
00104 tuning.sistandard = "dvb";
00105 tuning.modulation = ft.modulation;
00106
00107 if (std.toLower() == "atsc")
00108 tuning.sistandard = "atsc";
00109 else if (std.toLower() == "analog")
00110 {
00111 tuning.sistandard = "analog";
00112 tuning.modulation = DTVModulation::kModulationAnalog;
00113 }
00114
00115 freq_offsets[1] = ft.offset1;
00116 freq_offsets[2] = ft.offset2;
00117
00118 if (std == "dvbt")
00119 {
00120 tuning.inversion = ft.inversion;
00121 tuning.bandwidth = ft.bandwidth;
00122 tuning.hp_code_rate = ft.coderate_hp;
00123 tuning.lp_code_rate = ft.coderate_lp;
00124 tuning.trans_mode = ft.trans_mode;
00125 tuning.guard_interval = ft.guard_interval;
00126 tuning.hierarchy = ft.hierarchy;
00127 }
00128 else if (std == "dvbc" || std == "dvbs")
00129 {
00130 tuning.symbolrate = ft.symbol_rate;
00131 tuning.fec = ft.fec_inner;
00132 }
00133
00134 mplexid = GetMultiplexIdFromDB();
00135 }
00136
00140 uint TransportScanItem::GetMultiplexIdFromDB(void) const
00141 {
00142 int mplexid = 0;
00143
00144 for (uint i = 0; (i < offset_cnt()) && (mplexid <= 0); i++)
00145 mplexid = ChannelUtil::GetMplexID(SourceID, freq_offset(i));
00146
00147 return mplexid < 0 ? 0 : mplexid;
00148 }
00149
00150 uint64_t TransportScanItem::freq_offset(uint i) const
00151 {
00152 int64_t freq = (int64_t) tuning.frequency;
00153
00154 return (uint64_t) (freq + freq_offsets[i]);
00155 }
00156
00157 QString TransportScanItem::toString() const
00158 {
00159 QString str = QString("Transport Scan Item '%1' #%2\n")
00160 .arg(FriendlyName).arg(friendlyNum);
00161 str += QString("\tmplexid(%1) standard(%2) sourceid(%3)\n")
00162 .arg(mplexid).arg(tuning.sistandard).arg(SourceID);
00163 str += QString("\tUseTimer(%1) scanning(%2)\n")
00164 .arg(UseTimer).arg(scanning);
00165 str += QString("\ttimeoutTune(%3 msec)\n").arg(timeoutTune);
00166 if (tuning.sistandard == "atsc" || tuning.sistandard == "analog")
00167 {
00168 str += QString("\tfrequency(%1) modulation(%2)\n")
00169 .arg(tuning.frequency)
00170 .arg(tuning.modulation.toString());
00171 }
00172 else
00173 {
00174 str += QString("\tfrequency(%1) constellation(%2)\n")
00175 .arg(tuning.frequency)
00176 .arg(tuning.modulation.toString());
00177 str += QString("\t inv(%1) bandwidth(%2) hp(%3) lp(%4)\n")
00178 .arg(tuning.inversion)
00179 .arg(tuning.bandwidth)
00180 .arg(tuning.hp_code_rate)
00181 .arg(tuning.lp_code_rate);
00182 str += QString("\t trans_mode(%1) guard_int(%2) hierarchy(%3)\n")
00183 .arg(tuning.trans_mode)
00184 .arg(tuning.guard_interval)
00185 .arg(tuning.hierarchy);
00186 }
00187 str += QString("\t offset[0..2]: %1 %2 %3")
00188 .arg(freq_offsets[0]).arg(freq_offsets[1]).arg(freq_offsets[2]);
00189 return str;
00190 }
00191
00192 static bool init_freq_tables(void)
00193 {
00194 if (!frequencies_initialized)
00195 {
00196 init_freq_tables(frequencies);
00197 frequencies_initialized = true;
00198 }
00199 return true;
00200 }
00201
00202 bool teardown_frequency_tables(void)
00203 {
00204 QMutexLocker locker(&frequencies_lock);
00205 if (frequencies_initialized)
00206 {
00207 frequencies.clear();
00208 frequencies_initialized = false;
00209 }
00210 return true;
00211 }
00212
00213 static freq_table_list_t get_matching_freq_tables_internal(
00214 const QString &format, const QString &modulation, const QString &country)
00215 {
00216 const freq_table_map_t &fmap = frequencies;
00217
00218 freq_table_list_t list;
00219
00220 QString lookup = QString("%1_%2_%3%4")
00221 .arg(format).arg(modulation).arg(country);
00222
00223 freq_table_map_t::const_iterator it = fmap.begin();
00224 for (uint i = 0; it != fmap.end(); i++)
00225 {
00226 it = fmap.find(lookup.arg(i));
00227 if (it != fmap.end())
00228 list.push_back(*it);
00229 }
00230
00231 return list;
00232 }
00233
00234 freq_table_list_t get_matching_freq_tables(
00235 const QString &format, const QString &modulation, const QString &country)
00236 {
00237 QMutexLocker locker(&frequencies_lock);
00238 init_freq_tables();
00239
00240 freq_table_list_t list =
00241 get_matching_freq_tables_internal(format, modulation, country);
00242
00243 freq_table_list_t new_list;
00244 for (uint i = 0; i < list.size(); i++)
00245 new_list.push_back(new FrequencyTable(*list[i]));
00246
00247 return new_list;
00248 }
00249
00250 long long get_center_frequency(
00251 QString format, QString modulation, QString country, int freqid)
00252 {
00253 QMutexLocker locker(&frequencies_lock);
00254 init_freq_tables();
00255
00256 freq_table_list_t list =
00257 get_matching_freq_tables_internal(format, modulation, country);
00258
00259 for (uint i = 0; i < list.size(); ++i)
00260 {
00261 int min_freqid = list[i]->name_offset;
00262 int max_freqid = min_freqid +
00263 ((list[i]->frequencyEnd - list[i]->frequencyStart) /
00264 list[i]->frequencyStep);
00265
00266 if ((min_freqid <= freqid) && (freqid <= max_freqid))
00267 return list[i]->frequencyStart +
00268 list[i]->frequencyStep * (freqid - min_freqid);
00269 }
00270 return -1;
00271 }
00272
00273 int get_closest_freqid(
00274 QString format, QString modulation, QString country, long long centerfreq)
00275 {
00276 modulation = (modulation == "8vsb") ? "vsb8" : modulation;
00277
00278 freq_table_list_t list =
00279 get_matching_freq_tables_internal(format, modulation, country);
00280
00281 for (uint i = 0; i < list.size(); ++i)
00282 {
00283 int min_freqid = list[i]->name_offset;
00284 int max_freqid = min_freqid +
00285 ((list[i]->frequencyEnd - list[i]->frequencyStart) /
00286 list[i]->frequencyStep);
00287 int freqid =
00288 ((centerfreq - list[i]->frequencyStart) /
00289 list[i]->frequencyStep) + min_freqid;
00290
00291 if ((min_freqid <= freqid) && (freqid <= max_freqid))
00292 return freqid;
00293 }
00294 #if 0
00295 LOG(VB_GENERAL, LOG_DEBUG,
00296 QString("get_closest_freqid(%1, %2, %3, %4) Failed sz(%5)")
00297 .arg(format) .arg(modulation) .arg(country) .arg(centerfreq)
00298 .arg(list.size()));
00299 #endif
00300 return -1;
00301 }
00302
00303
00304 static void init_freq_tables(freq_table_map_t &fmap)
00305 {
00306
00307 fmap["dvbt_ofdm_gb0"] = new FrequencyTable(
00308 474000000, 850000000, 8000000, "Channel %1", 21,
00309 DTVInversion::kInversionOff,
00310 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00311 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00312 DTVTransmitMode::kTransmissionModeAuto,
00313 DTVGuardInterval::kGuardInterval_1_32, DTVHierarchy::kHierarchyNone,
00314 DTVModulation::kModulationQAMAuto, 166670, -166670);
00315
00316
00317 fmap["dvbt_ofdm_fi0"] = new FrequencyTable(
00318 474000000, 850000000, 8000000, "Channel %1", 21,
00319 DTVInversion::kInversionOff,
00320 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00321 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
00322 DTVTransmitMode::kTransmissionModeAuto,
00323 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00324 DTVModulation::kModulationQAMAuto, 0, 0);
00325
00326
00327 fmap["dvbt_ofdm_se0"] = new FrequencyTable(
00328 474000000, 850000000, 8000000, "Channel %1", 21,
00329 DTVInversion::kInversionOff,
00330 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00331 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
00332 DTVTransmitMode::kTransmissionModeAuto,
00333 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00334 DTVModulation::kModulationQAMAuto, 0, 0);
00335
00336
00337 fmap["dvbt_ofdm_au0"] = new FrequencyTable(
00338 177500000, 226500000, 7000000, "Channel %1", 5,
00339 DTVInversion::kInversionOff,
00340 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00341 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
00342 DTVTransmitMode::kTransmissionMode8K,
00343 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00344 DTVModulation::kModulationQAMAuto, 125000, 0);
00345 fmap["dvbt_ofdm_au1"] = new FrequencyTable(
00346 529500000, 816500000, 7000000, "Channel %1", 28,
00347 DTVInversion::kInversionOff,
00348 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00349 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAM64,
00350 DTVTransmitMode::kTransmissionMode8K,
00351 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00352 DTVModulation::kModulationQAMAuto, 125000, 0);
00353
00354
00355 fmap["dvbt_ofdm_de0"] = new FrequencyTable(
00356 177500000, 226500000, 7000000, "Channel %1", 5,
00357 DTVInversion::kInversionOff,
00358 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00359 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00360 DTVTransmitMode::kTransmissionMode8K,
00361 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00362 DTVModulation::kModulationQAMAuto, 0, 0);
00363 fmap["dvbt_ofdm_de1"] = new FrequencyTable(
00364 474000000, 826000000, 8000000, "Channel %1", 21,
00365 DTVInversion::kInversionOff,
00366 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00367 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00368 DTVTransmitMode::kTransmissionModeAuto,
00369 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00370 DTVModulation::kModulationQAMAuto, 0, 0);
00371
00372
00373 fmap["dvbt_ofdm_it0"] = new FrequencyTable(
00374 177500000, 226500000, 7000000, "Channel %1", 5,
00375 DTVInversion::kInversionOff,
00376 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00377 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00378 DTVTransmitMode::kTransmissionMode8K,
00379 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00380 DTVModulation::kModulationQAMAuto, 0, 0);
00381 fmap["dvbt_ofdm_it1"] = new FrequencyTable(
00382 474000000, 858000000, 8000000, "Channel %1", 21,
00383 DTVInversion::kInversionOff,
00384 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00385 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00386 DTVTransmitMode::kTransmissionModeAuto,
00387 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00388 DTVModulation::kModulationQAMAuto, 0, 0);
00389
00390
00391 fmap["dvbt_ofdm_cz0"] = new FrequencyTable(
00392 474000000, 858000000, 8000000, "Channel %1", 21,
00393 DTVInversion::kInversionOff,
00394 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_2_3,
00395 DTVCodeRate::kFEC_2_3, DTVModulation::kModulationQAM64,
00396 DTVTransmitMode::kTransmissionMode8K,
00397 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00398 DTVModulation::kModulationQAM64, 0, 0);
00399
00400
00401 fmap["dvbt_ofdm_gr0"] = new FrequencyTable(
00402 174000000, 230000000, 7000000, "Channel %1", 5,
00403 DTVInversion::kInversionAuto,
00404 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00405 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00406 DTVTransmitMode::kTransmissionModeAuto,
00407 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyAuto,
00408 DTVModulation::kModulationQAMAuto, 0, 0);
00409 fmap["dvbt_ofdm_gr1"] = new FrequencyTable(
00410 474000000, 866000000, 8000000, "Channel %1", 21,
00411 DTVInversion::kInversionAuto,
00412 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00413 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00414 DTVTransmitMode::kTransmissionModeAuto,
00415 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00416 DTVModulation::kModulationQAMAuto, 0, 0);
00417
00418
00419 fmap["dvbt_ofdm_es0"] = new FrequencyTable(
00420 474000000, 858000000, 8000000, "Channel %1", 21,
00421 DTVInversion::kInversionOff,
00422 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00423 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00424 DTVTransmitMode::kTransmissionModeAuto,
00425 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00426 DTVModulation::kModulationQAMAuto, 125000, 0);
00427
00428
00429 fmap["dvbt_ofdm_nz0"] = new FrequencyTable(
00430 474000000, 858000000, 8000000, "Channel %1", 21,
00431 DTVInversion::kInversionOff,
00432 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_3_4,
00433 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAM64,
00434 DTVTransmitMode::kTransmissionMode8K,
00435 DTVGuardInterval::kGuardInterval_1_16, DTVHierarchy::kHierarchyNone,
00436 DTVModulation::kModulationQAM64, 0 , 0);
00437
00438
00439 fmap["dvbt_ofdm_fr0"] = new FrequencyTable(
00440 474000000, 850000000, 8000000, "Channel %1", 21,
00441 DTVInversion::kInversionOff,
00442 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFECAuto,
00443 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00444 DTVTransmitMode::kTransmissionMode8K,
00445 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00446 DTVModulation::kModulationQAMAuto, 167000, -166000);
00447
00448
00449 fmap["dvbt_ofdm_dk0"] = new FrequencyTable(
00450 474000000, 858000000, 8000000, "Channel %1", 21,
00451 DTVInversion::kInversionOff,
00452 DTVBandwidth::kBandwidth8MHz, DTVCodeRate::kFEC_2_3,
00453 DTVCodeRate::kFECNone, DTVModulation::kModulationQAM64,
00454 DTVTransmitMode::kTransmissionMode8K,
00455 DTVGuardInterval::kGuardInterval_1_4, DTVHierarchy::kHierarchyNone,
00456 DTVModulation::kModulationQAM64, 0, 0);
00457
00458
00459 fmap["dvbt_ofdm_cl0"] = new FrequencyTable(
00460 473000000, 803000000, 6000000, "Channel %1", 14,
00461 DTVInversion::kInversionAuto,
00462 DTVBandwidth::kBandwidthAuto, DTVCodeRate::kFEC_3_4,
00463 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00464 DTVTransmitMode::kTransmissionModeAuto,
00465 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00466 DTVModulation::kModulationQAMAuto, 143000, 0);
00467
00468
00469 fmap["dvbc_qam_de0"] = new FrequencyTable(
00470 73000000, 73000000, 8000000, "Channel D%1", 73,
00471 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00472 6900000, 0, 0);
00473 fmap["dvbc_qam_de1"] = new FrequencyTable(
00474 81000000, 81000000, 8000000, "Channel D%1", 81,
00475 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00476 6900000, 0, 0);
00477 fmap["dvbc_qam_de2"] = new FrequencyTable(
00478 113000000, 121000000, 8000000, "Channel S0%1", 2,
00479 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00480 6900000, 0, 0);
00481 fmap["dvbc_qam_de3"] = new FrequencyTable(
00482 306000000, 466000000, 8000000, "Channel S%1", 21,
00483 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00484 6900000, 0, 0);
00485 fmap["dvbc_qam_de4"] = new FrequencyTable(
00486 474000000, 858000000, 8000000, "Channel %1", 21,
00487 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00488 6900000, 0, 0);
00489
00490 fmap["dvbc_qam_gb0"] = new FrequencyTable(
00491 12324000, 12324000+1, 10, "Channel %1", 1,
00492 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAMAuto,
00493 29500000, 0, 0);
00494 fmap["dvbc_qam_gb1"] = new FrequencyTable(
00495 459000000, 459000000+1, 10, "Channel %1", 2,
00496 DTVCodeRate::kFEC_3_4, DTVModulation::kModulationQAM64,
00497 6952000, 0, 0);
00498
00499 fmap["dvbc_qam_bf0"] = new FrequencyTable(
00500 203000000, 795000000, 100000, "BF Channel %1", 1,
00501 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00502 6900000, 0, 0);
00503 fmap["dvbc_qam_bf1"] = new FrequencyTable(
00504 194750000, 794750000, 100000, "BF Channel %1", 1 + (795000-203000) / 100,
00505 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00506 6900000, 0, 0);
00507
00508
00509 #ifdef DEBUG_DVB_OFFSETS
00510
00511 fmap["atsc_vsb8_us0"] = new FrequencyTable(
00512 533000000, 803000000, 6000000, "xATSC Channel %1", 24,
00513 DTVInversion::kInversionOff,
00514 DTVBandwidth::kBandwidth7MHz, DTVCodeRate::kFECAuto,
00515 DTVCodeRate::kFECAuto, DTVModulation::kModulationQAMAuto,
00516 DTVTransmitMode::kTransmissionMode8K,
00517 DTVGuardInterval::kGuardIntervalAuto, DTVHierarchy::kHierarchyNone,
00518 DTVModulation::kModulation8VSB, -100000, 100000);
00519 #else // if !DEBUG_DVB_OFFSETS
00520
00521
00522 fmap["atsc_vsb8_us0"] = new FrequencyTable(
00523 "ATSC Channel %1", 2, 57000000, 69000000, 6000000,
00524 DTVModulation::kModulation8VSB);
00525
00526 fmap["atsc_vsb8_us1"] = new FrequencyTable(
00527 "ATSC Channel %1", 5, 79000000, 85000000, 6000000,
00528 DTVModulation::kModulation8VSB);
00529
00530 fmap["atsc_vsb8_us2"] = new FrequencyTable(
00531 "ATSC Channel %1", 7, 177000000, 213000000, 6000000,
00532 DTVModulation::kModulation8VSB);
00533
00534 fmap["atsc_vsb8_us3"] = new FrequencyTable(
00535 "ATSC Channel %1", 14, 473000000, 803000000, 6000000,
00536 DTVModulation::kModulation8VSB);
00537 #endif // !DEBUG_DVB_OFFSETS
00538
00539 QString modStr[] = { "vsb8", "qam256", "qam128", "qam64", };
00540 uint mod[] = { DTVModulation::kModulation8VSB,
00541 DTVModulation::kModulationQAM256,
00542 DTVModulation::kModulationQAM128,
00543 DTVModulation::kModulationQAM64, };
00544 QString desc[] = { "ATSC ", "QAM-256 ", "QAM-128 ", "QAM-64 ", };
00545
00546 #define FREQ(A,B, C,D, E,F,G, H, I) \
00547 fmap[QString("atsc_%1_us%2").arg(A).arg(B)] = \
00548 new FrequencyTable(C+D, E, F, G, H, I);
00549
00550
00551 #define US_MAX_CHAN 159
00552
00553
00554 #define EIA_542_FREQUENCY(A,B,C) ( ( A * ( 8 + C ) ) + B )
00555
00556 for (uint i = 0; i < 4; i++)
00557 {
00558
00559 FREQ(modStr[i], "cable0", desc[i], "Channel %1",
00560 2, 57000000, 69000000, 6000000, mod[i]);
00561 FREQ(modStr[i], "cable1", desc[i], "Channel %1",
00562 5, 79000000, 85000000, 6000000, mod[i]);
00563 FREQ(modStr[i], "cable2", desc[i], "Channel %1",
00564 7, 177000000, 213000000, 6000000, mod[i]);
00565 FREQ(modStr[i], "cable3", desc[i], "Channel %1",
00566 14, 123000000, 171000000, 6000000, mod[i]);
00567 FREQ(modStr[i], "cable4", desc[i], "Channel %1",
00568 23, 219000000, 645000000, 6000000, mod[i]);
00569 FREQ(modStr[i], "cable5", desc[i], "Channel %1",
00570 95, 93000000, 117000000, 6000000, mod[i]);
00571
00572
00573 FREQ(modStr[i], "cable6", desc[i], "Channel %1",
00574 100, 651000000,
00575 EIA_542_FREQUENCY(6000000, 3000000, US_MAX_CHAN),
00576 6000000, mod[i]);
00577 FREQ(modStr[i], "cable7", desc[i], "Channel T-%1",
00578 7, 8750000, 50750000, 6000000, mod[i]);
00579
00580
00581 FREQ(modStr[i], "cablehigh0", desc[i], "Channel %1",
00582 78, 549000000, 645000000, 6000000, mod[i]);
00583 FREQ(modStr[i], "cablehigh1", desc[i], "Channel %1",
00584 100, 651000000,
00585 EIA_542_FREQUENCY(6000000, 3000000, US_MAX_CHAN),
00586 6000000, mod[i]);
00587
00588
00589 FREQ(modStr[i], "hrc0", desc[i], "HRC %1",
00590 1, 73753600, 73753601, 6000300, mod[i]);
00591 FREQ(modStr[i], "hrc1", desc[i], "HRC %1",
00592 2, 55752700, 67753300, 6000300, mod[i]);
00593 FREQ(modStr[i], "hrc2", desc[i], "HRC %1",
00594 5, 79753900, 85754200, 6000300, mod[i]);
00595 FREQ(modStr[i], "hrc3", desc[i], "HRC %1",
00596 7, 175758700, 211760500, 6000300, mod[i]);
00597 FREQ(modStr[i], "hrc4", desc[i], "HRC %1",
00598 14, 121756000, 169758400, 6000300, mod[i]);
00599 FREQ(modStr[i], "hrc5", desc[i], "HRC %1",
00600 23, 217760800, 643782100, 6000300, mod[i]);
00601 FREQ(modStr[i], "hrc6", desc[i], "HRC %1",
00602 95, 91754500, 115755700, 6000300, mod[i]);
00603
00604
00605 FREQ(modStr[i], "hrc7", desc[i], "HRC %1",
00606 100, 649782400,
00607 EIA_542_FREQUENCY(6000300, 1750000, US_MAX_CHAN),
00608 6000300, mod[i]);
00609
00610
00611
00612 FREQ(modStr[i], "hrchigh0", desc[i], "HRC %1",
00613 76, 535776700, 643782100, 6000300, mod[i]);
00614 FREQ(modStr[i], "hrchigh1", desc[i], "HRC %1",
00615 100, 649782400,
00616 EIA_542_FREQUENCY(6000300, 1750000, US_MAX_CHAN),
00617 6000300, mod[i]);
00618
00619
00620 FREQ(modStr[i], "irc0", desc[i], "IRC %1",
00621 1, 75012500, 75012501, 6000000, mod[i]);
00622 FREQ(modStr[i], "irc1", desc[i], "IRC %1",
00623 2, 57012500, 69012500, 6000000, mod[i]);
00624 FREQ(modStr[i], "irc2", desc[i], "IRC %1",
00625 5, 81012500, 87012500, 6000000, mod[i]);
00626 FREQ(modStr[i], "irc3", desc[i], "IRC %1",
00627 7, 177012500, 213012500, 6000000, mod[i]);
00628 FREQ(modStr[i], "irc4", desc[i], "IRC %1",
00629 14, 123012500, 171012500, 6000000, mod[i]);
00630 FREQ(modStr[i], "irc5", desc[i], "IRC %1",
00631 23, 219012500, 327012500, 6000000, mod[i]);
00632 FREQ(modStr[i], "irc6", desc[i], "IRC %1",
00633 42, 333025000, 333025001, 6000000, mod[i]);
00634 FREQ(modStr[i], "irc7", desc[i], "IRC %1",
00635 43, 339012500, 645012500, 6000000, mod[i]);
00636 FREQ(modStr[i], "irc8", desc[i], "IRC %1",
00637 95, 93012500, 105012500, 6000000, mod[i]);
00638 FREQ(modStr[i], "irc9", desc[i], "IRC %1",
00639 98, 111025000, 117025000, 6000000, mod[i]);
00640
00641
00642 FREQ(modStr[i], "irc10", desc[i], "IRC %1",
00643 100, 651012500,
00644 EIA_542_FREQUENCY(6000000, 3012500, US_MAX_CHAN),
00645 6000000, mod[i]);
00646
00647
00648
00649 FREQ(modStr[i], "irchigh0", desc[i], "IRC %1",
00650 76, 537012500, 645012500, 6000000, mod[i]);
00651 FREQ(modStr[i], "irchigh1", desc[i], "IRC %1",
00652 100, 651012500,
00653 EIA_542_FREQUENCY(6000000, 3012500, US_MAX_CHAN),
00654 6000000, mod[i]);
00655 }
00656
00657
00658 for (struct CHANLISTS *ptr = chanlists; ptr->name ; ptr++)
00659 {
00660 QString tbl_name = ptr->name;
00661 for (uint i = 0; i < (uint)ptr->count; i++)
00662 {
00663 uint64_t freq = (ptr->list[i].freq * 1000LL) + 1750000;
00664 fmap[QString("analog_analog_%1%2").arg(tbl_name).arg(i)] =
00665 new FrequencyTable(
00666 QString("%1 %2").arg(tbl_name).arg(ptr->list[i].name), i+2,
00667 freq, freq + 3000000,
00668 6000000, DTVModulation::kModulationAnalog);
00669 }
00670 }
00671
00672 }
