int py_device_init(py_device_object *self, PyObject *args, PyObject *kwds) {
unsigned int device_id = HDHOMERUN_DEVICE_ID_WILDCARD;
unsigned int device_ip = 0;
unsigned int tuner = 0;
char *kwlist[] = {"device_ip", "device_id", "tuner", NULL};
int success;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "|III", kwlist, &device_ip, &device_id, &tuner))
return -1;
if(device_ip == 0 && device_id == HDHOMERUN_DEVICE_ID_WILDCARD) {
PyErr_SetString(hdhomerun_device_error, "Insufficient information provided to initialize instance");
return -1;
}
self->hd = hdhomerun_device_create(device_id, device_ip, 0, NULL);
if(!self->hd) {
PyErr_SetString(hdhomerun_device_error, "Failed to initialize Device object");
return -1;
}
success = hdhomerun_device_set_tuner(self->hd, tuner);
if(success == -1) {
PyErr_SetString(PyExc_IOError, DEVICE_ERR_COMMUNICATION);
return -1;
} else if(success == 0) {
PyErr_SetString(hdhomerun_device_error, "failed to set tuner number");
return -1;
} else if(success != 1) {
PyErr_SetString(hdhomerun_device_error, DEVICE_ERR_UNDOCUMENTED);
return -1;
}
self->locked = 0;
return 0;
}
bool HDHRDevice::openDevice()
{
mDeviceConnection = hdhomerun_device_create(mDeviceInfo.device_id, mDeviceInfo.ip_addr, mTunerIndex, NULL);
if(!mDeviceConnection) return false;
if(!mChannel)
mChannel = new DTVChannel(dynamic_cast <SageTuner*> (this), mChannelName, NULL, 0);
if(!mChannel) {
hdhomerun_device_destroy(mDeviceConnection);
mDeviceConnection = NULL;
return false;
}
mDeviceModel = hdhomerun_device_get_model_str(mDeviceConnection);
flog( "Native.log", "HDHomeRun Device(Tuner:\"%s\" Model:%s) is open\r\n", mChannelName, mDeviceModel );
return true;
}
static int hdhomerun_device_selector_load_from_str_discover(struct hdhomerun_device_selector_t *hds, uint32_t target_ip, uint32_t device_id)
{
struct hdhomerun_discover_device_t result;
int discover_count = hdhomerun_discover_find_devices_custom_v2(target_ip, HDHOMERUN_DEVICE_TYPE_TUNER, device_id, &result, 1);
if (discover_count != 1) {
return 0;
}
int count = 0;
unsigned int tuner_index;
for (tuner_index = 0; tuner_index < result.tuner_count; tuner_index++) {
struct hdhomerun_device_t *hd = hdhomerun_device_create(result.device_id, result.ip_addr, tuner_index, hds->dbg);
if (!hd) {
continue;
}
hdhomerun_device_selector_add_device(hds, hd);
count++;
}
return count;
}
static void tvhdhomerun_device_create(struct hdhomerun_discover_device_t *dInfo) {
tvhdhomerun_device_t *hd = calloc(1, sizeof(tvhdhomerun_device_t));
htsmsg_t *conf = NULL, *feconf = NULL;
char uhex[UUID_HEX_SIZE];
int j, save = 0;
struct hdhomerun_device_t *hdhomerun_tuner;
dvb_fe_type_t type = DVB_TYPE_C;
tvhdhomerun_device_calc_uuid(uhex, dInfo->device_id);
hdhomerun_tuner = hdhomerun_device_create(dInfo->device_id, dInfo->ip_addr, 0, NULL);
{
const char *deviceModel = hdhomerun_device_get_model_str(hdhomerun_tuner);
if(deviceModel != NULL) {
hd->hd_info.deviceModel = strdup(deviceModel);
}
hdhomerun_device_destroy(hdhomerun_tuner);
}
conf = hts_settings_load("input/tvhdhomerun/adapters/%s", uhex);
if ( conf != NULL ) {
const char *override_type = htsmsg_get_str(conf, "fe_override");
if ( override_type != NULL) {
if ( !strcmp(override_type, "ATSC" ) )
override_type = "ATSC-T";
type = dvb_str2type(override_type);
if ( ! ( type == DVB_TYPE_C || type == DVB_TYPE_T ||
type == DVB_TYPE_ATSC_T || type == DVB_TYPE_ATSC_C ) ) {
type = DVB_TYPE_C;
}
}
} else {
if (strstr(hd->hd_info.deviceModel, "_atsc"))
type = DVB_TYPE_ATSC_T;
}
hd->hd_override_type = strdup(dvb_type2str(type));
tvhinfo(LS_TVHDHOMERUN, "Using Network type : %s", hd->hd_override_type);
/* some sane defaults */
hd->hd_fullmux_ok = 1;
hd->hd_pids_len = 127;
hd->hd_pids_max = 32;
hd->hd_pids_deladd = 1;
if (!tvh_hardware_create0((tvh_hardware_t*)hd, &tvhdhomerun_device_class,
uhex, conf))
return;
TAILQ_INIT(&hd->hd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (hd->hd_info.uuid)
free(hd->hd_info.uuid);
char fName[128];
snprintf(fName, 128, "HDHomeRun(%08X)",dInfo->device_id);
memset(&hd->hd_info.ip_address, 0, sizeof(hd->hd_info.ip_address));
hd->hd_info.ip_address.ss_family = AF_INET;
((struct sockaddr_in *)&hd->hd_info.ip_address)->sin_addr.s_addr = htonl(dInfo->ip_addr);
hd->hd_info.uuid = strdup(uhex);
hd->hd_info.friendlyname = strdup(fName);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
for (j = 0; j < dInfo->tuner_count; ++j) {
if (tvhdhomerun_frontend_create(hd, dInfo, feconf, type, j)) {
tvhinfo(LS_TVHDHOMERUN, "Created frontend %08X tuner %d", dInfo->device_id, j);
} else {
tvherror(LS_TVHDHOMERUN, "Unable to create frontend-device. ( %08x-%d )", dInfo->device_id,j);
}
}
if (save)
tvhdhomerun_device_changed(hd);
htsmsg_destroy(conf);
}
int hdhomerun_device_selector_load_from_str(struct hdhomerun_device_selector_t *hds, char *device_str)
{
/*
* IP address based device_str.
*/
unsigned int a[4];
if (sscanf(device_str, "%u.%u.%u.%u", &a[0], &a[1], &a[2], &a[3]) == 4) {
uint32_t ip_addr = (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0));
/*
* Multicast IP address.
*/
unsigned int port;
if (sscanf(device_str, "%u.%u.%u.%u:%u", &a[0], &a[1], &a[2], &a[3], &port) == 5) {
struct hdhomerun_device_t *hd = hdhomerun_device_create_multicast(ip_addr, port, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* IP address + tuner number.
*/
unsigned int tuner;
if (sscanf(device_str, "%u.%u.%u.%u-%u", &a[0], &a[1], &a[2], &a[3], &tuner) == 5) {
struct hdhomerun_device_t *hd = hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, ip_addr, tuner, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* IP address only - discover and add tuners.
*/
return hdhomerun_device_selector_load_from_str_discover(hds, ip_addr, HDHOMERUN_DEVICE_ID_WILDCARD);
}
/*
* Device ID based device_str.
*/
char *end;
uint32_t device_id = (uint32_t)strtoul(device_str, &end, 16);
if ((end == device_str + 8) && hdhomerun_discover_validate_device_id(device_id)) {
/*
* IP address + tuner number.
*/
if (*end == '-') {
unsigned int tuner = (unsigned int)strtoul(end + 1, NULL, 10);
struct hdhomerun_device_t *hd = hdhomerun_device_create(device_id, 0, tuner, hds->dbg);
if (!hd) {
return 0;
}
hdhomerun_device_selector_add_device(hds, hd);
return 1;
}
/*
* Device ID only - discover and add tuners.
*/
return hdhomerun_device_selector_load_from_str_discover(hds, 0, device_id);
}
/*
* DNS based device_str.
*/
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
struct addrinfo *sock_info;
if (getaddrinfo(device_str, "65001", &hints, &sock_info) != 0) {
return 0;
}
struct sockaddr_in *sock_addr = (struct sockaddr_in *)sock_info->ai_addr;
uint32_t ip_addr = (uint32_t)ntohl(sock_addr->sin_addr.s_addr);
freeaddrinfo(sock_info);
if (ip_addr == 0) {
return 0;
}
return hdhomerun_device_selector_load_from_str_discover(hds, ip_addr, HDHOMERUN_DEVICE_ID_WILDCARD);
}
static void tvhdhomerun_device_create(struct hdhomerun_discover_device_t *dInfo) {
tvhdhomerun_device_t *hd = calloc(1, sizeof(tvhdhomerun_device_t));
htsmsg_t *conf = NULL, *feconf = NULL;
tvh_uuid_t uuid;
int j, save = 0;
struct hdhomerun_device_t *hdhomerun_tuner;
dvb_fe_type_t type = DVB_TYPE_C;
struct in_addr ip_addr;
tvhdhomerun_device_calc_uuid(&uuid, dInfo->device_id);
hdhomerun_tuner = hdhomerun_device_create(dInfo->device_id, dInfo->ip_addr, 0, NULL);
{
const char *deviceModel = hdhomerun_device_get_model_str(hdhomerun_tuner);
if(deviceModel != NULL) {
hd->hd_info.deviceModel = strdup(deviceModel);
}
hdhomerun_device_destroy(hdhomerun_tuner);
}
conf = hts_settings_load("input/tvhdhomerun/adapters/%s", uuid.hex);
if ( conf != NULL ) {
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 ) ) {
type = DVB_TYPE_C;
}
}
} else {
if (strstr(hd->hd_info.deviceModel, "_atsc"))
type = DVB_TYPE_ATSC;
}
hd->hd_override_type = strdup(dvb_type2str(type));
tvhlog(LOG_INFO, "tvheadend","Using Network type : %s", hd->hd_override_type);
/* some sane defaults */
hd->hd_fullmux_ok = 1;
hd->hd_pids_len = 127;
hd->hd_pids_max = 32;
hd->hd_pids_deladd = 1;
if (!tvh_hardware_create0((tvh_hardware_t*)hd, &tvhdhomerun_device_class,
uuid.hex, conf)) {
free(hd);
return;
}
TAILQ_INIT(&hd->hd_frontends);
/* we may check if uuid matches, but the SHA hash should be enough */
if (hd->hd_info.uuid)
free(hd->hd_info.uuid);
char fName[128];
snprintf(fName, 128, "HDHomeRun(%08X)",dInfo->device_id);
ip_addr.s_addr = htonl(dInfo->ip_addr);
hd->hd_info.ip_address = strdup(inet_ntoa(ip_addr));
hd->hd_info.uuid = strdup(uuid.hex);
hd->hd_info.friendlyname = strdup(fName);
if (conf)
feconf = htsmsg_get_map(conf, "frontends");
save = !conf || !feconf;
for (j = 0; j < dInfo->tuner_count; ++j) {
if (tvhdhomerun_frontend_create(hd, dInfo, feconf, type, j)) {
tvhlog(LOG_INFO, "tvhdhomerun", "Created frontend %08X tuner %d", dInfo->device_id, j);
} else {
tvhlog(LOG_ERR, "tvhdhomerun", "Unable to create frontend-device. ( %08x-%d )", dInfo->device_id,j);
}
}
if (save)
tvhdhomerun_device_save(hd);
htsmsg_destroy(conf);
}
