hdhomerun_plugin.c - vendor/opensource/hdhomerun_plugin - Git at Google

 // 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 <assert.h>
 #include "utility.h"
 #include "hdhomerun_plugin.h"
 #include "libhdhomerun/hdhomerun.h"
 #include "hdhomerun_tuner.h"
 #include "hdhomerun_dev.h"
 #include "hdhomerun_tuner.h"
 #include "channel_buffer.h"
 #include "sagelog.h"

 #define MAX_TUNER_NUM 16

 struct device_list {
   int tuner_num;
   int list_num;
   struct hdhr_tuner_t *hdhrs;
 };

 static int discover_hdhrs(struct hdhr_tuner_t *ht, int max_ht_num)
 {
   int i, ret = 0;
   ret = discover_device(ht, max_ht_num);
   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]);
     }
     return i;
   }
   return 0;
 }

 void *dev_init(int *num)
 {
   int i, index = 0, tuner_num;
   struct device_list *devices;

   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun device init"));

   devices = (struct device_list *)malloc(sizeof(struct device_list));
   if (devices != NULL) {
     devices->hdhrs = (struct hdhr_tuner_t *)malloc(sizeof(struct hdhr_tuner_t) *
                                                    MAX_TUNER_NUM);
     memset(devices->hdhrs, 0,
            sizeof(sizeof(struct hdhr_tuner_t) * MAX_TUNER_NUM));
     if (devices->hdhrs == NULL) {
       free(devices);
       return 0;
     }
     devices->list_num = MAX_TUNER_NUM;
     devices->tuner_num = 0;
     tuner_num = discover_hdhrs(devices->hdhrs, MAX_TUNER_NUM);
     for (i = 0; i < tuner_num; i++) {
       devices->hdhrs[i].tuner_id = index++;
       snprintf(devices->hdhrs[i].tuner_name,
                sizeof(devices->hdhrs[i].tuner_name), "%s-%s",
                devices->hdhrs[i].model, devices->hdhrs[i].name);
       devices->tuner_num++;
       sage_log((_LOG_TRACE, 3, "hdhr:%d %s %s %s", i,
                 devices->hdhrs[i].tuner_name, devices->hdhrs[i].model,
                 devices->hdhrs[i].cc_tuner ? "CableCard" : ""));
     }
     devices->tuner_num = tuner_num;
     *num = tuner_num;
     return devices;
   }
   return NULL;
 }

 void dev_release(void *handle)
 {
   struct device_list *devices = (struct device_list *)handle;
   if (devices != NULL) {
     if (devices->hdhrs != NULL)
       free(devices->hdhrs);
     free(devices);
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun device release."));
 }

 int get_dev_name(void *handle, int index, char *name, int max_name_len)
 {
   struct device_list *devices = (struct device_list *)handle;
   if (devices != NULL && index < devices->tuner_num) {
     struct hdhr_tuner_t *hdhr = &devices->hdhrs[index];
     strncpy(name, hdhr->tuner_name, max_name_len);
     return 1;
   }
   return 0;
 }

 void *dev_open(void *handle, int index, int attr)
 {
   struct device_list *devices = (struct device_list *)handle;
   struct hdhr_tuner_t *hdhr;
   if (index >= devices->tuner_num)
     return NULL;
   hdhr = &devices->hdhrs[index];
   hdhr->hd = open_hdhr(hdhr->name);
   return hdhr;
 }

 void dev_close(void *dev)
 {
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return;
   }
   stop_channel(hdhr->hd);
   close_hdhr(hdhr->hd);
 }

 int dev_tune(void *dev, char *channel, char *stream_tar)
 {
   int ret;
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return 0;
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", hdhr->name,
             (char *)channel));
   if (strstr(stream_tar, "udp://") == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: stream target \"%s\" is wrong.",
               stream_tar));
     return 0;
   }

   if (hdhr->cc_tuner) {
     // HDHomeRun PRIME
     if (strstr(channel, "vchan:") == NULL) {
       char vchan[32];
       snprintf(vchan, sizeof(vchan), "vchan:%d", atoi(channel));
       ret = tune_channel(hdhr->hd, vchan, "", stream_tar);
     } else
       ret = tune_channel(hdhr->hd, channel, "", stream_tar);
   } else {
     // HDHomeRun US
     char tune_str[32], map_str[32], prog_str[8];
     int ch = -1, prog = -1, vch_major = -1, vch_minor = -1;
     char *ps, *pe;
     map_str[0] = 0x0;

     // channel format: xx-yy-zz
     // xx=physical channel, yy=virtual major channel, zz=virtual minor channel
     if (sscanf(channel, "%d-%d-%d", &ch, &vch_major, &vch_minor) == 3) {
       ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
       goto out;
     }

     // channel format: xx-yy
     // xx=physical channel, yy=virtual major channel
     if (sscanf(channel, "%d-%d", &ch, &vch_major) == 2) {
       vch_minor = 0;
       ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
       goto out;
     }

     // if channel in format "map:xxx-yy|auto:zzz prog:ppp"
     if ((ps = strstr(channel, "map:")) != NULL &&
         (pe = strchr(ps + 4, '|')) != NULL) {
       strncpy(map_str, ps + 4, pe - (ps + 4));
       map_str[pe - (ps + 4)] = 0x0;
     }
     get_int_val_by_name(channel, "auto", &ch, NULL);
     get_int_val_by_name(channel, "prog", &prog, NULL);
     if (prog == -1) {
       sage_log(
           (_LOG_TRACE, 3, "hdhr:ERROR: invalid channel string %s", channel));
       return 0;
     }
     // if channel in format "nnn prog:mmm", based on dev to guess map
     if (map_str[0] == 0x0 && prog > 0 && ch == -1) {
       ch = atoi(channel);
       if (ch > 0) {
         snprintf(map_str, sizeof(map_str), "map:us-bcast");
       }
     }
     if (map_str[0] && ch > 0 && prog > 0) {
       snprintf(tune_str, sizeof(tune_str), "%s|auto:%d", map_str, ch);
       snprintf(prog_str, sizeof(prog), "%d", prog);
       ret = tune_channel(hdhr->hd, tune_str, prog_str, stream_tar);
     } else {
       sage_log(
           (_LOG_ERROR, 3, "hdhr:ERROR: invalid channel string %s", channel));
       return 0;
     }
   }

 out:
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", (char *)channel,
             ret > 0 ? "successful" : "failed"));
   return ret > 0;
 }

 int dev_stop(void *dev)
 {
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return 0;
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun stop %s.", (char *)hdhr->name));
   int ret = stop_channel(hdhr->hd);
   return ret > 0;
 }

 int dev_scan(void *dev, char *tuner_name, char *channel,
              struct channel_list_t **cl_p)
 {
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return 0;
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun scan %s.", (char *)hdhr->name));
   if (hdhr->cc_tuner) {
     int vchannel;
     char *p;
     if ((p = strstr(channel, "vchan:")) == NULL)
       vchannel = atoi(channel);
     else
       vchannel = atoi(p + 6);
     if (vchannel == 0)
       return 0;

     struct channel_list_t *cl = _create_channel_list(1);
     int ret = scan_vchannel(hdhr->hd, vchannel, cl->ce);
     char unit_name[16];
     snprintf(cl->ce[0].dev_name, sizeof(cl->ce[0].dev_name) - 1, "HDHR.%s",
              get_unit_name(hdhr, unit_name, sizeof(unit_name)));
     cl->channel_num = ret;
     if (ret == 0) {
       _release_channel_list(cl);
       cl = NULL;
     }
     if (cl_p != NULL)
       *cl_p = cl;
     return ret;
   } else {
     sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun ATSC dev_scan not implemented %s.",
               (char *)hdhr->name));
   }

   return 0;
 }

 static struct channel_list_t *build_hdhr_channel_table(
     struct hdhr_tuner_t *hdhr)
 {
   if (hdhr->cc_tuner) {
     struct vchan_tbl_t *vt = create_vchan_tbl(hdhr);
     struct channel_list_t *cl = NULL;
     if (get_vchannel_list(vt) > 0) {
       int num = vt->channel_num;
       cl = _create_channel_list(num);
       int i;
       for (i = 0; i < num; i++) {
         char unit_name[16];
         cl->ce[i].state = 1;
         snprintf(cl->ce[i].dev_tuning, sizeof(cl->ce[i].dev_tuning) - 1,
                  "vchan:%d", vt->vchan[i].guide_id);
         snprintf(cl->ce[i].ch_name, sizeof(cl->ce[i].ch_name) - 1, "%d",
                  vt->vchan[i].guide_id);
         strncpy(cl->ce[i].ch_desc, vt->vchan[i].guide_name,
                 sizeof(cl->ce[i].ch_desc) - 1);
         cl->ce[i].src_ip[0] = 0x0;
         cl->ce[i].src_port = 0;  // dynamic assigning
         snprintf(cl->ce[i].dev_name, sizeof(cl->ce[i].dev_name) - 1, "HDHR.%s",
                  get_unit_name(hdhr, unit_name, sizeof(unit_name)));
         cl->ce[i].ch = vt->vchan[i].guide_id;
         cl->ce[i].frq = 0;
         cl->ce[i].av_inf[0] = 0;
       }
       cl->channel_num = i;
     }
     release_vchan_tbl(vt);
     return cl;
   } else {
     sage_log(
         (_LOG_TRACE, 3,
          "hdhr:hdhomerun ATSC build_hdhr_channel_table not implemented %s.",
          (char *)hdhr->name));
   }
   return NULL;
 }

 int dev_build_channel_table(void *dev, char *option,
                             struct channel_list_t **cl_p)
 {
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return 0;
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun dev_build_channel_table %s.",
             (char *)hdhr->name));
   struct channel_list_t *cl = build_hdhr_channel_table(hdhr);
   if (cl_p != NULL) {
     *cl_p = cl;
     if (cl == NULL)
       return 0;
     return cl->channel_num;
   }
   return 0;
 }

 int dev_release_channel_table(void *dev)
 {
   struct hdhr_tuner_t *hdhr = (struct hdhr_tuner_t *)dev;
   if (hdhr == NULL) {
     sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
     return 0;
   }
   sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun dev_release_channel_table %s.",
             (char *)hdhr->name));
   if (hdhr->channel_table != NULL) {
     free(hdhr->channel_table);
     hdhr->channel_table = NULL;
     return 1;
   } else {  // TODO
   }
   return 0;
 }
	// 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 <assert.h>
	#include "utility.h"
	#include "hdhomerun_plugin.h"
	#include "libhdhomerun/hdhomerun.h"
	#include "hdhomerun_tuner.h"
	#include "hdhomerun_dev.h"
	#include "hdhomerun_tuner.h"
	#include "channel_buffer.h"
	#include "sagelog.h"

	#define MAX_TUNER_NUM 16

	struct device_list {
	int tuner_num;
	int list_num;
	struct hdhr_tuner_t *hdhrs;
	};

	static int discover_hdhrs(struct hdhr_tuner_t *ht, int max_ht_num)
	{
	int i, ret = 0;
	ret = discover_device(ht, max_ht_num);
	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]);
	}
	return i;
	}
	return 0;
	}

	void dev_init(int num)
	{
	int i, index = 0, tuner_num;
	struct device_list *devices;

	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun device init"));

	devices = (struct device_list *)malloc(sizeof(struct device_list));
	if (devices != NULL) {
	devices->hdhrs = (struct hdhr_tuner_t )malloc(sizeof(struct hdhr_tuner_t)
	MAX_TUNER_NUM);
	memset(devices->hdhrs, 0,
	sizeof(sizeof(struct hdhr_tuner_t) * MAX_TUNER_NUM));
	if (devices->hdhrs == NULL) {
	free(devices);
	return 0;
	}
	devices->list_num = MAX_TUNER_NUM;
	devices->tuner_num = 0;
	tuner_num = discover_hdhrs(devices->hdhrs, MAX_TUNER_NUM);
	for (i = 0; i < tuner_num; i++) {
	devices->hdhrs[i].tuner_id = index++;
	snprintf(devices->hdhrs[i].tuner_name,
	sizeof(devices->hdhrs[i].tuner_name), "%s-%s",
	devices->hdhrs[i].model, devices->hdhrs[i].name);
	devices->tuner_num++;
	sage_log((_LOG_TRACE, 3, "hdhr:%d %s %s %s", i,
	devices->hdhrs[i].tuner_name, devices->hdhrs[i].model,
	devices->hdhrs[i].cc_tuner ? "CableCard" : ""));
	}
	devices->tuner_num = tuner_num;
	*num = tuner_num;
	return devices;
	}
	return NULL;
	}

	void dev_release(void *handle)
	{
	struct device_list devices = (struct device_list )handle;
	if (devices != NULL) {
	if (devices->hdhrs != NULL)
	free(devices->hdhrs);
	free(devices);
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun device release."));
	}

	int get_dev_name(void handle, int index, char name, int max_name_len)
	{
	struct device_list devices = (struct device_list )handle;
	if (devices != NULL && index < devices->tuner_num) {
	struct hdhr_tuner_t *hdhr = &devices->hdhrs[index];
	strncpy(name, hdhr->tuner_name, max_name_len);
	return 1;
	}
	return 0;
	}

	void dev_open(void handle, int index, int attr)
	{
	struct device_list devices = (struct device_list )handle;
	struct hdhr_tuner_t *hdhr;
	if (index >= devices->tuner_num)
	return NULL;
	hdhr = &devices->hdhrs[index];
	hdhr->hd = open_hdhr(hdhr->name);
	return hdhr;
	}

	void dev_close(void *dev)
	{
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return;
	}
	stop_channel(hdhr->hd);
	close_hdhr(hdhr->hd);
	}

	int dev_tune(void dev, char channel, char *stream_tar)
	{
	int ret;
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return 0;
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", hdhr->name,
	(char *)channel));
	if (strstr(stream_tar, "udp://") == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: stream target \"%s\" is wrong.",
	stream_tar));
	return 0;
	}

	if (hdhr->cc_tuner) {
	// HDHomeRun PRIME
	if (strstr(channel, "vchan:") == NULL) {
	char vchan[32];
	snprintf(vchan, sizeof(vchan), "vchan:%d", atoi(channel));
	ret = tune_channel(hdhr->hd, vchan, "", stream_tar);
	} else
	ret = tune_channel(hdhr->hd, channel, "", stream_tar);
	} else {
	// HDHomeRun US
	char tune_str[32], map_str[32], prog_str[8];
	int ch = -1, prog = -1, vch_major = -1, vch_minor = -1;
	char ps, pe;
	map_str[0] = 0x0;

	// channel format: xx-yy-zz
	// xx=physical channel, yy=virtual major channel, zz=virtual minor channel
	if (sscanf(channel, "%d-%d-%d", &ch, &vch_major, &vch_minor) == 3) {
	ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
	goto out;
	}

	// channel format: xx-yy
	// xx=physical channel, yy=virtual major channel
	if (sscanf(channel, "%d-%d", &ch, &vch_major) == 2) {
	vch_minor = 0;
	ret = tune_vchannel(hdhr->hd, ch, vch_major, vch_minor, stream_tar);
	goto out;
	}

	// if channel in format "map:xxx-yy\|auto:zzz prog:ppp"
	if ((ps = strstr(channel, "map:")) != NULL &&
	(pe = strchr(ps + 4, '\|')) != NULL) {
	strncpy(map_str, ps + 4, pe - (ps + 4));
	map_str[pe - (ps + 4)] = 0x0;
	}
	get_int_val_by_name(channel, "auto", &ch, NULL);
	get_int_val_by_name(channel, "prog", &prog, NULL);
	if (prog == -1) {
	sage_log(
	(_LOG_TRACE, 3, "hdhr:ERROR: invalid channel string %s", channel));
	return 0;
	}
	// if channel in format "nnn prog:mmm", based on dev to guess map
	if (map_str[0] == 0x0 && prog > 0 && ch == -1) {
	ch = atoi(channel);
	if (ch > 0) {
	snprintf(map_str, sizeof(map_str), "map:us-bcast");
	}
	}
	if (map_str[0] && ch > 0 && prog > 0) {
	snprintf(tune_str, sizeof(tune_str), "%s\|auto:%d", map_str, ch);
	snprintf(prog_str, sizeof(prog), "%d", prog);
	ret = tune_channel(hdhr->hd, tune_str, prog_str, stream_tar);
	} else {
	sage_log(
	(_LOG_ERROR, 3, "hdhr:ERROR: invalid channel string %s", channel));
	return 0;
	}
	}

	out:
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun tune %s %s.", (char *)channel,
	ret > 0 ? "successful" : "failed"));
	return ret > 0;
	}

	int dev_stop(void *dev)
	{
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return 0;
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun stop %s.", (char *)hdhr->name));
	int ret = stop_channel(hdhr->hd);
	return ret > 0;
	}

	int dev_scan(void dev, char tuner_name, char *channel,
	struct channel_list_t **cl_p)
	{
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return 0;
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun scan %s.", (char *)hdhr->name));
	if (hdhr->cc_tuner) {
	int vchannel;
	char *p;
	if ((p = strstr(channel, "vchan:")) == NULL)
	vchannel = atoi(channel);
	else
	vchannel = atoi(p + 6);
	if (vchannel == 0)
	return 0;

	struct channel_list_t *cl = _create_channel_list(1);
	int ret = scan_vchannel(hdhr->hd, vchannel, cl->ce);
	char unit_name[16];
	snprintf(cl->ce[0].dev_name, sizeof(cl->ce[0].dev_name) - 1, "HDHR.%s",
	get_unit_name(hdhr, unit_name, sizeof(unit_name)));
	cl->channel_num = ret;
	if (ret == 0) {
	_release_channel_list(cl);
	cl = NULL;
	}
	if (cl_p != NULL)
	*cl_p = cl;
	return ret;
	} else {
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun ATSC dev_scan not implemented %s.",
	(char *)hdhr->name));
	}

	return 0;
	}

	static struct channel_list_t *build_hdhr_channel_table(
	struct hdhr_tuner_t *hdhr)
	{
	if (hdhr->cc_tuner) {
	struct vchan_tbl_t *vt = create_vchan_tbl(hdhr);
	struct channel_list_t *cl = NULL;
	if (get_vchannel_list(vt) > 0) {
	int num = vt->channel_num;
	cl = _create_channel_list(num);
	int i;
	for (i = 0; i < num; i++) {
	char unit_name[16];
	cl->ce[i].state = 1;
	snprintf(cl->ce[i].dev_tuning, sizeof(cl->ce[i].dev_tuning) - 1,
	"vchan:%d", vt->vchan[i].guide_id);
	snprintf(cl->ce[i].ch_name, sizeof(cl->ce[i].ch_name) - 1, "%d",
	vt->vchan[i].guide_id);
	strncpy(cl->ce[i].ch_desc, vt->vchan[i].guide_name,
	sizeof(cl->ce[i].ch_desc) - 1);
	cl->ce[i].src_ip[0] = 0x0;
	cl->ce[i].src_port = 0; // dynamic assigning
	snprintf(cl->ce[i].dev_name, sizeof(cl->ce[i].dev_name) - 1, "HDHR.%s",
	get_unit_name(hdhr, unit_name, sizeof(unit_name)));
	cl->ce[i].ch = vt->vchan[i].guide_id;
	cl->ce[i].frq = 0;
	cl->ce[i].av_inf[0] = 0;
	}
	cl->channel_num = i;
	}
	release_vchan_tbl(vt);
	return cl;
	} else {
	sage_log(
	(_LOG_TRACE, 3,
	"hdhr:hdhomerun ATSC build_hdhr_channel_table not implemented %s.",
	(char *)hdhr->name));
	}
	return NULL;
	}

	int dev_build_channel_table(void dev, char option,
	struct channel_list_t **cl_p)
	{
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return 0;
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun dev_build_channel_table %s.",
	(char *)hdhr->name));
	struct channel_list_t *cl = build_hdhr_channel_table(hdhr);
	if (cl_p != NULL) {
	*cl_p = cl;
	if (cl == NULL)
	return 0;
	return cl->channel_num;
	}
	return 0;
	}

	int dev_release_channel_table(void *dev)
	{
	struct hdhr_tuner_t hdhr = (struct hdhr_tuner_t )dev;
	if (hdhr == NULL) {
	sage_log((_LOG_TRACE, 3, "hdhr:ERROR: invalid device handle."));
	return 0;
	}
	sage_log((_LOG_TRACE, 3, "hdhr:hdhomerun dev_release_channel_table %s.",
	(char *)hdhr->name));
	if (hdhr->channel_table != NULL) {
	free(hdhr->channel_table);
	hdhr->channel_table = NULL;
	return 1;
	} else { // TODO
	}
	return 0;
	}