| // 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; |
| struct hdhomerun_channel_list_t *channel_list=NULL; |
| 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; |
| } |
| channel_list = hdhomerun_channel_list_create( channel_map ); |
| if ( channel_list == NULL ) { |
| printf( "hdhomerun failed to create channel map\n"); |
| 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-16",stream_target ); |
| ret = hdhomerun_device_set_tuner_target( hd, target ); |
| if ( ret < 0 ) { |
| printf( "hdhomerun failed set target %s ret:%d\n", target, ret ); |
| } |
| if ( channel_list ) |
| hdhomerun_channel_list_destroy( channel_list ); |
| |
| 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 dumplicated 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., maxium 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 ( 1 ) { |
| 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 |