list = &scanfile_regions_DVBC;
else if (!strcasecmp(type, "dvbs"))
list = &scanfile_regions_DVBS;
- else if (!strcasecmp(type, "atsc"))
- list = &scanfile_regions_ATSC;
+ else if (!strcasecmp(type, "atsc-t"))
+ list = &scanfile_regions_ATSC_T;
+ else if (!strcasecmp(type, "atsc-c"))
+ list = &scanfile_regions_ATSC_C;
else
return -EINVAL;
DVB_TYPE_T = 1, /* terrestrial */
DVB_TYPE_C, /* cable */
DVB_TYPE_S, /* satellite */
- DVB_TYPE_ATSC, /* terrestrial - north america */
- DVB_TYPE_LAST = DVB_TYPE_ATSC
+ DVB_TYPE_ATSC_T, /* terrestrial - north america */
+ DVB_TYPE_ATSC_C, /* cable - north america */
+ DVB_TYPE_LAST = DVB_TYPE_ATSC_C
} dvb_fe_type_t;
typedef enum dvb_fe_spectral_inversion {
const static struct strtab delsystab[] = {
{ "NONE", DVB_SYS_NONE },
+ { "DVB-C", DVB_SYS_DVBC_ANNEX_A },
{ "DVBC/ANNEX_A", DVB_SYS_DVBC_ANNEX_A },
{ "DVBC_ANNEX_A", DVB_SYS_DVBC_ANNEX_A },
+ { "ATSC-C", DVB_SYS_DVBC_ANNEX_B },
{ "DVBC/ANNEX_B", DVB_SYS_DVBC_ANNEX_B },
{ "DVBC_ANNEX_B", DVB_SYS_DVBC_ANNEX_B },
+ { "DVB-C/ANNEX-C",DVB_SYS_DVBC_ANNEX_C },
{ "DVBC/ANNEX_C", DVB_SYS_DVBC_ANNEX_C },
{ "DVBC_ANNEX_C", DVB_SYS_DVBC_ANNEX_C },
{ "DVBC_ANNEX_AC",DVB_SYS_DVBC_ANNEX_A }, /* for compatibility */
+ { "DVB-T", DVB_SYS_DVBT },
{ "DVBT", DVB_SYS_DVBT },
+ { "DVB-T2", DVB_SYS_DVBT2 },
{ "DVBT2", DVB_SYS_DVBT2 },
+ { "DVB-S", DVB_SYS_DVBS },
{ "DVBS", DVB_SYS_DVBS },
+ { "DVB-S2", DVB_SYS_DVBS2 },
{ "DVBS2", DVB_SYS_DVBS2 },
+ { "DVB-H", DVB_SYS_DVBH },
{ "DVBH", DVB_SYS_DVBH },
+ { "ISDB-T", DVB_SYS_ISDBT },
{ "ISDBT", DVB_SYS_ISDBT },
+ { "ISDB-S", DVB_SYS_ISDBS },
{ "ISDBS", DVB_SYS_ISDBS },
+ { "ISDB-C", DVB_SYS_ISDBC },
{ "ISDBC", DVB_SYS_ISDBC },
+ { "ATSC-T", DVB_SYS_ATSC },
{ "ATSC", DVB_SYS_ATSC },
+ { "ATSCM-H", DVB_SYS_ATSCMH },
{ "ATSCMH", DVB_SYS_ATSCMH },
{ "DTMB", DVB_SYS_DTMB },
{ "DMBTH", DVB_SYS_DTMB }, /* for compatibility */
{
switch (delsys) {
case DVB_SYS_DVBC_ANNEX_A:
- case DVB_SYS_DVBC_ANNEX_B:
case DVB_SYS_DVBC_ANNEX_C:
case DVB_SYS_ISDBC:
return DVB_TYPE_C;
return DVB_TYPE_S;
case DVB_SYS_ATSC:
case DVB_SYS_ATSCMH:
- return DVB_TYPE_ATSC;
+ return DVB_TYPE_ATSC_T;
+ case DVB_SYS_DVBC_ANNEX_B:
+ return DVB_TYPE_ATSC_C;
default:
return DVB_TYPE_NONE;
}
dvb_str2val(pol);
const static struct strtab typetab[] = {
- {"DVB-T", DVB_TYPE_T},
- {"DVB-C", DVB_TYPE_C},
- {"DVB-S", DVB_TYPE_S},
- {"ATSC", DVB_TYPE_ATSC},
+ {"DVB-T", DVB_TYPE_T},
+ {"DVB-C", DVB_TYPE_C},
+ {"DVB-S", DVB_TYPE_S},
+ {"ATSC-T", DVB_TYPE_ATSC_T},
+ {"ATSC-C", DVB_TYPE_ATSC_C}
};
dvb_str2val(type);
}
static int
-dvb_mux_conf_str_atsc ( dvb_mux_conf_t *dmc, char *buf, size_t bufsize )
+dvb_mux_conf_str_atsc_t ( dvb_mux_conf_t *dmc, char *buf, size_t bufsize )
{
return
snprintf(buf, bufsize,
case DVB_TYPE_T:
return dvb_mux_conf_str_dvbt(dmc, buf, bufsize);
case DVB_TYPE_C:
+ case DVB_TYPE_ATSC_C:
return dvb_mux_conf_str_dvbc(dmc, buf, bufsize);
case DVB_TYPE_S:
return dvb_mux_conf_str_dvbs(dmc, buf, bufsize);
- case DVB_TYPE_ATSC:
- return dvb_mux_conf_str_atsc(dmc, buf, bufsize);
+ case DVB_TYPE_ATSC_T:
+ return dvb_mux_conf_str_atsc_t(dmc, buf, bufsize);
default:
return
snprintf(buf, bufsize, "UNKNOWN MUX CONFIG");
case FE_OFDM:
return DVB_TYPE_T;
case FE_ATSC:
- return DVB_TYPE_ATSC;
+ return DVB_TYPE_ATSC_T;
default:
return DVB_TYPE_NONE;
}
}
/* Create frontend */
- linuxdvb_frontend_create(feconf, la, i, fe_path, dmx_path, dvr_path, type, dfi.name);
#if DVB_VER_ATLEAST(5,5)
memset(fetypes, 0, sizeof(fetypes));
- fetypes[type] = 1;
for (j = 0; j < cmd.u.buffer.len; j++) {
delsys = cmd.u.buffer.data[j];
type, dfi.name);
fetypes[type] = 1;
}
+#else
+ linuxdvb_frontend_create(feconf, la, i, fe_path, dmx_path, dvr_path, type, dfi.name);
#endif
pthread_mutex_unlock(&global_lock);
}
}
};
-const idclass_t linuxdvb_frontend_atsc_class =
+const idclass_t linuxdvb_frontend_atsc_t_class =
{
.ic_super = &linuxdvb_frontend_class,
- .ic_class = "linuxdvb_frontend_atsc",
- .ic_caption = N_("Linux ATSC frontend"),
+ .ic_class = "linuxdvb_frontend_atsc_t",
+ .ic_caption = N_("Linux ATSC-T frontend"),
+ .ic_properties = (const property_t[]){
+ {}
+ }
+};
+
+const idclass_t linuxdvb_frontend_atsc_c_class =
+{
+ .ic_super = &linuxdvb_frontend_class,
+ .ic_class = "linuxdvb_frontend_atsc_c",
+ .ic_caption = N_("Linux ATSC-C frontend"),
.ic_properties = (const property_t[]){
{}
}
#undef _OFDM
break;
case DVB_TYPE_C:
+ case DVB_TYPE_ATSC_C:
p.u.qam.symbol_rate = dmc->u.dmc_fe_qam.symbol_rate;
p.u.qam.fec_inner = TRU(qam.fec_inner, fec_tbl, FEC_AUTO);
p.u.qam.modulation = TR(modulation, mod_tbl, QAM_AUTO);
p.u.qpsk.symbol_rate = dmc->u.dmc_fe_qpsk.symbol_rate;
p.u.qpsk.fec_inner = TRU(qpsk.fec_inner, fec_tbl, FEC_AUTO);
break;
- case DVB_TYPE_ATSC:
+ case DVB_TYPE_ATSC_T:
p.u.vsb.modulation = TR(modulation, mod_tbl, QAM_AUTO);
break;
default:
idc = &linuxdvb_frontend_dvbc_class;
else if (type == DVB_TYPE_T)
idc = &linuxdvb_frontend_dvbt_class;
- else if (type == DVB_TYPE_ATSC)
- idc = &linuxdvb_frontend_atsc_class;
+ else if (type == DVB_TYPE_ATSC_T)
+ idc = &linuxdvb_frontend_atsc_t_class;
+ else if (type == DVB_TYPE_ATSC_C)
+ idc = &linuxdvb_frontend_atsc_c_class;
else {
tvherror("linuxdvb", "unknown FE type %d", type);
return NULL;
extern const idclass_t dvb_network_dvbt_class;
extern const idclass_t dvb_network_dvbc_class;
extern const idclass_t dvb_network_dvbs_class;
-extern const idclass_t dvb_network_atsc_class;
+extern const idclass_t dvb_network_atsc_t_class;
+extern const idclass_t dvb_network_atsc_c_class;
void dvb_network_init ( void );
void dvb_network_done ( void );
extern const idclass_t dvb_mux_dvbt_class;
extern const idclass_t dvb_mux_dvbc_class;
extern const idclass_t dvb_mux_dvbs_class;
-extern const idclass_t dvb_mux_atsc_class;
+extern const idclass_t dvb_mux_atsc_t_class;
+extern const idclass_t dvb_mux_atsc_c_class;
dvb_mux_t *dvb_mux_create0
(dvb_network_t *ln, uint16_t onid, uint16_t tsid,
{\
static const int t[] = { __VA_ARGS__ };\
int i;\
- htsmsg_t *m = htsmsg_create_list();\
- for (i = 0; i < ARRAY_SIZE(t); i++)\
- htsmsg_add_str(m, NULL, tvh_gettext_lang(lang, dvb_##l##2str(t[i])));\
+ htsmsg_t *m = htsmsg_create_list(), *e;\
+ for (i = 0; i < ARRAY_SIZE(t); i++) {\
+ e = htsmsg_create_map(); \
+ htsmsg_add_str(e, "key", dvb_##l##2str(t[i]));\
+ htsmsg_add_str(e, "val", tvh_gettext_lang(lang, dvb_##l##2str(t[i])));\
+ htsmsg_add_msg(m, NULL, e);\
+ }\
return m;\
}
#define MUX_PROP_STR(_id, _name, t, l, d)\
.ic_caption = N_("Linux DVB-T multiplex"),
.ic_properties = (const property_t[]){
{
- MUX_PROP_STR("delsys", N_("Delivery system"), dvbt, delsys, N_("DVB-T")),
+ MUX_PROP_STR("delsys", N_("Delivery system"), dvbt, delsys, "DVBT"),
},
{
.type = PT_U32,
#define dvb_mux_dvbc_class_delsys_get dvb_mux_class_delsys_get
#define dvb_mux_dvbc_class_delsys_set dvb_mux_class_delsys_set
+
static htsmsg_t *
dvb_mux_dvbc_class_delsys_enum (void *o, const char *lang)
{
htsmsg_t *list = htsmsg_create_list();
htsmsg_add_str(list, NULL, dvb_delsys2str(DVB_SYS_DVBC_ANNEX_A));
- htsmsg_add_str(list, NULL, dvb_delsys2str(DVB_SYS_DVBC_ANNEX_B));
htsmsg_add_str(list, NULL, dvb_delsys2str(DVB_SYS_DVBC_ANNEX_C));
return list;
}
.ic_caption = N_("Linux DVB-C multiplex"),
.ic_properties = (const property_t[]){
{
- MUX_PROP_STR("delsys", N_("Delivery system"), dvbc, delsys, N_("DVBC_ANNEX_AC")),
+ MUX_PROP_STR("delsys", N_("Delivery system"), dvbc, delsys, "DVB-C"),
},
{
.type = PT_U32,
}
};
-#define dvb_mux_atsc_class_delsys_get dvb_mux_class_delsys_get
-#define dvb_mux_atsc_class_delsys_set dvb_mux_class_delsys_set
+#define dvb_mux_atsc_t_class_delsys_get dvb_mux_class_delsys_get
+#define dvb_mux_atsc_t_class_delsys_set dvb_mux_class_delsys_set
static htsmsg_t *
-dvb_mux_atsc_class_delsys_enum (void *o, const char *lang)
+dvb_mux_atsc_t_class_delsys_enum (void *o, const char *lang)
{
htsmsg_t *list = htsmsg_create_list();
htsmsg_add_str(list, NULL, dvb_delsys2str(DVB_SYS_ATSC));
return list;
}
-dvb_mux_class_R(atsc, modulation, qam,
+dvb_mux_class_R(atsc_t, modulation, qam,
DVB_MOD_QAM_AUTO, DVB_MOD_QAM_256, DVB_MOD_VSB_8);
-const idclass_t dvb_mux_atsc_class =
+const idclass_t dvb_mux_atsc_t_class =
{
.ic_super = &dvb_mux_class,
- .ic_class = "dvb_mux_atsc",
- .ic_caption = N_("Linux ATSC multiplex"),
+ .ic_class = "dvb_mux_atsc_t",
+ .ic_caption = N_("Linux ATSC-T multiplex"),
.ic_properties = (const property_t[]){
{
- MUX_PROP_STR("delsys", N_("Delivery system"), atsc, delsys, N_("ATSC")),
+ MUX_PROP_STR("delsys", N_("Delivery system"), atsc_t, delsys, "ATSC-T"),
},
{
.type = PT_U32,
.set = dvb_mux_dvbt_class_frequency_set,
},
{
- MUX_PROP_STR("modulation", N_("Modulation"), atsc, qam, N_("AUTO"))
+ MUX_PROP_STR("modulation", N_("Modulation"), atsc_t, qam, N_("AUTO"))
+ },
+ {}
+ }
+};
+
+#define dvb_mux_atsc_c_class_delsys_get dvb_mux_class_delsys_get
+#define dvb_mux_atsc_c_class_delsys_set dvb_mux_class_delsys_set
+
+static htsmsg_t *
+dvb_mux_atsc_c_class_delsys_enum (void *o, const char *lang)
+{
+ htsmsg_t *list = htsmsg_create_list();
+ htsmsg_add_str(list, NULL, dvb_delsys2str(DVB_SYS_DVBC_ANNEX_B));
+ return list;
+}
+
+const idclass_t dvb_mux_atsc_c_class =
+{
+ .ic_super = &dvb_mux_class,
+ .ic_class = "dvb_mux_atsc_c",
+ .ic_caption = N_("Linux ATSC-C multiplex"),
+ .ic_properties = (const property_t[]){
+ {
+ MUX_PROP_STR("delsys", N_("Delivery system"), atsc_c, delsys, "ATSC-C"),
+ },
+ {
+ .type = PT_U32,
+ .id = "frequency",
+ .name = N_("Frequency (Hz)"),
+ .desc = N_("The frequency of the mux (in Hertz)."),
+ .off = offsetof(dvb_mux_t, lm_tuning.dmc_fe_freq),
+ .set = dvb_mux_dvbt_class_frequency_set,
+ },
+ {
+ .type = PT_U32,
+ .id = "symbolrate",
+ .name = N_("Symbol rate (Sym/s)"),
+ .desc = N_("The symbol rate."),
+ .off = offsetof(dvb_mux_t, lm_tuning.u.dmc_fe_qam.symbol_rate),
+ },
+ {
+ MUX_PROP_STR("constellation", N_("Constellation"), dvbc, qam, N_("AUTO"))
+ },
+ {
+ MUX_PROP_STR("fec", N_("FEC"), dvbc, fec, N_("AUTO"))
},
{}
}
} else if (ln->ln_type == DVB_TYPE_T) {
idc = &dvb_mux_dvbt_class;
delsys = DVB_SYS_DVBT;
- } else if (ln->ln_type == DVB_TYPE_ATSC) {
- idc = &dvb_mux_atsc_class;
+ } else if (ln->ln_type == DVB_TYPE_ATSC_T) {
+ idc = &dvb_mux_atsc_t_class;
delsys = DVB_SYS_ATSC;
+ } else if (ln->ln_type == DVB_TYPE_ATSC_C) {
+ idc = &dvb_mux_atsc_c_class;
+ delsys = DVB_SYS_DVBC_ANNEX_B;
} else {
tvherror("dvb", "unknown FE type %d", ln->ln_type);
return NULL;
return dvb_network_class_scanfile_list(o, lang, "dvbs");
}
static htsmsg_t *
-dvb_network_atsc_class_scanfile_list ( void *o, const char *lang )
+dvb_network_atsc_t_class_scanfile_list ( void *o, const char *lang )
{
- return dvb_network_class_scanfile_list(o, lang, "atsc");
+ return dvb_network_class_scanfile_list(o, lang, "atsc-t");
+}
+
+static htsmsg_t *
+dvb_network_atsc_c_class_scanfile_list ( void *o, const char *lang )
+{
+ return dvb_network_class_scanfile_list(o, lang, "atsc-c");
}
static const void *
}
};
-const idclass_t dvb_network_atsc_class =
+const idclass_t dvb_network_atsc_t_class =
+{
+ .ic_super = &dvb_network_class,
+ .ic_class = "dvb_network_atsc_t",
+ .ic_caption = N_("ATSC-T network"),
+ .ic_properties = (const property_t[]) {
+ {
+ .type = PT_STR,
+ .id = "scanfile",
+ .name = N_("Pre-defined muxes"),
+ .desc = N_("Use a pre-defined list of ATSC-T muxes. "
+ "Note: these lists can sometimes be outdated and "
+ "may cause scanning to take longer than usual."),
+ .set = dvb_network_class_scanfile_set,
+ .get = dvb_network_class_scanfile_get,
+ .list = dvb_network_atsc_t_class_scanfile_list,
+ .opts = PO_NOSAVE,
+ },
+ {}
+ }
+};
+
+const idclass_t dvb_network_atsc_c_class =
{
.ic_super = &dvb_network_class,
- .ic_class = "dvb_network_atsc",
- .ic_caption = N_("ATSC network"),
+ .ic_class = "dvb_network_atsc_c",
+ .ic_caption = N_("ATSC-C network"),
.ic_properties = (const property_t[]) {
{
.type = PT_STR,
.id = "scanfile",
.name = N_("Pre-defined muxes"),
- .desc = N_("Use a pre-defined list of ATSC muxes. "
+ .desc = N_("Use a pre-defined list of ATSC-C muxes. "
"Note: these lists can sometimes be outdated and "
"may cause scanning to take longer than usual."),
.set = dvb_network_class_scanfile_set,
.get = dvb_network_class_scanfile_get,
- .list = dvb_network_atsc_class_scanfile_list,
+ .list = dvb_network_atsc_c_class_scanfile_list,
.opts = PO_NOSAVE,
},
{}
return dvb_network_check_bandwidth(lm->lm_tuning.u.dmc_fe_ofdm.bandwidth,
dmc->u.dmc_fe_ofdm.bandwidth);
case DVB_TYPE_C:
+ case DVB_TYPE_ATSC_C:
return deltaU32(lm->lm_tuning.u.dmc_fe_qam.symbol_rate,
dmc->u.dmc_fe_qam.symbol_rate) > deltar;
case DVB_TYPE_S:
return deltaU32(lm->lm_tuning.u.dmc_fe_qpsk.symbol_rate,
dmc->u.dmc_fe_qpsk.symbol_rate) > deltar;
- case DVB_TYPE_ATSC:
+ case DVB_TYPE_ATSC_T:
return 0;
default:
return 0;
return &dvb_mux_dvbc_class;
if (idnode_is_instance(&mn->mn_id, &dvb_network_dvbs_class))
return &dvb_mux_dvbs_class;
- if (idnode_is_instance(&mn->mn_id, &dvb_network_atsc_class))
- return &dvb_mux_atsc_class;
+ if (idnode_is_instance(&mn->mn_id, &dvb_network_atsc_t_class))
+ return &dvb_mux_atsc_t_class;
+ if (idnode_is_instance(&mn->mn_id, &dvb_network_atsc_c_class))
+ return &dvb_mux_atsc_c_class;
return NULL;
}
save |= cls == &dvb_mux_dvbt_class && dmc->dmc_fe_type == DVB_TYPE_T;
save |= cls == &dvb_mux_dvbc_class && dmc->dmc_fe_type == DVB_TYPE_C;
save |= cls == &dvb_mux_dvbs_class && dmc->dmc_fe_type == DVB_TYPE_S;
- save |= cls == &dvb_mux_atsc_class && dmc->dmc_fe_type == DVB_TYPE_ATSC;
+ save |= cls == &dvb_mux_atsc_t_class && dmc->dmc_fe_type == DVB_TYPE_ATSC_T;
+ save |= cls == &dvb_mux_atsc_c_class && dmc->dmc_fe_type == DVB_TYPE_ATSC_C;
if (save && dmc->dmc_fe_type == DVB_TYPE_S) {
satpos = dvb_network_get_orbital_pos(mn);
/* do not allow to mix satellite positions */
&dvb_network_dvbt_class,
&dvb_network_dvbc_class,
&dvb_network_dvbs_class,
- &dvb_network_atsc_class,
+ &dvb_network_atsc_t_class,
+ &dvb_network_atsc_c_class,
};
void dvb_network_init ( void )
return &dvb_network_dvbc_class;
else if (type == DVB_TYPE_S)
return &dvb_network_dvbs_class;
- else if (type == DVB_TYPE_ATSC)
- return &dvb_network_atsc_class;
+ else if (type == DVB_TYPE_ATSC_T)
+ return &dvb_network_atsc_t_class;
+ else if (type == DVB_TYPE_ATSC_C)
+ return &dvb_network_atsc_c_class;
return NULL;
}
return DVB_TYPE_C;
else if (idc == &dvb_network_dvbs_class)
return DVB_TYPE_S;
- else if (idc == &dvb_network_atsc_class)
- return DVB_TYPE_ATSC;
+ else if (idc == &dvb_network_atsc_t_class)
+ return DVB_TYPE_ATSC_T;
+ else if (idc == &dvb_network_atsc_c_class)
+ return DVB_TYPE_ATSC_C;
return DVB_TYPE_NONE;
}
(mmd->lm_tuning.u.dmc_fe_qpsk.orbital_pos == DVB_POLARISATION_HORIZONTAL ? 0x8000 : 0);
break;
case DVB_TYPE_C:
+ case DVB_TYPE_ATSC_C:
hash = 0xFFFF0000;
break;
case DVB_TYPE_T:
hash = 0xEEEE0000;
break;
- case DVB_TYPE_ATSC:
+ case DVB_TYPE_ATSC_T:
hash = 0xDDDD0000;
break;
default:
} else if (strncmp(argv[i], "DVBC-", 5) == 0) {
type = DVB_TYPE_C;
m = atoi(argv[i] + 5);
- } else if (strncmp(argv[i], "ATSC-", 5) == 0) {
- type = DVB_TYPE_ATSC;
+ } else if (strncmp(argv[i], "ATSCT-", 5) == 0) {
+ type = DVB_TYPE_ATSC_T;
m = atoi(argv[i] + 5);
- } else if (strncmp(argv[i], "DVBCB-", 6) == 0) {
+ } else if (strncmp(argv[i], "ATSCC-", 6) == 0) {
+ type = DVB_TYPE_ATSC_C;
m = atoi(argv[i] + 6);
- v2 = 2;
}
if (type == DVB_TYPE_NONE) {
tvhlog(LOG_ERR, "satip", "%s: bad tuner type [%s]",
}
};
-const idclass_t satip_frontend_atsc_class =
+const idclass_t satip_frontend_atsc_t_class =
{
.ic_super = &satip_frontend_class,
- .ic_class = "satip_frontend_atsc",
- .ic_caption = N_("SAT>IP ATSC frontend"),
+ .ic_class = "satip_frontend_atsc_t",
+ .ic_caption = N_("SAT>IP ATSC-T frontend"),
+ .ic_properties = (const property_t[]){
+ {}
+ }
+};
+
+const idclass_t satip_frontend_atsc_c_class =
+{
+ .ic_super = &satip_frontend_class,
+ .ic_class = "satip_frontend_atsc_c",
+ .ic_caption = N_("SAT>IP ATSC-C frontend"),
.ic_properties = (const property_t[]){
{}
}
idc = &satip_frontend_dvbt_class;
else if (type == DVB_TYPE_C)
idc = &satip_frontend_dvbc_class;
- else if (type == DVB_TYPE_ATSC)
- idc = &satip_frontend_atsc_class;
+ else if (type == DVB_TYPE_ATSC_T)
+ idc = &satip_frontend_atsc_t_class;
+ else if (type == DVB_TYPE_ATSC_C)
+ idc = &satip_frontend_atsc_c_class;
else {
tvherror("satip", "unknown FE type %d", type);
return NULL;
scanfile_region_list_t scanfile_regions_DVBC;
scanfile_region_list_t scanfile_regions_DVBT;
scanfile_region_list_t scanfile_regions_DVBS;
-scanfile_region_list_t scanfile_regions_ATSC;
+scanfile_region_list_t scanfile_regions_ATSC_T;
+scanfile_region_list_t scanfile_regions_ATSC_C;
/* **************************************************************************
* Country codes
{
scanfile_region_t *reg;
scanfile_region_list_t *list = NULL;
- if (!strcmp(type, "dvb-s")) list = &scanfile_regions_DVBS;
- else if (!strcmp(type, "dvb-t")) list = &scanfile_regions_DVBT;
- else if (!strcmp(type, "dvb-c")) list = &scanfile_regions_DVBC;
- else if (!strcmp(type, "atsc")) list = &scanfile_regions_ATSC;
+ if (!strcmp(type, "dvb-s")) list = &scanfile_regions_DVBS;
+ else if (!strcmp(type, "dvb-t")) list = &scanfile_regions_DVBT;
+ else if (!strcmp(type, "dvb-c")) list = &scanfile_regions_DVBC;
+ else if (!strcmp(type, "atsc-t")) list = &scanfile_regions_ATSC_T;
+ else if (!strcmp(type, "atsc-c")) list = &scanfile_regions_ATSC_C;
if (!list) return NULL;
LIST_FOREACH(reg, list, sfr_link) {
return reg;
}
+/*
+ *
+ */
+static int
+scanfile_create_network
+ ( scanfile_network_t **_net, const char *type, const char *name,
+ dvb_fe_delivery_system_t delsys )
+{
+ scanfile_region_t *reg = NULL;
+ scanfile_network_t *net;
+ char buf[256], buf2[256], buf3[256], *str;
+ int opos;
+
+ /* Region */
+ strncpy(buf, name, sizeof(buf));
+ buf[sizeof(buf)-1] = '\0';
+ if (!strcmp(type, "dvb-s")) {
+ reg = scanfile_region_create(type, "geo", "Geo-synchronous Orbit");
+ } else {
+ str = buf;
+ while (*str) {
+ if (*str == '-') {
+ *str = '\0';
+ if (!strcmp(type, "atsc"))
+ type = delsys == DVB_SYS_ATSC ? "atsc-t" : "atsc-c";
+ reg = scanfile_region_create(type, buf, tldcode2longname(buf));
+ *str = '-';
+ break;
+ }
+ str++;
+ }
+ }
+ if (!reg)
+ return -1;
+
+ /* Network */
+ str = buf;
+ while (*str) {
+ if (!isprint(*str)) *str = '_';
+ str++;
+ }
+ *str = '\0';
+ opos = INT_MAX;
+ if (!strcmp(type, "dvb-s") && scanfile_network_dvbs_pos(buf, &opos)) {
+ snprintf(buf3, sizeof(buf3), "%c%3i.%i%c:%s", opos < 0 ? '<' : '>',
+ abs(opos) / 10, abs(opos) % 10,
+ opos < 0 ? 'W' :'E', buf);
+ strcpy(buf, buf3);
+ }
+ snprintf(buf2, sizeof(buf2), "%s_%s", type, buf);
+ net = calloc(1, sizeof(scanfile_network_t));
+ net->sfn_id = strdup(buf2);
+ net->sfn_name = strdup(buf);
+ net->sfn_satpos = opos;
+ LIST_INSERT_SORTED(®->sfr_networks, net, sfn_link, scanfile_network_cmp);
+
+ *_net = net;
+ return 0;
+}
+
/*
* Process mux entry
*/
-static void
-scanfile_load_one ( scanfile_network_t *net, const char *line )
+static int
+scanfile_load_one
+ ( scanfile_network_t **net, const char *type, const char *name, const char *line )
{
int r = 1;
dvb_mux_conf_t *mux = malloc(sizeof(dvb_mux_conf_t));
if (r) {
free(mux);
} else {
- LIST_INSERT_HEAD(&net->sfn_muxes, mux, dmc_link);
+ if (*net == NULL && scanfile_create_network(net, type, name, mux->dmc_fe_delsys))
+ return -1;
+ LIST_INSERT_HEAD(&(*net)->sfn_muxes, mux, dmc_link);
}
+ return 1;
}
/*
#define mux_ok(r) ((r) = ((r) > 0) ? 0 : (r))
static int
-scanfile_load_dvbv5 ( scanfile_network_t *net, char *line, fb_file *fp )
+scanfile_load_dvbv5
+ ( scanfile_network_t **net, const char *type, const char *name,
+ char *line, fb_file *fp )
{
int res = 1, r = 1;
char buf[256];
if ((mux->dmc_fe_inversion = dvb_str2inver(x)) == -1)
mux_fail(r, "wrong inversion '%s'", x);
if (htsmsg_get_u32(l, "SYMBOL_RATE", &mux->u.dmc_fe_qam.symbol_rate))
- mux_fail0(r, "dvb-c: undefined symbol rate");
+ mux->u.dmc_fe_qam.symbol_rate = 6900000;
} else if (mux->dmc_fe_delsys == DVB_SYS_ATSC) {
- mux->dmc_fe_type = DVB_TYPE_ATSC;
mux->dmc_fe_modulation = DVB_MOD_VSB_8;
if ((x = htsmsg_get_str(l, "MODULATION")))
} else {
dvb_mux_conf_str(mux, buf, sizeof(buf));
tvhtrace("scanfile", "mux %s", buf);
- LIST_INSERT_HEAD(&net->sfn_muxes, mux, dmc_link);
+ if (*net == NULL)
+ if (scanfile_create_network(net, type, name, mux->dmc_fe_delsys))
+ return -1;
+ LIST_INSERT_HEAD(&(*net)->sfn_muxes, mux, dmc_link);
}
return res;
scanfile_load_file
( const char *type, fb_dir *dir, const char *name )
{
- int opos, load;
fb_file *fp;
- scanfile_region_t *reg = NULL;
- scanfile_network_t *net;
- char *str;
- char buf[256], buf2[256], buf3[256];
+ scanfile_network_t *net = NULL;
+ char *str, buf[256];
+ int load = 0;
+
tvhtrace("scanfile", "load file %s", name);
fp = fb_open2(dir, name, 1, 0);
if (!fp) return;
- /* Region */
- strncpy(buf, name, sizeof(buf));
- buf[sizeof(buf)-1] = '\0';
- if (!strcmp(type, "dvb-s")) {
- reg = scanfile_region_create(type, "geo", "Geo-synchronous Orbit");
- } else {
- str = buf;
- while (*str) {
- if (*str == '-') {
- *str = '\0';
- reg = scanfile_region_create(type, buf, tldcode2longname(buf));
- *str = '-';
- break;
- }
- str++;
- }
- }
- if (!reg) {
- fb_close(fp);
- return;
- }
-
- /* Network */
- str = buf;
- while (*str) {
- if (!isprint(*str)) *str = '_';
- str++;
- }
- *str = '\0';
- opos = INT_MAX;
- if (!strcmp(type, "dvb-s") && scanfile_network_dvbs_pos(buf, &opos)) {
- snprintf(buf3, sizeof(buf3), "%c%3i.%i%c:%s", opos < 0 ? '<' : '>',
- abs(opos) / 10, abs(opos) % 10,
- opos < 0 ? 'W' :'E', buf);
- strcpy(buf, buf3);
- }
- snprintf(buf2, sizeof(buf2), "%s_%s", type, buf);
- net = calloc(1, sizeof(scanfile_network_t));
- net->sfn_id = strdup(buf2);
- net->sfn_name = strdup(buf);
- net->sfn_satpos = opos;
- LIST_INSERT_SORTED(®->sfr_networks, net, sfn_link, scanfile_network_cmp);
-
/* Process file */
load = 1;
- while (!fb_eof(fp)) {
+ while (!fb_eof(fp) && load >= 0) {
/* Get line */
if (load) {
buf[sizeof(buf)-1] = '\0';
if (!fb_gets(fp, buf, sizeof(buf) - 1)) break;
+ str = buf + strlen(buf) - 1;
if (buf[0])
- buf[strlen(buf)-1] = '\0';
- while (buf[0] && buf[strlen(buf)-1] <= ' ')
- buf[strlen(buf)-1] = '\0';
+ *(str--) = '\0';
+ while (buf[0] && *str <= ' ')
+ *(str--) = '\0';
}
- load = 1;
/* Process mux */
+ load = 1;
switch (*buf) {
case 'A':
case 'C':
case 'T':
case 'S':
- scanfile_load_one(net, buf);
+ load = scanfile_load_one(&net, type, name, buf);
break;
case '[':
- load = scanfile_load_dvbv5(net, buf, fp);
+ load = scanfile_load_dvbv5(&net, type, name, buf, fp);
break;
default:
break;
#endif
scanfile_load_dir(path, NULL, 0);
- r += scanfile_stats("DVB-T", &scanfile_regions_DVBT);
- r += scanfile_stats("DVB-S", &scanfile_regions_DVBS);
- r += scanfile_stats("DVB-C", &scanfile_regions_DVBC);
- r += scanfile_stats("ATSC", &scanfile_regions_ATSC);
+ r += scanfile_stats("DVB-T", &scanfile_regions_DVBT);
+ r += scanfile_stats("DVB-S", &scanfile_regions_DVBS);
+ r += scanfile_stats("DVB-C", &scanfile_regions_DVBC);
+ r += scanfile_stats("ATSC-T", &scanfile_regions_ATSC_T);
+ r += scanfile_stats("ATSC-C", &scanfile_regions_ATSC_C);
if (!r) {
tvhwarn("scanfile", "no predefined muxes found, check path '%s%s'",
path[0] == '/' ? path : TVHEADEND_DATADIR "/",
scanfile_done_region(&scanfile_regions_DVBS);
scanfile_done_region(&scanfile_regions_DVBT);
scanfile_done_region(&scanfile_regions_DVBC);
- scanfile_done_region(&scanfile_regions_ATSC);
+ scanfile_done_region(&scanfile_regions_ATSC_T);
+ scanfile_done_region(&scanfile_regions_ATSC_C);
}
/*
l = &scanfile_regions_DVBC;
else if (!strcasecmp(tok, "dvbs"))
l = &scanfile_regions_DVBS;
- else if (!strcasecmp(tok, "atsc"))
- l = &scanfile_regions_ATSC;
+ else if (!strcasecmp(tok, "atsc-t"))
+ l = &scanfile_regions_ATSC_T;
+ else if (!strcasecmp(tok, "atsc-c"))
+ l = &scanfile_regions_ATSC_C;
else
goto fail;
extern scanfile_region_list_t scanfile_regions_DVBC;
extern scanfile_region_list_t scanfile_regions_DVBT;
extern scanfile_region_list_t scanfile_regions_DVBS;
-extern scanfile_region_list_t scanfile_regions_ATSC;
+extern scanfile_region_list_t scanfile_regions_ATSC_T;
+extern scanfile_region_list_t scanfile_regions_ATSC_C;
void scanfile_init ( void );
void scanfile_done ( void );
const char *override_type = htsmsg_get_str(conf, "fe_override");
if ( override_type != NULL) {
type = dvb_str2type(override_type);
- if ( ! ( type == DVB_TYPE_C || type == DVB_TYPE_T || type == DVB_TYPE_ATSC ) ) {
+ if ( ! ( type == DVB_TYPE_C || type == DVB_TYPE_T || type == DVB_TYPE_ATSC_T ) ) {
type = DVB_TYPE_C;
}
}
} else {
if (strstr(hd->hd_info.deviceModel, "_atsc"))
- type = DVB_TYPE_ATSC;
+ type = DVB_TYPE_ATSC_T;
}
hd->hd_override_type = strdup(dvb_type2str(type));
}
};
-const idclass_t tvhdhomerun_frontend_atsc_class =
+const idclass_t tvhdhomerun_frontend_atsc_t_class =
{
.ic_super = &tvhdhomerun_frontend_class,
- .ic_class = "tvhdhomerun_frontend_atsc",
- .ic_caption = N_("HDHomeRun ATSC frontend"),
+ .ic_class = "tvhdhomerun_frontend_atsc_t",
+ .ic_caption = N_("HDHomeRun ATSC-T frontend"),
+ .ic_properties = (const property_t[]){
+ {}
+ }
+};
+
+const idclass_t tvhdhomerun_frontend_atsc_c_class =
+{
+ .ic_super = &tvhdhomerun_frontend_class,
+ .ic_class = "tvhdhomerun_frontend_atsc_c",
+ .ic_caption = N_("HDHomeRun ATSC-C frontend"),
.ic_properties = (const property_t[]){
{}
}
idc = &tvhdhomerun_frontend_dvbt_class;
else if (type == DVB_TYPE_C)
idc = &tvhdhomerun_frontend_dvbc_class;
- else if (type == DVB_TYPE_ATSC) {
- idc = &tvhdhomerun_frontend_atsc_class;
- } else {
+ else if (type == DVB_TYPE_ATSC_T)
+ idc = &tvhdhomerun_frontend_atsc_t_class;
+ else if (type == DVB_TYPE_ATSC_C)
+ idc = &tvhdhomerun_frontend_atsc_c_class;
+ else {
tvherror("stvhdhomerun", "unknown FE type %d", type);
return NULL;
}
goto result;
}
fe -= i;
- i = satip_server_conf.satip_atsc;
+ i = satip_server_conf.satip_atsc_t;
if (fe <= i) {
res = DVB_SYS_ATSC;
goto result;
}
fe -= i;
- i = satip_server_conf.satip_dvbcb;
+ i = satip_server_conf.satip_atsc_c;
if (fe <= i) {
res = DVB_SYS_DVBC_ANNEX_B;
goto result;
http_arg_list_t args;
struct xml_type_xtab xtab[] = {
- { "DVBS", &satip_server_conf.satip_dvbs, &dvbs },
- { "DVBS2", &satip_server_conf.satip_dvbs2, &dvbs },
- { "DVBT", &satip_server_conf.satip_dvbt, &dvbt },
- { "DVBT2", &satip_server_conf.satip_dvbt2, &dvbt },
- { "DVBC", &satip_server_conf.satip_dvbc, &dvbc },
- { "DVBC2", &satip_server_conf.satip_dvbc2, &dvbc },
- { "ATSC", &satip_server_conf.satip_atsc, &atsc },
- { "DVBCB", &satip_server_conf.satip_dvbcb, &dvbc },
+ { "DVBS", &satip_server_conf.satip_dvbs, &dvbs },
+ { "DVBS2", &satip_server_conf.satip_dvbs2, &dvbs },
+ { "DVBT", &satip_server_conf.satip_dvbt, &dvbt },
+ { "DVBT2", &satip_server_conf.satip_dvbt2, &dvbt },
+ { "DVBC", &satip_server_conf.satip_dvbc, &dvbc },
+ { "DVBC2", &satip_server_conf.satip_dvbc2, &dvbc },
+ { "ATSCT", &satip_server_conf.satip_atsc_t, &atsc },
+ { "ATSCC", &satip_server_conf.satip_atsc_c, &atsc },
{}
};
srcs = mn->mn_satip_source;
} else if (idnode_is_instance(&mn->mn_id, &dvb_network_dvbc_class))
dvbc++;
- else if (idnode_is_instance(&mn->mn_id, &dvb_network_atsc_class))
+ else if (idnode_is_instance(&mn->mn_id, &dvb_network_atsc_t_class))
atsc++;
else if (idnode_is_instance(&mn->mn_id, &iptv_network_class)) {
LIST_FOREACH(mm, &mn->mn_muxes, mm_network_link)
http_server_ip, http_server_port,
http_server_ip, satip_server_rtsp_port,
descramble, muxcnf);
- tvhinfo("satips", "SAT>IP Server tuners: DVB-T/T2 %d/%d, DVB-S/S2 %d/%d, DVB-C/C2 %d/%d, ATSC %d, DVB-Cable/AnnexB %d",
+ tvhinfo("satips", "SAT>IP Server tuners: DVB-T/T2 %d/%d, DVB-S/S2 %d/%d, DVB-C/C2 %d/%d, ATSC-T/C %d/%d",
satip_server_conf.satip_dvbt,
satip_server_conf.satip_dvbt2,
satip_server_conf.satip_dvbs,
satip_server_conf.satip_dvbs2,
satip_server_conf.satip_dvbc,
satip_server_conf.satip_dvbc2,
- satip_server_conf.satip_atsc,
- satip_server_conf.satip_dvbcb);
+ satip_server_conf.satip_atsc_t,
+ satip_server_conf.satip_atsc_c);
}
/*
.type = PT_INT,
.id = "satip_dvbs",
.name = N_("DVB-S"),
- .desc = N_("The number of DVB-S tuners to export."),
+ .desc = N_("The number of DVB-S (Satellite) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbs),
.group = 2,
},
.type = PT_INT,
.id = "satip_dvbs2",
.name = N_("DVB-S2"),
- .desc = N_("The number of DVB-S2 tuners to export."),
+ .desc = N_("The number of DVB-S2 (Satellite) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbs2),
.group = 2,
},
.type = PT_INT,
.id = "satip_dvbt",
.name = N_("DVB-T"),
- .desc = N_("The number of DVB-T tuners to export."),
+ .desc = N_("The number of DVB-T (Terresterial) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbt),
.group = 2,
},
.type = PT_INT,
.id = "satip_dvbt2",
.name = N_("DVB-T2"),
- .desc = N_("The number of DVB-T2 tuners to export."),
+ .desc = N_("The number of DVB-T2 (Terresterial) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbt2),
.group = 2,
},
.type = PT_INT,
.id = "satip_dvbc",
.name = N_("DVB-C"),
- .desc = N_("The number of DVB-C tuners to export."),
+ .desc = N_("The number of DVB-C (Cable) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbc),
.group = 2,
},
.type = PT_INT,
.id = "satip_dvbc2",
.name = N_("DVB-C2"),
- .desc = N_("The number of DVB-C2 tuners to export."),
+ .desc = N_("The number of DVB-C2 (Cable) tuners to export."),
.off = offsetof(struct satip_server_conf, satip_dvbc2),
.group = 2,
},
{
.type = PT_INT,
- .id = "satip_atsc",
- .name = N_("ATSC"),
- .desc = N_("The number of ATSC tuners to export."),
- .off = offsetof(struct satip_server_conf, satip_atsc),
+ .id = "satip_atsct",
+ .name = N_("ATSC-T"),
+ .desc = N_("The number of ATSC-T (Terresterial) tuners to export."),
+ .off = offsetof(struct satip_server_conf, satip_atsc_t),
.group = 2,
},
{
.type = PT_INT,
- .id = "satip_dvbc2",
- .name = N_("DVB-Cable/AnnexB"),
- .desc = N_("The number of DVB-Cable/AnnexB tuners to export."),
- .off = offsetof(struct satip_server_conf, satip_dvbcb),
+ .id = "satip_atscc",
+ .name = N_("ATSC-C"),
+ .desc = N_("The number of ATSC-C (Cable/AnnexB) tuners to export."),
+ .off = offsetof(struct satip_server_conf, satip_atsc_c),
.group = 2,
},
{}
int satip_dvbt2;
int satip_dvbc;
int satip_dvbc2;
- int satip_atsc;
- int satip_dvbcb;
+ int satip_atsc_t;
+ int satip_atsc_c;
char *satip_nat_ip;
};
projects / thirdparty / tvheadend.git / commitdiff
