blob: bff23153d01925ffcea2157bed9f850233a60319 [file] [log] [blame]
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: qianzhang@google.com (Qian Zhang)
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <inttypes.h>
#include "utility.h"
#include "channel_buffer.h"
#include "libhdhomerun/hdhomerun.h"
#include "hdhomerun_tuner.h"
#include "hdhomerun_dev.h"
#include "sagelog.h"
#define PARSE_TIMEOUT 2
#define CHANNE_SCAN_SRC "227.0.0.1"
#define CHANNEL_SCAN_PORT 6069
static volatile sig_atomic_t sigabort_flag = FALSE;
static volatile sig_atomic_t siginfo_flag = FALSE;
static const char *map_tbl[] = {"us-bcast", "us-cable", "us-hrc", "us-irc",
"au-bcast", "tw-bcast", "eu-bcast", 0x0};
static void sigabort_handler(int arg)
{
sigabort_flag = TRUE;
}
static void siginfo_handler(int arg)
{
siginfo_flag = TRUE;
}
static void register_signal_handlers(sig_t sigpipe_handler,
sig_t sigint_handler,
sig_t siginfo_handler)
{
#if defined(SIGPIPE)
signal(SIGPIPE, sigpipe_handler);
#endif
#if defined(SIGINT)
signal(SIGINT, sigint_handler);
#endif
#if defined(SIGINFO)
signal(SIGINFO, siginfo_handler);
#endif
}
// channel format: map:us-cable,auto:68
void *open_hdhr(char *name)
{
struct hdhomerun_device_t *hd;
hd = hdhomerun_device_create_from_str(name, NULL);
return hd;
}
void close_hdhr(void *device)
{
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
if (hd) {
hdhomerun_device_stream_stop(hd);
hdhomerun_device_destroy(hd);
}
}
int tune_channel(void *device, char *channel, char *program,
char *stream_target)
{
char channel_str[32] = "auto:";
char vchannel_str[16];
char channel_map[32];
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
int ret;
if (hd == NULL) {
printf("hdhomerun invalid handle\n");
return -1;
}
if (!get_string_by_name(channel, "vchan", vchannel_str, sizeof(vchannel_str),
NULL)) {
vchannel_str[0] = 0x0;
if (!get_string_by_name(channel, "auto", channel_str + 5,
sizeof(channel_str) - 5, NULL)) {
printf("hdhomerun %p invalid channel %s\n", device, channel);
return -1;
}
if (!get_string_by_name(channel, "map", channel_map, sizeof(channel_map),
NULL)) {
printf("hdhomerun %p invalid channel map %s\n", device, channel);
strncpy(channel_map, "us-cable", sizeof(channel_map));
}
if (program[0] == 0x0) {
printf("hdhomerun %p invalid channel program %s\n", device, program);
return -1;
}
ret = hdhomerun_device_set_tuner_channelmap(hd, channel_map);
if (ret < 0)
printf("hdhomerun failed to set tuner channel map %s\n", channel_map);
ret = hdhomerun_device_set_tuner_channel(hd, channel_str);
if (ret < 0)
printf("hdhomerun tuning failed:%s ret:%d\n", channel_str, ret);
ret = hdhomerun_device_set_tuner_program(hd, program);
if (ret <= 0)
printf("hdhomerun failed set program:%s ret:%d\n", program, ret);
} else {
ret = hdhomerun_device_set_tuner_vchannel(hd, vchannel_str);
if (ret < 0)
printf("hdhomerun tuning failed: vchannel:%s ret:%d\n", vchannel_str,
ret);
}
char target[64];
snprintf(target, sizeof(target), "%s ttl=2", stream_target);
ret = hdhomerun_device_set_tuner_target(hd, target);
if (ret < 0) {
printf("hdhomerun failed set target %s ret:%d\n", target, ret);
}
return ret;
}
int vchan_to_prog_num(char *streaminfo, unsigned int vchan_major,
unsigned int vchan_minor, unsigned int *prog_num)
{
char *line;
char *next_line;
unsigned int program_number;
unsigned int virtual_major, virtual_minor;
next_line = streaminfo;
while (1) {
line = next_line;
next_line = strchr(line, '\n');
if (!next_line) {
break;
}
*next_line++ = 0;
if (sscanf(line, "%u: %u.%u", &program_number, &virtual_major,
&virtual_minor) != 3) {
if (sscanf(line, "%u: %u", &program_number, &virtual_major) != 2) {
continue;
}
virtual_minor = 0;
}
if (vchan_major == virtual_major && vchan_minor == virtual_minor) {
*prog_num = program_number;
return 1;
}
}
return 0;
}
int tune_vchannel(void *device, unsigned int channel,
unsigned int vchannel_major, unsigned int vchannel_minor,
char *stream_target)
{
char channel_map[16];
char channel_str[16];
char program_str[16];
char target_str[64];
struct hdhomerun_device_t *hd;
struct hdhomerun_tuner_status_t ts;
char *streaminfo;
unsigned int program;
int i, ret;
hd = (struct hdhomerun_device_t *)device;
// Set tuner channel map to US broadcast
snprintf(channel_map, sizeof(channel_map), "us-bcast");
ret = hdhomerun_device_set_tuner_channelmap(hd, channel_map);
if (ret < 0) {
printf("hdhr:ERROR: set tuner channel map %s\n", channel_map);
goto out;
}
// Tune to physical channel
snprintf(channel_str, sizeof(channel_str), "auto:%u", channel);
ret = hdhomerun_device_set_tuner_channel(hd, channel_str);
if (ret <= 0) {
printf("hdhr:ERROR: set tuner channel %s\n", channel_str);
goto out;
}
// Wait for SER to hit 100% (max 3 secs)
usleep(500000);
for (i = 0; i < 10; i++) {
ret = hdhomerun_device_get_tuner_status(hd, NULL, &ts);
if (ret > 0 && ts.symbol_error_quality >= 100) {
break;
}
usleep(250000);
}
// Get MPEG2-TS stream info
ret = hdhomerun_device_get_tuner_streaminfo(hd, &streaminfo);
if (ret <= 0) {
printf("hdhr:ERROR: get tuner streaminfo\n");
goto out;
}
printf("hdhr:hdhomerun streaminfo:\n%s", streaminfo);
// Translate virtual channel (major.minor) to program number
ret = vchan_to_prog_num(streaminfo, vchannel_major, vchannel_minor, &program);
if (ret <= 0) {
printf("hdhr:ERROR: vchannel %d.%d not found in streaminfo\n",
vchannel_major, vchannel_minor);
goto out;
}
printf("hdhr:hdhomerun vchannel %u.%u -> program %u\n", vchannel_major,
vchannel_minor, program);
// Set tuner program
snprintf(program_str, sizeof(program_str), "%u", program);
ret = hdhomerun_device_set_tuner_program(hd, program_str);
if (ret <= 0) {
printf("hdhr:ERROR: set tuner program %s\n", program_str);
goto out;
}
// Set tuner stream target
snprintf(target_str, sizeof(target_str), "%s ttl=2", stream_target);
ret = hdhomerun_device_set_tuner_target(hd, target_str);
if (ret <= 0) {
printf("hdhr:ERROR: set tuner target %s\n", target_str);
}
out:
return ret;
}
// channel format: map:us-cable,auto:68
int stop_channel(void *device)
{
int ret;
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
if (hd == NULL) {
printf("hdhomerun invalid handle\n");
return -1;
}
ret = hdhomerun_device_set_tuner_channel(hd, "none");
if (ret < 0) {
printf("hdhomerun failed set channel none to stop streaming ret:%d\n",
ret);
}
ret = hdhomerun_device_set_tuner_vchannel(hd, "none");
if (ret < 0) {
printf("hdhomerun failed set vchannel none to stop streaming ret:%d\n",
ret);
}
ret = hdhomerun_device_set_tuner_target(hd, "none");
if (ret < 0) {
printf("hdhomerun failed set target none to stop streaming ret:%d\n", ret);
}
return ret;
}
char *get_unit_name(struct hdhr_tuner_t *ht, char *name, int size)
{
char *p = strchr(ht->name, '-');
if (p != NULL) {
int len = p - ht->name;
strncpy(name, ht->name, len);
name[len] = 0x0;
return name;
}
name[0] = 0x0;
return name;
}
static char *ip4_address(int ip4, char *buf, int size)
{
snprintf(buf, size, "%u.%u.%u.%u", (unsigned int)(ip4 >> 24) & 0xFF,
(unsigned int)(ip4 >> 16) & 0xFF, (unsigned int)(ip4 >> 8) & 0xFF,
(unsigned int)(ip4 >> 0) & 0xFF);
return buf;
}
int discover_device(struct hdhr_tuner_t *ht, int max_ht_num)
{
int i, k, num = 0;
struct hdhomerun_discover_device_t *device_info =
malloc(max_ht_num * sizeof(struct hdhomerun_discover_device_t));
int ret = hdhomerun_discover_find_devices_custom(
0, HDHOMERUN_DEVICE_TYPE_TUNER, -1, device_info, 16);
if (ret <= 0) {
free(device_info);
return 0;
}
// printf( "found %d hdhomerun device\n", ret );
for (i = 0; i < ret; i++) {
// printf( "ip:%x type:%x id:%x num:%d\n", device_info[i].ip_addr,
// device_info[i].device_type, device_info[i].device_id,
// device_info[i].tuner_count );
for (k = 0; k < device_info[i].tuner_count && num < max_ht_num; k++) {
snprintf(ht[num].name, sizeof(ht[num].name), "%X-%d",
device_info[i].device_id, k);
ip4_address(device_info[i].ip_addr, ht[num].ip, sizeof(ht[num].ip));
ht[num].type = device_info[i].device_type;
ht[num].cc_tuner = 0;
ht[num].model[0] = 0;
num++;
}
}
free(device_info);
return num;
}
static char *get_tune_string(char *result, char *tune_str, int tune_str_len)
{
int i = 0;
int ch;
while (map_tbl[i][0]) {
if (get_int_val_by_name(result, map_tbl[i], &ch, NULL) > 0) {
snprintf(tune_str, tune_str_len, "map:%s|auto:%d", map_tbl[i], ch);
return tune_str;
}
i++;
}
return "";
}
static int get_tune_channel(char *result)
{
int i = 0;
int ch;
while (map_tbl[i][0]) {
if (get_int_val_by_name(result, map_tbl[i], &ch, NULL) > 0) {
return ch;
}
i++;
}
return 0;
}
int scan_all(void *device, struct channel_entry_t *ce, int ce_num)
{
int found_channel = 0;
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
if (hd == NULL) {
printf("hdhomerun invalid handle\n");
return -1;
}
char *ret_error;
if (hdhomerun_device_tuner_lockkey_request(hd, &ret_error) <= 0) {
fprintf(stderr, "failed to lock tuner\n");
if (ret_error) {
fprintf(stderr, "%s\n", ret_error);
}
return -1;
}
hdhomerun_device_set_tuner_target(hd, "none");
char *channelmap;
if (hdhomerun_device_get_tuner_channelmap(hd, &channelmap) <= 0) {
fprintf(stderr, "failed to query channelmap from device\n");
return -1;
}
const char *channelmap_scan_group =
hdhomerun_channelmap_get_channelmap_scan_group(channelmap);
if (!channelmap_scan_group) {
fprintf(stderr, "unknown channelmap '%s'\n", channelmap);
return -1;
}
if (hdhomerun_device_channelscan_init(hd, channelmap_scan_group) <= 0) {
fprintf(stderr, "failed to initialize channel scan\n");
return -1;
}
register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler);
int ret = 0;
while (!sigabort_flag && found_channel < ce_num) {
struct hdhomerun_channelscan_result_t result;
char tune_str[32];
char channel_name[32];
int channel_num;
ret = hdhomerun_device_channelscan_advance(hd, &result);
if (ret <= 0) {
break;
}
ret = hdhomerun_device_channelscan_detect(hd, &result);
if (ret < 0) {
break;
}
if (ret == 0) {
continue;
}
if (0)
printf("LOCK: %s %s (ss=%u snq=%u seq=%u)\n",
get_tune_string(result.channel_str, tune_str, sizeof(tune_str)),
result.status.lock_str, result.status.signal_strength,
result.status.signal_to_noise_quality,
result.status.symbol_error_quality);
channel_num = get_tune_channel(result.channel_str);
int i;
for (i = 0; i < result.program_count; i++) {
struct hdhomerun_channelscan_program_t *program = &result.programs[i];
if (strstr(program->program_str, "encrypted") == NULL) {
int program_id = atoi(program->program_str);
if (!get_string_by_token(program->program_str, 2, channel_name,
sizeof(channel_name), NULL)) {
if (!get_string_by_token(program->program_str, 1, channel_name,
sizeof(channel_name), NULL))
snprintf(channel_name, sizeof(channel_name), "%d.%d", channel_num,
i);
else {
if (!strcmp(channel_name, "0"))
snprintf(channel_name, sizeof(channel_name), "%d.%d", channel_num,
i);
}
}
snprintf(
ce->dev_tuning, sizeof(ce->dev_tuning), "%s prog:%d",
get_tune_string(result.channel_str, tune_str, sizeof(tune_str)),
program_id);
strncpy(ce->ch_name, channel_name, sizeof(ce->ch_name));
strncpy(ce->dev_name, device, sizeof(ce->dev_name));
ce->ch = found_channel;
ce->frq = result.frequency;
ce->av_inf[0] = 0x0;
ce++;
if (++found_channel >= ce_num)
break;
printf("o");
}
}
printf(".");
fflush(stdout);
}
hdhomerun_device_tuner_lockkey_release(hd);
if (ret < 0) {
fprintf(stderr,
"communication error sending request to hdhomerun device\n");
}
return found_channel;
}
struct vchan_tbl_t *create_vchan_tbl(struct hdhr_tuner_t *ht)
{
struct vchan_tbl_t *vt = malloc(sizeof(struct vchan_tbl_t));
vt->ht = *ht;
vt->channel_size = 500;
vt->channel_num = 0;
vt->vchan = malloc(sizeof(struct vchan_t) * vt->channel_size);
memset(vt->vchan, 0x0, sizeof(struct vchan_t) * vt->channel_size);
return vt;
}
void release_vchan_tbl(struct vchan_tbl_t *vt)
{
if (vt->vchan)
free(vt->vchan);
free(vt);
}
int grow_vhcan_tbl(struct vchan_tbl_t *vt)
{
int new_channel_size = vt->channel_size + 100;
struct vchan_t *new_vchan_list =
malloc(sizeof(struct vchan_t) * new_channel_size);
if (new_vchan_list == NULL)
return 0;
memcpy(new_vchan_list, vt->vchan, vt->channel_size * sizeof(struct vchan_t));
free(vt->vchan);
vt->vchan = new_vchan_list;
vt->channel_size = new_channel_size;
return 1;
}
int tuner_input_sharing(struct hdhr_tuner_t *ht1, struct hdhr_tuner_t *ht2)
{
if (ht1->cc_tuner == 1 && !strcmp(ht1->ip, ht2->ip))
return 1;
return 0;
}
#ifdef TEST_APP
static int scan_channel(void *device, int index, struct channel_entry_t *ce,
int ce_channel_num, int ce_num)
{
int found_channel = 0;
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
if (hd == NULL) {
printf("hdhomerun invalid handle\n");
return -1;
}
char *ret_error;
if (hdhomerun_device_tuner_lockkey_request(hd, &ret_error) <= 0) {
fprintf(stderr, "failed to lock tuner\n");
if (ret_error) {
fprintf(stderr, "%s\n", ret_error);
}
return -1;
}
hdhomerun_device_set_tuner_target(hd, "none");
char *channelmap;
if (hdhomerun_device_get_tuner_channelmap(hd, &channelmap) <= 0) {
fprintf(stderr, "failed to query channelmap from device\n");
return -1;
}
const char *channelmap_scan_group =
hdhomerun_channelmap_get_channelmap_scan_group(channelmap);
if (!channelmap_scan_group) {
fprintf(stderr, "unknown channelmap '%s'\n", channelmap);
return -1;
}
if (hdhomerun_device_channelscan_init(hd, channelmap_scan_group) <= 0) {
fprintf(stderr, "failed to initialize channel scan\n");
return -1;
}
register_signal_handlers(sigabort_handler, sigabort_handler, siginfo_handler);
int ret = 0, i;
do {
struct hdhomerun_channelscan_result_t result;
char tune_str[32];
char channel_name[32];
int channel_num;
ret = hdhomerun_device_channelscan_at(hd, index, &result);
// ret = hdhomerun_device_channelscan_advance( hd, &result );
if (ret <= 0) {
break;
}
// skip duplicated channel
for (i = 0; i < ce_channel_num; i++) {
if (ce->frq == result.frequency)
break;
}
if (ce->frq == result.frequency)
break;
ret = hdhomerun_device_channelscan_detect(hd, &result);
if (ret < 0) {
break;
}
if (ret == 0) {
continue;
}
if (0)
printf("LOCK: %s %s (ss=%u snq=%u seq=%u)\n",
get_tune_string(result.channel_str, tune_str, sizeof(tune_str)),
result.status.lock_str, result.status.signal_strength,
result.status.signal_to_noise_quality,
result.status.symbol_error_quality);
channel_num = get_tune_channel(result.channel_str);
for (i = 0; i < result.program_count; i++) {
struct hdhomerun_channelscan_program_t *program = &result.programs[i];
if (strstr(program->program_str, "encrypted") == NULL) {
int program_id = atoi(program->program_str);
if (!get_string_by_token(program->program_str, 2, channel_name,
sizeof(channel_name), NULL)) {
if (!get_string_by_token(program->program_str, 1, channel_name,
sizeof(channel_name), NULL))
snprintf(channel_name, sizeof(channel_name), "%d.%d", channel_num,
i);
else {
if (!strcmp(channel_name, "0"))
snprintf(channel_name, sizeof(channel_name), "%d.%d", channel_num,
i);
}
}
struct channel_entry_t *ce_p = &ce[ce_channel_num];
snprintf(
ce->dev_tuning, sizeof(ce->dev_tuning), "%s prog:%d",
get_tune_string(result.channel_str, tune_str, sizeof(tune_str)),
program_id);
strncpy(ce_p->ch_name, channel_name, sizeof(ce_p->ch_name));
strncpy(ce_p->dev_name, device, sizeof(ce_p->dev_name));
ce_p->ch = found_channel + ce_channel_num;
ce_p->frq = result.frequency;
ce_p->av_inf[0] = 0x0;
char stream_tar[32];
snprintf(stream_tar, sizeof(stream_tar), "udp://%s:%u", CHANNE_SCAN_SRC,
CHANNEL_SCAN_PORT);
ret = tune_channel(hd, ce_p->dev_tuning, "", stream_tar);
if (ret > 0)
ret = parse_avinf(CHANNE_SCAN_SRC, CHANNEL_SCAN_PORT, ce_p->av_inf,
sizeof(ce_p->av_inf), PARSE_TIMEOUT);
if (ret > 0)
ret = strstr(ce_p->av_inf, "ENCRYPTED") == NULL &&
strstr(ce_p->av_inf, "NO-DATA") == NULL;
if (ret)
if (++ce_channel_num > ce_num)
break;
}
}
} while (0);
hdhomerun_device_tuner_lockkey_release(hd);
if (ret < 0) {
fprintf(stderr,
"communication error sending request to hdhomerun device\n");
}
return found_channel;
}
int scan_vchannel(void *device, int vchannel, struct channel_entry_t *ce)
{
int ret;
struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)device;
if (hd == NULL) {
sage_log((_LOG_ERROR, 3, "hdhomerun invalid handle."));
return -1;
}
ce->state = 1;
ce->ch = vchannel;
ce->frq = 0;
ce->av_inf[0] = 0x0;
char stream_tar[32];
snprintf(ce->ch_name, sizeof(ce->ch_name), "%d", vchannel);
snprintf(ce->dev_tuning, sizeof(ce->dev_tuning), "vchan:%d", vchannel);
snprintf(stream_tar, sizeof(stream_tar), "udp://%s:%u", CHANNE_SCAN_SRC,
CHANNEL_SCAN_PORT);
ret = tune_channel(device, ce->dev_tuning, "", stream_tar);
if (ret > 0)
ret = parse_avinf(CHANNE_SCAN_SRC, CHANNEL_SCAN_PORT, ce->av_inf,
sizeof(ce->av_inf), PARSE_TIMEOUT);
if (ret > 0)
ret = strstr(ce->av_inf, "ENCRYPTED") == NULL &&
strstr(ce->av_inf, "NO-DATA") == NULL;
if (ret <= 0) {
ce->state = 0;
return 0;
}
return 1;
}
static int _make_channel_entry_buffer(struct channel_entry_t *ce, char *buf,
int size)
{
int pos = 0;
pos += snprintf(buf + pos, size - pos, "ch:%03d ", ce->ch);
if (ce->ch_name[0])
pos += snprintf(buf + pos, size - pos, "name:%s ", ce->ch_name);
if (ce->src_ip[0] && ce->src_port)
pos += snprintf(buf + pos, size - pos, "ip:%s port:%d ", ce->src_ip,
ce->src_port);
if (ce->epg_id[0])
pos += snprintf(buf + pos, size - pos, "epg:%s ", ce->epg_id);
if (ce->dev_name[0])
pos += snprintf(buf + pos, size - pos, "dev:%s ", ce->dev_name);
if (ce->dev_tuning[0])
pos += snprintf(buf + pos, size - pos, "tune:%s ", ce->dev_tuning);
if (ce->av_inf[0])
pos += snprintf(buf + pos, size - pos, "av:\"%s\" ", ce->av_inf);
pos += snprintf(buf + pos, size - pos, "\n");
return pos;
}
static int _save_channel_entry(char *file_name, struct channel_entry_t *ce,
int num)
{
int i;
char buf[2048];
FILE *fp;
fp = fopen(file_name, "w");
if (fp == NULL) {
// printf( "Can't open file %s to save channel table, errno:%d\n",
// file_name, errno );
return -1;
}
fputs("#Google sagetv channel table ver 1.0., maximum 2048 bytes per line\n",
fp);
fprintf(fp, "total_channel:%d\n", num);
for (i = 0; i < num; i++) {
_make_channel_entry_buffer(ce, buf, sizeof(buf));
fputs(buf, fp);
ce++;
}
fclose(fp);
return 1;
}
int main(int argc, char *argv[])
{
int i, ret = 0;
int tuner_count = 0;
struct hdhr_tuner_t ht[16];
ret = discover_device(ht, 16);
printf("found tuners:%d\n", ret);
if (ret > 0) {
for (i = 0; i < ret; i++) {
// if a unit shares a source input in a device, copy data.
if (i > 0 && tuner_input_sharing(&ht[i - 1], &ht[i])) {
ht[i].cc_tuner = ht[i - 1].cc_tuner;
strncpy(ht[i].model, ht[i - 1].model, sizeof(ht[i].model));
} else
get_dev_model(&ht[i]);
printf("%d tuner:%s ip:%s type:%d cc:%d model:%s\n", i, ht[i].name,
ht[i].ip, ht[i].type, ht[i].cc_tuner, ht[i].model);
}
tuner_count = ret;
}
// test channel scan
if (0) {
time_t t0 = time(NULL);
struct channel_entry_t ce[400];
int channel_num = 0;
// channel_num = scan_all( "101007FD-0", ce, 400 );
for (i = 60; i <= 70; i++) {
ret = scan_channel("101007FD-1", i, ce, channel_num, 400);
if (ret < 0 || sigabort_flag)
break;
printf("find channe:%d\n", ret);
channel_num += ret;
}
printf("time:%ld\n", time(NULL) - t0);
_save_channel_entry("channel-scan.txt", ce, channel_num);
}
// test vchannel scan
if (0) {
struct hdhr_tuner_t *cc_ht = NULL;
for (i = 0; i < tuner_count; i++) {
if (ht[i].cc_tuner) {
cc_ht = &ht[i];
break;
}
}
if (cc_ht != NULL) {
time_t t0 = time(NULL);
struct vchan_tbl_t *vt = create_vchan_tbl(cc_ht);
ret = get_vchannel_list(vt);
if (ret > 0) {
int n;
int channel_num = 0;
struct channel_list_t *cl = create_channel_list(ret);
for (n = 1; n < vt->channel_num && channel_num < 500; n++) {
printf("TRACE %d %s\n", n, vt->vchan[n].guide_name);
ret = scan_vchannel(vt, n, cl);
if (ret > 0) {
struct channel_entry_t *ce_p = &cl->ce[channel_num];
snprintf(ce_p->dev_name, sizeof(ce_p->dev_name), "HDHR.%s", device,
sizeof(ce_p->dev_name));
channel_num++;
}
printf("TRACE channel %d, %d\n", channel_num, n);
}
_save_channel_entry("channel-scan.txt", cl);
}
release_vchan_tbl(vt);
printf("time:%ld\n", time(NULL) - t0);
}
}
// test tune
if (1) {
// printf( "tuning %s \n", device[i] );
char *dev_name = "1311A273-0"; //"101007FD-1";
// ret = tune_channel( dev_name, "map:us-cable|auto:68", "343",
// "udp://226.0.0.1:4096" );
ret = tune_channel(dev_name, "vchan:600", "", "udp://226.0.0.1:4096");
printf("hit enter to stop\n");
getchar();
ret = stop_channel(dev_name);
}
return ret;
}
#endif