diff options
Diffstat (limited to 'abs')
| -rw-r--r-- | abs/core-testing/mythtv/stable/mythtv/PKGBUILD | 10 | ||||
| -rw-r--r-- | abs/core-testing/mythtv/stable/mythtv/changeset-20877.patch | 5910 |
2 files changed, 5918 insertions, 2 deletions
diff --git a/abs/core-testing/mythtv/stable/mythtv/PKGBUILD b/abs/core-testing/mythtv/stable/mythtv/PKGBUILD index cd8e276..454e36b 100644 --- a/abs/core-testing/mythtv/stable/mythtv/PKGBUILD +++ b/abs/core-testing/mythtv/stable/mythtv/PKGBUILD @@ -1,13 +1,15 @@ pkgname=mythtv pkgver=0.21 -pkgrel=74 +pkgrel=75 pkgdesc="A Homebrew PVR project" arch=('i686' 'x86_64') depends=('bash' 'mysql-clients>=5.0' 'qt3' 'lame' 'lirc-utils' 'ffmpeg' \ 'libxvmc' 'libavc1394' 'libdc1394' 'libiec61883' 'perl-net-upnp' 'perl-time-format') backup=(etc/mythtv/mythbackend.conf etc/mythtv/mysql.txt usr/share/mythtv/is.xmlusr/share/mythtv/media_settings.xml ) source=(ftp://ftp.knoppmyth.net/R6/sources/${pkgname}-${pkgver}-fixes.tar.bz2 \ - mythbackend myththemedmenu.cpp.patch myththemedmenu.h.patch smolt_jump.patch pretty gnome_screensaver.patch mpegpspatch mythbackend.lr mythfrontend.lr) + mythbackend myththemedmenu.cpp.patch myththemedmenu.h.patch smolt_jump.patch pretty gnome_screensaver.patch mpegpspatch mythbackend.lr mythfrontend.lr + changeset-20877.patch) + #md5sums=('e316ed18d7ac837cf8c4af54b1478793' '7ef6de58240e7aad389a0b13d91b1cf6'\ # 'a0ecb7f476cb71c0c1ac90d349fc7695') @@ -33,6 +35,10 @@ build() { # cd libs/libavformat # patch -p0 < $startdir/src/mpegpspatch # cd - + +# Remove the hdhomerun changeset 20877 that prevents things from compiling. + patch -p3 < ../changeset-20877.patch + . /etc/profile.d/qt3.sh # use QT3 qmake diff --git a/abs/core-testing/mythtv/stable/mythtv/changeset-20877.patch b/abs/core-testing/mythtv/stable/mythtv/changeset-20877.patch new file mode 100644 index 0000000..b92f0c1 --- /dev/null +++ b/abs/core-testing/mythtv/stable/mythtv/changeset-20877.patch @@ -0,0 +1,5910 @@ +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/Makefile src/mythtv-0.21/libs/libmythtv/hdhomerun/Makefile +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/Makefile 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/Makefile 2009-01-09 13:14:56.000000000 +1030 +@@ -1,52 +1,21 @@ +-LIBSRCS += hdhomerun_pkt.c +-LIBSRCS += hdhomerun_debug.c +-LIBSRCS += hdhomerun_discover.c +-LIBSRCS += hdhomerun_channels.c +-LIBSRCS += hdhomerun_channelscan.c +-LIBSRCS += hdhomerun_control.c +-LIBSRCS += hdhomerun_video.c +-LIBSRCS += hdhomerun_device.c +-LIBSRCS += hdhomerun_device_selector.c + +-CC := $(CROSS_COMPILE)gcc +-STRIP := $(CROSS_COMPILE)strip ++SRCS += hdhomerun_pkt.c ++SRCS += hdhomerun_discover.c ++SRCS += hdhomerun_control.c ++SRCS += hdhomerun_video.c ++SRCS += hdhomerun_device.c ++SRCS += hdhomerun_config.c + + CFLAGS += -Wall -O2 -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wpointer-arith +-LDFLAGS += -lpthread +-SHARED = -shared -Wl,-soname,libhdhomerun$(LIBEXT) + +-ifeq ($(OS),Windows_NT) +- BINEXT := .exe +- LIBEXT := .dll +- LDFLAGS += -liphlpapi +-else +- LIBEXT := .so +- ifneq ($(findstring solaris,$(shell echo $$OSTYPE)),) +- LDFLAGS += -lns -lsocket +- endif +- ifneq ($(findstring darwin,$(shell echo $$OSTYPE)),) +- CFLAGS += -arch i386 -arch ppc +- LIBEXT := .dylib +- SHARED := -dynamiclib -install_name libhdhomerun$(LIBEXT) +- endif +-endif +- +-all : hdhomerun_config$(BINEXT) libhdhomerun$(LIBEXT) +- +-hdhomerun_config$(BINEXT) : hdhomerun_config.c $(LIBSRCS) +- $(CC) $(CFLAGS) $+ $(LDFLAGS) -o $@ +- $(STRIP) $@ +- +-libhdhomerun$(LIBEXT) : $(LIBSRCS) +- $(CC) $(CFLAGS) -fPIC -DDLL_EXPORT $(SHARED) $+ $(LDFLAGS) -o $@ ++hdhomerun_config : $(SRCS) ++ gcc $(CFLAGS) $(SRCS) -lpthread -o $@ ++ strip $@ ++ ++hdhomerun_config.exe : $(SRCS) ++ gcc $(CFLAGS) $(SRCS) -lpthread -liphlpapi -o $@ ++ strip $@ + + clean : +- -rm -f hdhomerun_config$(BINEXT) +- -rm -f libhdhomerun$(LIBEXT) +- +-distclean : clean +- +-%: +- @echo "(ignoring request to make $@)" +- +-.PHONY: all list clean distclean ++ rm -f hdhomerun_config ++ rm -f hdhomerun_config.exe +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,14 +1,12 @@ +-#ifndef __HDHOMERUN_INCLUDES__ +-#define __HDHOMERUN_INCLUDES__ + /* +- * hdhomerun.h ++ * hdhomerun_device.h + * +- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -16,33 +14,13 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + + #include "hdhomerun_os.h" +-#include "hdhomerun_types.h" + #include "hdhomerun_pkt.h" +-#include "hdhomerun_debug.h" + #include "hdhomerun_discover.h" + #include "hdhomerun_control.h" + #include "hdhomerun_video.h" +-#include "hdhomerun_channels.h" +-#include "hdhomerun_channelscan.h" + #include "hdhomerun_device.h" +-#include "hdhomerun_device_selector.h" +- +-#endif /* __HDHOMERUN_INCLUDES__ */ +- +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_channels.c +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_channels.h +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_channelscan.c +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_channelscan.h +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_config.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_config.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_config.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_config.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_config.c + * +- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,34 +14,12 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + + #include "hdhomerun.h" + +-/* +- * The console output format should be set to UTF-8, however in XP and Vista this breaks batch file processing. +- * Attempting to restore on exit fails to restore if the program is terminated by the user. +- * Solution - set the output format each printf. +- */ +-#if defined(__WINDOWS__) +-#define printf console_printf +-#define vprintf console_vprintf +-#endif +- + static const char *appname; + + struct hdhomerun_device_t *hd; +@@ -53,8 +31,7 @@ + printf("\t%s <id> get help\n", appname); + printf("\t%s <id> get <item>\n", appname); + printf("\t%s <id> set <item> <value>\n", appname); +- printf("\t%s <id> scan <tuner> [<filename>]\n", appname); +- printf("\t%s <id> save <tuner> <filename>\n", appname); ++ printf("\t%s <id> scan <tuner> <starting channel>\n", appname); + printf("\t%s <id> upgrade <filename>\n", appname); + return -1; + } +@@ -91,29 +68,10 @@ + return FALSE; + } + +-static uint32_t parse_ip_addr(const char *str) +-{ +- unsigned long a[4]; +- if (sscanf(str, "%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], &a[3]) != 4) { +- return 0; +- } +- +- return (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0)); +-} +- +-static int discover_print(char *target_ip_str) ++static int discover_print(void) + { +- uint32_t target_ip = 0; +- if (target_ip_str) { +- target_ip = parse_ip_addr(target_ip_str); +- if (target_ip == 0) { +- fprintf(stderr, "invalid ip address: %s\n", target_ip_str); +- return -1; +- } +- } +- + struct hdhomerun_discover_device_t result_list[64]; +- int count = hdhomerun_discover_find_devices_custom(target_ip, HDHOMERUN_DEVICE_TYPE_TUNER, HDHOMERUN_DEVICE_ID_WILDCARD, result_list, 64); ++ int count = hdhomerun_discover_find_devices(HDHOMERUN_DEVICE_TYPE_TUNER, result_list, 64); + if (count < 0) { + fprintf(stderr, "error sending discover request\n"); + return -1; +@@ -136,6 +94,32 @@ + return count; + } + ++static bool_t parse_device_id_str(const char *s, uint32_t *pdevice_id, uint32_t *pdevice_ip) ++{ ++ unsigned long a[4]; ++ if (sscanf(s, "%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], &a[3]) == 4) { ++ *pdevice_id = HDHOMERUN_DEVICE_ID_WILDCARD; ++ *pdevice_ip = (uint32_t)((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0)); ++ return TRUE; ++ } ++ ++ unsigned long device_id_raw; ++ if (sscanf(s, "%lx", &device_id_raw) != 1) { ++ fprintf(stderr, "invalid device id: %s\n", s); ++ return FALSE; ++ } ++ ++ uint32_t device_id = (uint32_t)device_id_raw; ++ if (!hdhomerun_discover_validate_device_id(device_id)) { ++ fprintf(stderr, "invalid device id: %s\n", s); ++ return FALSE; ++ } ++ ++ *pdevice_id = device_id; ++ *pdevice_ip = 0; ++ return TRUE; ++} ++ + static int cmd_get(const char *item) + { + char *ret_value; +@@ -154,7 +138,7 @@ + return 1; + } + +-static int cmd_set_internal(const char *item, const char *value) ++static int cmd_set(const char *item, const char *value) + { + char *ret_error; + if (hdhomerun_device_set_var(hd, item, value, NULL, &ret_error) < 0) { +@@ -170,260 +154,118 @@ + return 1; + } + +-static int cmd_set(const char *item, const char *value) ++static int cmd_streaminfo(const char *tuner_str) + { +- if (strcmp(value, "-") == 0) { +- char *buffer = NULL; +- size_t pos = 0; +- +- while (1) { +- buffer = (char *)realloc(buffer, pos + 1024); +- if (!buffer) { +- fprintf(stderr, "out of memory\n"); +- return -1; +- } +- +- size_t size = fread(buffer + pos, 1, 1024, stdin); +- pos += size; +- +- if (size < 1024) { +- break; +- } +- } +- +- buffer[pos] = 0; +- +- int ret = cmd_set_internal(item, buffer); +- +- free(buffer); +- return ret; +- } +- +- return cmd_set_internal(item, value); +-} +- +-static bool_t sigabort = FALSE; +- +-static void signal_abort(int arg) +-{ +- sigabort = TRUE; +-} +- +-static void cmd_scan_printf(FILE *fp, const char *fmt, ...) +-{ +- va_list ap; +- va_start(ap, fmt); +- +- if (fp) { +- va_list apc; +- va_copy(apc, ap); +- +- vfprintf(fp, fmt, apc); +- fflush(fp); +- +- va_end(apc); +- } +- +- vprintf(fmt, ap); +- fflush(stdout); +- +- va_end(ap); ++ fprintf(stderr, "streaminfo: use \"get /tuner<n>/streaminfo\"\n"); ++ return -1; + } + +-static int cmd_scan(const char *tuner_str, const char *filename) ++static int cmd_scan(const char *tuner_str, const char *start_value) + { +- if (hdhomerun_device_set_tuner_from_str(hd, tuner_str) <= 0) { ++ unsigned int tuner; ++ if (sscanf(tuner_str, "%u", &tuner) != 1) { + fprintf(stderr, "invalid tuner number\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(hd, tuner); + +- 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; ++ char channel_str[64]; ++ strncpy(channel_str, start_value, sizeof(channel_str)); ++ channel_str[sizeof(channel_str) - 8] = 0; ++ ++ char *channel_number_ptr = strrchr(channel_str, ':'); ++ if (!channel_number_ptr) { ++ channel_number_ptr = channel_str; ++ } else { ++ channel_number_ptr++; + } + +- const char *channelmap_scan_group = hdhomerun_channelmap_get_channelmap_scan_group(channelmap); +- if (!channelmap_scan_group) { +- fprintf(stderr, "unknown channelmap '%s'\n", channelmap); ++ unsigned int channel_number = atol(channel_number_ptr); ++ if (channel_number == 0) { ++ fprintf(stderr, "invalid starting channel\n"); + return -1; + } + +- if (hdhomerun_device_channelscan_init(hd, channelmap_scan_group) <= 0) { +- fprintf(stderr, "failed to initialize channel scan\n"); ++ /* Test starting channel. */ ++ int ret = hdhomerun_device_set_tuner_channel(hd, channel_str); ++ if (ret < 0) { ++ fprintf(stderr, "communication error sending request to hdhomerun device\n"); + return -1; + } +- +- FILE *fp = NULL; +- if (filename) { +- fp = fopen(filename, "w"); +- if (!fp) { +- fprintf(stderr, "unable to create file: %s\n", filename); +- return -1; +- } ++ if (ret == 0) { ++ fprintf(stderr, "invalid starting channel\n"); ++ return -1; + } + +- signal(SIGINT, signal_abort); +- signal(SIGPIPE, signal_abort); ++ while (1) { ++ /* Update channel value */ ++ sprintf(channel_number_ptr, "%u", channel_number); + +- int ret = 0; +- while (!sigabort) { +- struct hdhomerun_channelscan_result_t result; +- ret = hdhomerun_device_channelscan_advance(hd, &result); +- if (ret <= 0) { +- break; ++ /* Set channel. */ ++ ret = hdhomerun_device_set_tuner_channel(hd, channel_str); ++ if (ret < 0) { ++ fprintf(stderr, "communication error sending request to hdhomerun device\n"); ++ return -1; + } +- +- cmd_scan_printf(fp, "SCANNING: %lu (%s)\n", +- result.frequency, result.channel_str +- ); +- +- ret = hdhomerun_device_channelscan_detect(hd, &result); +- if (ret <= 0) { +- break; ++ if (ret == 0) { ++ return 0; + } + +- cmd_scan_printf(fp, "LOCK: %s (ss=%u snq=%u seq=%u)\n", +- result.status.lock_str, result.status.signal_strength, +- result.status.signal_to_noise_quality, result.status.symbol_error_quality +- ); ++ /* Wait 1.5s for lock (qam auto is the slowest to lock). */ ++ usleep(HDHOMERUN_DEVICE_MAX_TUNE_TO_LOCK_TIME * 1000); + +- if (result.transport_stream_id_detected) { +- cmd_scan_printf(fp, "TSID: 0x%04X\n", result.transport_stream_id); ++ /* Get status to check for signal. Quality numbers will not be valid yet. */ ++ struct hdhomerun_tuner_status_t status; ++ if (hdhomerun_device_get_tuner_status(hd, &status) < 0) { ++ fprintf(stderr, "communication error sending request to hdhomerun device\n"); ++ return -1; + } + +- int i; +- for (i = 0; i < result.program_count; i++) { +- struct hdhomerun_channelscan_program_t *program = &result.programs[i]; +- cmd_scan_printf(fp, "PROGRAM %s\n", program->program_str); ++ /* If no signal then advance to next channel. */ ++ if (status.signal_strength == 0) { ++ printf("%s: no signal\n", channel_str); ++ channel_number++; ++ continue; + } +- } +- +- hdhomerun_device_tuner_lockkey_release(hd); + +- if (fp) { +- fclose(fp); +- } +- if (ret < 0) { +- fprintf(stderr, "communication error sending request to hdhomerun device\n"); +- } +- return ret; +-} +- +-static int cmd_save(const char *tuner_str, const char *filename) +-{ +- if (hdhomerun_device_set_tuner_from_str(hd, tuner_str) <= 0) { +- fprintf(stderr, "invalid tuner number\n"); +- return -1; +- } ++ /* Wait for 2s. */ ++ usleep(HDHOMERUN_DEVICE_MAX_LOCK_TO_DATA_TIME * 1000); + +- FILE *fp; +- if (strcmp(filename, "null") == 0) { +- fp = NULL; +- } else if (strcmp(filename, "-") == 0) { +- fp = stdout; +- } else { +- fp = fopen(filename, "wb"); +- if (!fp) { +- fprintf(stderr, "unable to create file %s\n", filename); ++ /* Get status to check quality numbers. */ ++ if (hdhomerun_device_get_tuner_status(hd, &status) < 0) { ++ fprintf(stderr, "communication error sending request to hdhomerun device\n"); + return -1; + } +- } +- +- int ret = hdhomerun_device_stream_start(hd); +- if (ret <= 0) { +- fprintf(stderr, "unable to start stream\n"); +- if (fp && fp != stdout) { +- fclose(fp); +- } +- return ret; +- } +- +- signal(SIGINT, signal_abort); +- signal(SIGPIPE, signal_abort); +- +- struct hdhomerun_video_stats_t stats_old, stats_cur; +- hdhomerun_device_get_video_stats(hd, &stats_old); +- +- uint64_t next_progress = getcurrenttime() + 1000; +- +- while (!sigabort) { +- uint64_t loop_start_time = getcurrenttime(); +- +- size_t actual_size; +- uint8_t *ptr = hdhomerun_device_stream_recv(hd, VIDEO_DATA_BUFFER_SIZE_1S, &actual_size); +- if (!ptr) { +- msleep(64); ++ if (status.signal_strength == 0) { ++ printf("%s: no signal\n", channel_str); ++ channel_number++; + continue; + } ++ printf("%s: ss=%u snq=%u seq=%u\n", channel_str, status.signal_strength, status.signal_to_noise_quality, status.symbol_error_quality); + +- if (fp) { +- if (fwrite(ptr, 1, actual_size, fp) != actual_size) { +- fprintf(stderr, "error writing output\n"); +- return -1; +- } ++ /* Detect sub channels. */ ++ usleep(4 * 1000000); ++ char *streaminfo; ++ if (hdhomerun_device_get_tuner_streaminfo(hd, &streaminfo) <= 0) { ++ channel_number++; ++ continue; + } +- +- if (loop_start_time >= next_progress) { +- next_progress += 1000; +- if (loop_start_time >= next_progress) { +- next_progress = loop_start_time + 1000; +- } +- +- hdhomerun_device_get_video_stats(hd, &stats_cur); +- +- if (stats_cur.overflow_error_count > stats_old.overflow_error_count) { +- fprintf(stderr, "o"); +- } else if (stats_cur.network_error_count > stats_old.network_error_count) { +- fprintf(stderr, "n"); +- } else if (stats_cur.transport_error_count > stats_old.transport_error_count) { +- fprintf(stderr, "t"); +- } else if (stats_cur.sequence_error_count > stats_old.sequence_error_count) { +- fprintf(stderr, "s"); +- } else { +- fprintf(stderr, "."); ++ while (1) { ++ char *end = strchr(streaminfo, '\n'); ++ if (!end) { ++ break; + } + +- stats_old = stats_cur; +- fflush(stderr); +- } ++ *end++ = 0; ++ printf("program %s\n", streaminfo); + +- int32_t delay = 64 - (int32_t)(getcurrenttime() - loop_start_time); +- if (delay <= 0) { +- continue; ++ streaminfo = end; + } + +- msleep(delay); +- } +- +- if (fp) { +- fclose(fp); ++ /* Advance to next channel. */ ++ channel_number++; + } +- +- hdhomerun_device_stream_stop(hd); +- hdhomerun_device_get_video_stats(hd, &stats_cur); +- +- fprintf(stderr, "\n"); +- fprintf(stderr, "-- Video statistics --\n"); +- fprintf(stderr, "%u packets received, %u overflow errors, %u network errors, %u transport errors, %u sequence errors\n", +- (unsigned int)stats_cur.packet_count, +- (unsigned int)stats_cur.overflow_error_count, +- (unsigned int)stats_cur.network_error_count, +- (unsigned int)stats_cur.transport_error_count, +- (unsigned int)stats_cur.sequence_error_count); +- +- return 0; + } + + static int cmd_upgrade(const char *filename) +@@ -434,98 +276,16 @@ + return -1; + } + +- printf("uploading firmware...\n"); + if (hdhomerun_device_upgrade(hd, fp) <= 0) { + fprintf(stderr, "error sending upgrade file to hdhomerun device\n"); + fclose(fp); + return -1; + } +- sleep(2); +- +- printf("upgrading firmware...\n"); +- sleep(8); +- +- printf("rebooting...\n"); +- int count = 0; +- char *version_str; +- while (1) { +- if (hdhomerun_device_get_version(hd, &version_str, NULL) >= 0) { +- break; +- } +- +- count++; +- if (count > 30) { +- fprintf(stderr, "error finding device after firmware upgrade\n"); +- fclose(fp); +- return -1; +- } + +- sleep(1); +- } +- +- printf("upgrade complete - now running firmware %s\n", version_str); ++ printf("upgrade complete\n"); + return 0; + } + +-static int cmd_execute(void) +-{ +- char *ret_value; +- char *ret_error; +- if (hdhomerun_device_get_var(hd, "/sys/boot", &ret_value, &ret_error) < 0) { +- fprintf(stderr, "communication error sending request to hdhomerun device\n"); +- return -1; +- } +- +- if (ret_error) { +- printf("%s\n", ret_error); +- return 0; +- } +- +- char *end = ret_value + strlen(ret_value); +- char *pos = ret_value; +- +- while (1) { +- if (pos >= end) { +- break; +- } +- +- char *eol_r = strchr(pos, '\r'); +- if (!eol_r) { +- eol_r = end; +- } +- +- char *eol_n = strchr(pos, '\n'); +- if (!eol_n) { +- eol_n = end; +- } +- +- char *eol = eol_r; +- if (eol_n < eol) { +- eol = eol_n; +- } +- +- char *sep = strchr(pos, ' '); +- if (!sep || sep > eol) { +- pos = eol + 1; +- continue; +- } +- +- *sep = 0; +- *eol = 0; +- +- char *item = pos; +- char *value = sep + 1; +- +- printf("set %s \"%s\"\n", item, value); +- +- cmd_set_internal(item, value); +- +- pos = eol + 1; +- } +- +- return 1; +-} +- + static int main_cmd(int argc, char *argv[]) + { + if (argc < 1) { +@@ -534,17 +294,6 @@ + + char *cmd = *argv++; argc--; + +- if (contains(cmd, "key")) { +- if (argc < 2) { +- return help(); +- } +- uint32_t lockkey = strtoul(argv[0], NULL, 0); +- hdhomerun_device_tuner_lockkey_use_value(hd, lockkey); +- +- cmd = argv[1]; +- argv+=2; argc-=2; +- } +- + if (contains(cmd, "get")) { + if (argc < 1) { + return help(); +@@ -559,22 +308,18 @@ + return cmd_set(argv[0], argv[1]); + } + +- if (contains(cmd, "scan")) { ++ if (contains(cmd, "streaminfo")) { + if (argc < 1) { + return help(); + } +- if (argc < 2) { +- return cmd_scan(argv[0], NULL); +- } else { +- return cmd_scan(argv[0], argv[1]); +- } ++ return cmd_streaminfo(argv[0]); + } + +- if (contains(cmd, "save")) { ++ if (contains(cmd, "scan")) { + if (argc < 2) { + return help(); + } +- return cmd_save(argv[0], argv[1]); ++ return cmd_scan(argv[0], argv[1]); + } + + if (contains(cmd, "upgrade")) { +@@ -584,17 +329,16 @@ + return cmd_upgrade(argv[0]); + } + +- if (contains(cmd, "execute")) { +- return cmd_execute(); +- } +- + return help(); + } + + static int main_internal(int argc, char *argv[]) + { + #if defined(__WINDOWS__) +- /* Initialize network socket support. */ ++ //Start pthreads ++ pthread_win32_process_attach_np(); ++ ++ // Start WinSock + WORD wVersionRequested = MAKEWORD(2, 0); + WSADATA wsaData; + WSAStartup(wVersionRequested, &wsaData); +@@ -613,36 +357,35 @@ + return help(); + } + if (contains(id_str, "discover")) { +- if (argc < 1) { +- return discover_print(NULL); +- } else { +- return discover_print(argv[0]); +- } ++ return discover_print(); + } + +- /* Device object. */ +- hd = hdhomerun_device_create_from_str(id_str, NULL); +- if (!hd) { +- fprintf(stderr, "invalid device id: %s\n", id_str); ++ /* Device ID. */ ++ uint32_t device_id, device_ip; ++ if (!parse_device_id_str(id_str, &device_id, &device_ip)) { + return -1; + } + +- /* Device ID check. */ +- uint32_t device_id_requested = hdhomerun_device_get_device_id_requested(hd); +- if (!hdhomerun_discover_validate_device_id(device_id_requested)) { +- fprintf(stderr, "invalid device id: %08lX\n", (unsigned long)device_id_requested); ++ /* Device object. */ ++ hd = hdhomerun_device_create(device_id, device_ip, 0); ++ if (!hd) { ++ fprintf(stderr, "unable to create device\n"); ++ return -1; + } + +- /* Connect to device and check model. */ +- const char *model = hdhomerun_device_get_model_str(hd); +- if (!model) { ++ /* Connect to device and check firmware version. */ ++ int ret = hdhomerun_device_firmware_version_check(hd, 0); ++ if (ret < 0) { + fprintf(stderr, "unable to connect to device\n"); + hdhomerun_device_destroy(hd); + return -1; + } ++ if (ret == 0) { ++ fprintf(stderr, "WARNING: firmware upgrade needed for all operations to function\n"); ++ } + + /* Command. */ +- int ret = main_cmd(argc, argv); ++ ret = main_cmd(argc, argv); + + /* Cleanup. */ + hdhomerun_device_destroy(hd); +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_control.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_control.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_control.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_control.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_control.c + * +- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,119 +14,83 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#include "hdhomerun.h" +- +-#define HDHOMERUN_CONTROL_SEND_TIMEOUT 5000 +-#define HDHOMERUN_CONTROL_RECV_TIMEOUT 5000 +-#define HDHOMERUN_CONTROL_UPGRADE_TIMEOUT 20000 ++#include "hdhomerun_os.h" ++#include "hdhomerun_pkt.h" ++#include "hdhomerun_discover.h" ++#include "hdhomerun_control.h" + + struct hdhomerun_control_sock_t { +- uint32_t desired_device_id; +- uint32_t desired_device_ip; +- uint32_t actual_device_id; +- uint32_t actual_device_ip; ++ uint32_t device_id; ++ uint32_t device_ip; + int sock; +- struct hdhomerun_debug_t *dbg; +- struct hdhomerun_pkt_t tx_pkt; +- struct hdhomerun_pkt_t rx_pkt; ++ uint8_t buffer[16384]; + }; + +-static void hdhomerun_control_close_sock(struct hdhomerun_control_sock_t *cs) +-{ +- if (cs->sock == -1) { +- return; +- } +- +- close(cs->sock); +- cs->sock = -1; +-} +- +-void hdhomerun_control_set_device(struct hdhomerun_control_sock_t *cs, uint32_t device_id, uint32_t device_ip) +-{ +- hdhomerun_control_close_sock(cs); +- +- cs->desired_device_id = device_id; +- cs->desired_device_ip = device_ip; +- cs->actual_device_id = 0; +- cs->actual_device_ip = 0; +-} +- +-struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip, struct hdhomerun_debug_t *dbg) ++struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip) + { +- struct hdhomerun_control_sock_t *cs = (struct hdhomerun_control_sock_t *)calloc(1, sizeof(struct hdhomerun_control_sock_t)); ++ struct hdhomerun_control_sock_t *cs = (struct hdhomerun_control_sock_t *)malloc(sizeof(struct hdhomerun_control_sock_t)); + if (!cs) { +- hdhomerun_debug_printf(dbg, "hdhomerun_control_create: failed to allocate control object\n"); + return NULL; + } +- +- cs->dbg = dbg; ++ ++ cs->device_id = device_id; ++ cs->device_ip = device_ip; + cs->sock = -1; +- hdhomerun_control_set_device(cs, device_id, device_ip); + + return cs; + } + + void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs) + { +- hdhomerun_control_close_sock(cs); ++ if (cs->sock != -1) { ++ close(cs->sock); ++ } + free(cs); + } + ++static void hdhomerun_control_close_sock(struct hdhomerun_control_sock_t *cs) ++{ ++ close(cs->sock); ++ cs->sock = -1; ++} ++ + static bool_t hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs) + { + if (cs->sock != -1) { + return TRUE; + } + +- if ((cs->desired_device_id == 0) && (cs->desired_device_ip == 0)) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: no device specified\n"); +- return FALSE; +- } +- +- /* Find device. */ +- struct hdhomerun_discover_device_t result; +- if (hdhomerun_discover_find_devices_custom(cs->desired_device_ip, HDHOMERUN_DEVICE_TYPE_WILDCARD, cs->desired_device_id, &result, 1) <= 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: device not found\n"); +- return FALSE; ++ /* Find ip address. */ ++ uint32_t device_ip = cs->device_ip; ++ if (device_ip == 0) { ++ struct hdhomerun_discover_device_t result; ++ if (hdhomerun_discover_find_device(cs->device_id, &result) <= 0) { ++ return FALSE; ++ } ++ device_ip = result.ip_addr; + } +- cs->actual_device_ip = result.ip_addr; +- cs->actual_device_id = result.device_id; + + /* Create socket. */ + cs->sock = (int)socket(AF_INET, SOCK_STREAM, 0); + if (cs->sock == -1) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to create socket (%d)\n", sock_getlasterror); + return FALSE; + } + + /* Set timeouts. */ +- setsocktimeout(cs->sock, SOL_SOCKET, SO_SNDTIMEO, HDHOMERUN_CONTROL_SEND_TIMEOUT); +- setsocktimeout(cs->sock, SOL_SOCKET, SO_RCVTIMEO, HDHOMERUN_CONTROL_RECV_TIMEOUT); ++ setsocktimeout(cs->sock, SOL_SOCKET, SO_SNDTIMEO, 1000); ++ setsocktimeout(cs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000); + + /* Initiate connection. */ + struct sockaddr_in sock_addr; + memset(&sock_addr, 0, sizeof(sock_addr)); + sock_addr.sin_family = AF_INET; +- sock_addr.sin_addr.s_addr = htonl(cs->actual_device_ip); ++ sock_addr.sin_addr.s_addr = htonl(device_ip); + sock_addr.sin_port = htons(HDHOMERUN_CONTROL_TCP_PORT); + if (connect(cs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_connect_sock: failed to connect (%d)\n", sock_getlasterror); + hdhomerun_control_close_sock(cs); + return FALSE; + } +@@ -135,215 +99,125 @@ + return TRUE; + } + +-uint32_t hdhomerun_control_get_device_id(struct hdhomerun_control_sock_t *cs) +-{ +- if (!hdhomerun_control_connect_sock(cs)) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_device_id: connect failed\n"); +- return 0; +- } +- +- return cs->actual_device_id; +-} +- +-uint32_t hdhomerun_control_get_device_ip(struct hdhomerun_control_sock_t *cs) +-{ +- if (!hdhomerun_control_connect_sock(cs)) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_device_ip: connect failed\n"); +- return 0; +- } +- +- return cs->actual_device_ip; +-} +- +-uint32_t hdhomerun_control_get_device_id_requested(struct hdhomerun_control_sock_t *cs) +-{ +- return cs->desired_device_id; +-} +- +-uint32_t hdhomerun_control_get_device_ip_requested(struct hdhomerun_control_sock_t *cs) +-{ +- return cs->desired_device_ip; +-} +- + uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs) + { + if (!hdhomerun_control_connect_sock(cs)) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_local_addr: connect failed\n"); + return 0; + } + + struct sockaddr_in sock_addr; + socklen_t sockaddr_size = sizeof(sock_addr); + if (getsockname(cs->sock, (struct sockaddr*)&sock_addr, &sockaddr_size) != 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_local_addr: getsockname failed (%d)\n", sock_getlasterror); + return 0; + } + + return ntohl(sock_addr.sin_addr.s_addr); + } + +-static int hdhomerun_control_send_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt) ++static int hdhomerun_control_send(struct hdhomerun_control_sock_t *cs, uint8_t *start, uint8_t *end) + { +- int length = (int)(tx_pkt->end - tx_pkt->start); +- if (send(cs->sock, (char *)tx_pkt->start, (int)length, 0) != length) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_sock: send failed (%d)\n", sock_getlasterror); +- hdhomerun_control_close_sock(cs); ++ int length = (int)(end - start); ++ if (send(cs->sock, (char *)start, (int)length, 0) != length) { + return -1; + } + +- return 1; ++ return length; + } + +-static int hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *rx_pkt, uint16_t *ptype, uint64_t recv_timeout) ++static int hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, uint8_t *buffer, uint8_t *limit) + { +- uint64_t stop_time = getcurrenttime() + recv_timeout; +- hdhomerun_pkt_reset(rx_pkt); ++ struct timeval t; ++ t.tv_sec = 0; ++ t.tv_usec = 250000; + +- while (getcurrenttime() < stop_time) { +- struct timeval t; +- t.tv_sec = 0; +- t.tv_usec = 250000; +- +- fd_set readfds; +- FD_ZERO(&readfds); +- FD_SET(cs->sock, &readfds); +- +- if (select(cs->sock+1, &readfds, NULL, NULL, &t) < 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: select failed (%d)\n", sock_getlasterror); +- hdhomerun_control_close_sock(cs); +- return -1; +- } +- +- if (!FD_ISSET(cs->sock, &readfds)) { +- continue; +- } +- +- int rx_length = recv(cs->sock, (char *)rx_pkt->end, (int)(rx_pkt->limit - rx_pkt->end), 0); +- if (rx_length <= 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: recv failed (%d)\n", sock_getlasterror); +- hdhomerun_control_close_sock(cs); +- return -1; +- } +- rx_pkt->end += rx_length; ++ fd_set readfds; ++ FD_ZERO(&readfds); ++ FD_SET(cs->sock, &readfds); + +- int ret = hdhomerun_pkt_open_frame(rx_pkt, ptype); +- if (ret < 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: frame error\n"); +- hdhomerun_control_close_sock(cs); +- return -1; +- } +- if (ret == 0) { +- continue; +- } ++ if (select(cs->sock+1, &readfds, NULL, NULL, &t) < 0) { ++ return -1; ++ } + +- return 1; ++ if (!FD_ISSET(cs->sock, &readfds)) { ++ return 0; + } + +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_recv_sock: timeout\n"); +- hdhomerun_control_close_sock(cs); +- return -1; ++ int length = recv(cs->sock, (char *)buffer, (int)(limit - buffer), 0); ++ if (length <= 0) { ++ return -1; ++ } ++ ++ return length; + } + +-static int hdhomerun_control_send_recv_internal(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt, struct hdhomerun_pkt_t *rx_pkt, uint16_t type, uint64_t recv_timeout) ++static int hdhomerun_control_recv(struct hdhomerun_control_sock_t *cs, uint8_t *buffer, uint8_t *limit) + { +- hdhomerun_pkt_seal_frame(tx_pkt, type); ++ uint64_t timeout = getcurrenttime() + 1000; ++ uint8_t *ptr = buffer; + +- int i; +- for (i = 0; i < 2; i++) { +- if (cs->sock == -1) { +- if (!hdhomerun_control_connect_sock(cs)) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_recv: connect failed\n"); +- return -1; +- } ++ while (getcurrenttime() < timeout) { ++ int length = hdhomerun_control_recv_sock(cs, ptr, limit); ++ if (length < 0) { ++ return -1; + } +- +- if (hdhomerun_control_send_sock(cs, tx_pkt) < 0) { ++ if (length == 0) { + continue; + } +- if (!rx_pkt) { +- return 1; +- } ++ ptr += length; + +- uint16_t rsp_type; +- if (hdhomerun_control_recv_sock(cs, rx_pkt, &rsp_type, recv_timeout) < 0) { ++ if (buffer + HDHOMERUN_MIN_PEEK_LENGTH > limit) { + continue; + } +- if (rsp_type != type + 1) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_recv: unexpected frame type\n"); +- hdhomerun_control_close_sock(cs); ++ ++ length = (int)hdhomerun_peek_packet_length(buffer); ++ if (buffer + length > limit) { + continue; + } + +- return 1; ++ return length; + } + +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_send_recv: failed\n"); + return -1; + } + +-int hdhomerun_control_send_recv(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt, struct hdhomerun_pkt_t *rx_pkt, uint16_t type) ++static int hdhomerun_control_get_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror) + { +- return hdhomerun_control_send_recv_internal(cs, tx_pkt, rx_pkt, type, HDHOMERUN_CONTROL_RECV_TIMEOUT); +-} +- +-static int hdhomerun_control_get_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, uint32_t lockkey, char **pvalue, char **perror) +-{ +- struct hdhomerun_pkt_t *tx_pkt = &cs->tx_pkt; +- struct hdhomerun_pkt_t *rx_pkt = &cs->rx_pkt; +- +- /* Request. */ +- hdhomerun_pkt_reset(tx_pkt); +- +- int name_len = (int)strlen(name) + 1; +- if (tx_pkt->end + 3 + name_len > tx_pkt->limit) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: request too long\n"); ++ /* Send request. */ ++ uint8_t *ptr = cs->buffer; ++ hdhomerun_write_get_set_request(&ptr, name, value); ++ if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) { + return -1; + } +- hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_GETSET_NAME); +- hdhomerun_pkt_write_var_length(tx_pkt, name_len); +- hdhomerun_pkt_write_mem(tx_pkt, (void *)name, name_len); + +- if (value) { +- int value_len = (int)strlen(value) + 1; +- if (tx_pkt->end + 3 + value_len > tx_pkt->limit) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: request too long\n"); +- return -1; +- } +- hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_GETSET_VALUE); +- hdhomerun_pkt_write_var_length(tx_pkt, value_len); +- hdhomerun_pkt_write_mem(tx_pkt, (void *)value, value_len); ++ /* Receive response. */ ++ int length = hdhomerun_control_recv(cs, cs->buffer, cs->buffer + sizeof(cs->buffer)); ++ if (length <= 0) { ++ return -1; + } + +- if (lockkey != 0) { +- if (tx_pkt->end + 6 > tx_pkt->limit) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: request too long\n"); +- return -1; +- } +- hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_GETSET_LOCKKEY); +- hdhomerun_pkt_write_var_length(tx_pkt, 4); +- hdhomerun_pkt_write_u32(tx_pkt, lockkey); ++ /* Parse response. */ ++ ptr = cs->buffer; ++ uint8_t *end = ptr + length; ++ int type = hdhomerun_process_packet(&ptr, &end); ++ if (type < 0) { ++ return -1; + } +- +- /* Send/Recv. */ +- if (hdhomerun_control_send_recv_internal(cs, tx_pkt, rx_pkt, HDHOMERUN_TYPE_GETSET_REQ, HDHOMERUN_CONTROL_RECV_TIMEOUT) < 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: send/recv error\n"); ++ if (type != HDHOMERUN_TYPE_GETSET_RPY) { + return -1; + } + +- /* Response. */ +- while (1) { ++ while (ptr < end) { + uint8_t tag; + size_t len; +- uint8_t *next = hdhomerun_pkt_read_tlv(rx_pkt, &tag, &len); +- if (!next) { ++ uint8_t *val; ++ if (hdhomerun_read_tlv(&ptr, end, &tag, &len, &val) < 0) { + break; + } +- + switch (tag) { + case HDHOMERUN_TAG_GETSET_VALUE: + if (pvalue) { +- *pvalue = (char *)rx_pkt->pos; +- rx_pkt->pos[len] = 0; ++ *pvalue = (char *)val; ++ val[len] = 0; + } + if (perror) { + *perror = NULL; +@@ -351,48 +225,59 @@ + return 1; + + case HDHOMERUN_TAG_ERROR_MESSAGE: +- rx_pkt->pos[len] = 0; +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: %s\n", rx_pkt->pos); +- + if (pvalue) { + *pvalue = NULL; + } + if (perror) { +- *perror = (char *)rx_pkt->pos; ++ *perror = (char *)val; ++ val[len] = 0; + } +- + return 0; + } +- +- rx_pkt->pos = next; + } + +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_get_set: missing response tags\n"); + return -1; + } + + int hdhomerun_control_get(struct hdhomerun_control_sock_t *cs, const char *name, char **pvalue, char **perror) + { +- return hdhomerun_control_get_set(cs, name, NULL, 0, pvalue, perror); ++ if (!hdhomerun_control_connect_sock(cs)) { ++ return -1; ++ } ++ ++ int ret = hdhomerun_control_get_set(cs, name, NULL, pvalue, perror); ++ if (ret < 0) { ++ hdhomerun_control_close_sock(cs); ++ return -1; ++ } ++ ++ return ret; + } + + int hdhomerun_control_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror) + { +- return hdhomerun_control_get_set(cs, name, value, 0, pvalue, perror); +-} ++ if (!hdhomerun_control_connect_sock(cs)) { ++ return -1; ++ } + +-int hdhomerun_control_set_with_lockkey(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, uint32_t lockkey, char **pvalue, char **perror) +-{ +- return hdhomerun_control_get_set(cs, name, value, lockkey, pvalue, perror); ++ int ret = hdhomerun_control_get_set(cs, name, value, pvalue, perror); ++ if (ret < 0) { ++ hdhomerun_control_close_sock(cs); ++ return -1; ++ } ++ ++ return ret; + } + + int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file) + { +- struct hdhomerun_pkt_t *tx_pkt = &cs->tx_pkt; +- struct hdhomerun_pkt_t *rx_pkt = &cs->rx_pkt; ++ if (!hdhomerun_control_connect_sock(cs)) { ++ return -1; ++ } ++ + uint32_t sequence = 0; ++ uint8_t *ptr; + +- /* Upload. */ + while (1) { + uint8_t data[256]; + size_t length = fread(data, 1, 256, upgrade_file); +@@ -400,12 +285,10 @@ + break; + } + +- hdhomerun_pkt_reset(tx_pkt); +- hdhomerun_pkt_write_u32(tx_pkt, sequence); +- hdhomerun_pkt_write_mem(tx_pkt, data, length); +- +- if (hdhomerun_control_send_recv_internal(cs, tx_pkt, NULL, HDHOMERUN_TYPE_UPGRADE_REQ, 0) < 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_upgrade: send/recv failed\n"); ++ ptr = cs->buffer; ++ hdhomerun_write_upgrade_request(&ptr, sequence, data, length); ++ if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) { ++ hdhomerun_control_close_sock(cs); + return -1; + } + +@@ -414,40 +297,15 @@ + + if (sequence == 0) { + /* No data in file. Error, but no need to close connection. */ +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_upgrade: zero length file\n"); + return 0; + } + +- /* Execute upgrade. */ +- hdhomerun_pkt_reset(tx_pkt); +- hdhomerun_pkt_write_u32(tx_pkt, 0xFFFFFFFF); +- +- if (hdhomerun_control_send_recv_internal(cs, tx_pkt, rx_pkt, HDHOMERUN_TYPE_UPGRADE_REQ, HDHOMERUN_CONTROL_UPGRADE_TIMEOUT) < 0) { +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_upgrade: send/recv failed\n"); ++ ptr = cs->buffer; ++ hdhomerun_write_upgrade_request(&ptr, 0xFFFFFFFF, NULL, 0); ++ if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) { ++ hdhomerun_control_close_sock(cs); + return -1; + } + +- /* Check response. */ +- while (1) { +- uint8_t tag; +- size_t len; +- uint8_t *next = hdhomerun_pkt_read_tlv(rx_pkt, &tag, &len); +- if (!next) { +- break; +- } +- +- switch (tag) { +- case HDHOMERUN_TAG_ERROR_MESSAGE: +- rx_pkt->pos[len] = 0; +- hdhomerun_debug_printf(cs->dbg, "hdhomerun_control_upgrade: %s\n", (char *)rx_pkt->pos); +- return 0; +- +- default: +- break; +- } +- +- rx_pkt->pos = next; +- } +- + return 1; + } +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_control.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_control.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_control.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_control.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_control.h + * +- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,20 +14,8 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + #ifdef __cplusplus + extern "C" { +@@ -43,26 +31,13 @@ + * + * uint32_t device_id = 32-bit device id of device. Set to HDHOMERUN_DEVICE_ID_WILDCARD to match any device ID. + * uint32_t device_ip = IP address of device. Set to 0 to auto-detect. +- * struct hdhomerun_debug_t *dbg: Pointer to debug logging object. May be NULL. + * + * Returns a pointer to the newly created control socket. + * + * When no longer needed, the socket should be destroyed by calling hdhomerun_control_destroy. + */ +-extern LIBTYPE struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip, struct hdhomerun_debug_t *dbg); +-extern LIBTYPE void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs); +- +-/* +- * Get the actual device id or ip of the device. +- * +- * Returns 0 if the device id cannot be determined. +- */ +-extern LIBTYPE uint32_t hdhomerun_control_get_device_id(struct hdhomerun_control_sock_t *cs); +-extern LIBTYPE uint32_t hdhomerun_control_get_device_ip(struct hdhomerun_control_sock_t *cs); +-extern LIBTYPE uint32_t hdhomerun_control_get_device_id_requested(struct hdhomerun_control_sock_t *cs); +-extern LIBTYPE uint32_t hdhomerun_control_get_device_ip_requested(struct hdhomerun_control_sock_t *cs); +- +-extern LIBTYPE void hdhomerun_control_set_device(struct hdhomerun_control_sock_t *cs, uint32_t device_id, uint32_t device_ip); ++extern struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip); ++extern void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs); + + /* + * Get the local machine IP address used when communicating with the device. +@@ -71,12 +46,7 @@ + * + * Returns 32-bit IP address with native endianness, or 0 on error. + */ +-extern LIBTYPE uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs); +- +-/* +- * Low-level communication. +- */ +-extern LIBTYPE int hdhomerun_control_send_recv(struct hdhomerun_control_sock_t *cs, struct hdhomerun_pkt_t *tx_pkt, struct hdhomerun_pkt_t *rx_pkt, uint16_t type); ++extern uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs); + + /* + * Get/set a control variable on the device. +@@ -95,9 +65,8 @@ + * Returns 0 if the operation was rejected (pvalue NULL, perror set). + * Returns -1 if a communication error occurs. + */ +-extern LIBTYPE int hdhomerun_control_get(struct hdhomerun_control_sock_t *cs, const char *name, char **pvalue, char **perror); +-extern LIBTYPE int hdhomerun_control_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror); +-extern LIBTYPE int hdhomerun_control_set_with_lockkey(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, uint32_t lockkey, char **pvalue, char **perror); ++extern int hdhomerun_control_get(struct hdhomerun_control_sock_t *cs, const char *name, char **pvalue, char **perror); ++extern int hdhomerun_control_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror); + + /* + * Upload new firmware to the device. +@@ -108,7 +77,7 @@ + * Returns 0 if the upload was rejected. + * Returns -1 if an error occurs. + */ +-extern LIBTYPE int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file); ++extern int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file); + + #ifdef __cplusplus + } +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_debug.c +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_debug.h +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_device.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_device.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_device.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_device.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* +- * hdhomerun_device.c ++ * hdhomerun_record.c + * +- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,92 +14,43 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#include "hdhomerun.h" ++#include "hdhomerun_os.h" ++#include "hdhomerun_pkt.h" ++#include "hdhomerun_control.h" ++#include "hdhomerun_video.h" ++#include "hdhomerun_device.h" + + struct hdhomerun_device_t { + struct hdhomerun_control_sock_t *cs; + struct hdhomerun_video_sock_t *vs; +- struct hdhomerun_debug_t *dbg; +- struct hdhomerun_channelscan_t *scan; +- uint32_t device_id; + unsigned int tuner; +- uint32_t lockkey; +- char name[32]; +- char model[32]; ++ char result_buffer[1024]; + }; + +-static void hdhomerun_device_set_update(struct hdhomerun_device_t *hd) +-{ +- /* Clear cached information. */ +- *hd->model = 0; +- +- /* New name. */ +- sprintf(hd->name, "%08lX-%u", (unsigned long)hd->device_id, hd->tuner); +-} +- +-void hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip) +-{ +- hdhomerun_control_set_device(hd->cs, device_id, device_ip); +- +- if ((device_id == 0) || (device_id == HDHOMERUN_DEVICE_ID_WILDCARD)) { +- device_id = hdhomerun_control_get_device_id(hd->cs); +- } +- +- hd->device_id = device_id; +- hdhomerun_device_set_update(hd); +-} +- +-void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner) +-{ +- hd->tuner = tuner; +- hdhomerun_device_set_update(hd); +-} +- +-struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner, struct hdhomerun_debug_t *dbg) ++struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner) + { + struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)calloc(1, sizeof(struct hdhomerun_device_t)); + if (!hd) { +- hdhomerun_debug_printf(dbg, "hdhomerun_device_create: failed to allocate device object\n"); + return NULL; + } + +- hd->dbg = dbg; ++ hd->tuner = tuner; + +- hd->cs = hdhomerun_control_create(0, 0, hd->dbg); ++ hd->cs = hdhomerun_control_create(device_id, device_ip); + if (!hd->cs) { +- hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_create: failed to create control object\n"); + free(hd); + return NULL; + } + +- hdhomerun_device_set_device(hd, device_id, device_ip); +- hdhomerun_device_set_tuner(hd, tuner); +- + return hd; + } + + void hdhomerun_device_destroy(struct hdhomerun_device_t *hd) + { +- if (hd->scan) { +- channelscan_destroy(hd->scan); +- } +- + if (hd->vs) { + hdhomerun_video_destroy(hd->vs); + } +@@ -109,152 +60,9 @@ + free(hd); + } + +-static bool_t is_hex_char(char c) +-{ +- if ((c >= '0') && (c <= '9')) { +- return TRUE; +- } +- if ((c >= 'A') && (c <= 'F')) { +- return TRUE; +- } +- if ((c >= 'a') && (c <= 'f')) { +- return TRUE; +- } +- return FALSE; +-} +- +-static struct hdhomerun_device_t *hdhomerun_device_create_from_str_device_id(const char *device_str, struct hdhomerun_debug_t *dbg) +-{ +- int i; +- const char *ptr = device_str; +- for (i = 0; i < 8; i++) { +- if (!is_hex_char(*ptr++)) { +- return NULL; +- } +- } +- +- if (*ptr == 0) { +- unsigned long device_id; +- if (sscanf(device_str, "%lx", &device_id) != 1) { +- return NULL; +- } +- return hdhomerun_device_create((uint32_t)device_id, 0, 0, dbg); +- } +- +- if (*ptr == '-') { +- unsigned long device_id; +- unsigned int tuner; +- if (sscanf(device_str, "%lx-%u", &device_id, &tuner) != 2) { +- return NULL; +- } +- return hdhomerun_device_create((uint32_t)device_id, 0, tuner, dbg); +- } +- +- return NULL; +-} +- +-static struct hdhomerun_device_t *hdhomerun_device_create_from_str_ip(const char *device_str, struct hdhomerun_debug_t *dbg) +-{ +- unsigned long a[4]; +- if (sscanf(device_str, "%lu.%lu.%lu.%lu", &a[0], &a[1], &a[2], &a[3]) != 4) { +- return NULL; +- } +- +- unsigned long device_ip = (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0); +- return hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, (uint32_t)device_ip, 0, dbg); +-} +- +-static struct hdhomerun_device_t *hdhomerun_device_create_from_str_dns(const char *device_str, struct hdhomerun_debug_t *dbg) +-{ +-#if defined(__CYGWIN__) +- return NULL; +-#else +- 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 NULL; +- } +- +- struct sockaddr_in *sock_addr = (struct sockaddr_in *)sock_info->ai_addr; +- uint32_t device_ip = ntohl(sock_addr->sin_addr.s_addr); +- freeaddrinfo(sock_info); +- +- if (device_ip == 0) { +- return NULL; +- } +- +- return hdhomerun_device_create(HDHOMERUN_DEVICE_ID_WILDCARD, (uint32_t)device_ip, 0, dbg); +-#endif +-} +- +-struct hdhomerun_device_t *hdhomerun_device_create_from_str(const char *device_str, struct hdhomerun_debug_t *dbg) +-{ +- struct hdhomerun_device_t *device = hdhomerun_device_create_from_str_device_id(device_str, dbg); +- if (device) { +- return device; +- } +- +- device = hdhomerun_device_create_from_str_ip(device_str, dbg); +- if (device) { +- return device; +- } +- +- device = hdhomerun_device_create_from_str_dns(device_str, dbg); +- if (device) { +- return device; +- } +- +- return NULL; +-} +- +-int hdhomerun_device_set_tuner_from_str(struct hdhomerun_device_t *hd, const char *tuner_str) +-{ +- unsigned int tuner; +- if (sscanf(tuner_str, "%u", &tuner) == 1) { +- hdhomerun_device_set_tuner(hd, tuner); +- return 1; +- } +- if (sscanf(tuner_str, "/tuner%u", &tuner) == 1) { +- hdhomerun_device_set_tuner(hd, tuner); +- return 1; +- } +- +- return -1; +-} +- +-const char *hdhomerun_device_get_name(struct hdhomerun_device_t *hd) +-{ +- return hd->name; +-} +- +-uint32_t hdhomerun_device_get_device_id(struct hdhomerun_device_t *hd) +-{ +- return hdhomerun_control_get_device_id(hd->cs); +-} +- +-uint32_t hdhomerun_device_get_device_ip(struct hdhomerun_device_t *hd) +-{ +- return hdhomerun_control_get_device_ip(hd->cs); +-} +- +-uint32_t hdhomerun_device_get_device_id_requested(struct hdhomerun_device_t *hd) +-{ +- return hdhomerun_control_get_device_id_requested(hd->cs); +-} +- +-uint32_t hdhomerun_device_get_device_ip_requested(struct hdhomerun_device_t *hd) +-{ +- return hdhomerun_control_get_device_ip_requested(hd->cs); +-} +- +-unsigned int hdhomerun_device_get_tuner(struct hdhomerun_device_t *hd) ++void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner) + { +- return hd->tuner; ++ hd->tuner = tuner; + } + + struct hdhomerun_control_sock_t *hdhomerun_device_get_control_sock(struct hdhomerun_device_t *hd) +@@ -264,16 +72,9 @@ + + struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_device_t *hd) + { +- if (hd->vs) { +- return hd->vs; +- } +- +- hd->vs = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S * 2, hd->dbg); + if (!hd->vs) { +- hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_video_sock: failed to create video object\n"); +- return NULL; ++ hd->vs = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S); + } +- + return hd->vs; + } + +@@ -295,73 +96,7 @@ + return (uint32_t)value; + } + +-static bool_t hdhomerun_device_get_tuner_status_lock_is_bcast(struct hdhomerun_tuner_status_t *status) +-{ +- if (strcmp(status->lock_str, "8vsb") == 0) { +- return TRUE; +- } +- if (strncmp(status->lock_str, "t8", 2) == 0) { +- return TRUE; +- } +- if (strncmp(status->lock_str, "t7", 2) == 0) { +- return TRUE; +- } +- if (strncmp(status->lock_str, "t6", 2) == 0) { +- return TRUE; +- } +- +- return FALSE; +-} +- +-uint32_t hdhomerun_device_get_tuner_status_ss_color(struct hdhomerun_tuner_status_t *status) +-{ +- unsigned int ss_yellow_min; +- unsigned int ss_green_min; +- +- if (!status->lock_supported) { +- return HDHOMERUN_STATUS_COLOR_NEUTRAL; +- } +- +- if (hdhomerun_device_get_tuner_status_lock_is_bcast(status)) { +- ss_yellow_min = 50; /* -30dBmV */ +- ss_green_min = 75; /* -15dBmV */ +- } else { +- ss_yellow_min = 80; /* -12dBmV */ +- ss_green_min = 90; /* -6dBmV */ +- } +- +- if (status->signal_strength >= ss_green_min) { +- return HDHOMERUN_STATUS_COLOR_GREEN; +- } +- if (status->signal_strength >= ss_yellow_min) { +- return HDHOMERUN_STATUS_COLOR_YELLOW; +- } +- +- return HDHOMERUN_STATUS_COLOR_RED; +-} +- +-uint32_t hdhomerun_device_get_tuner_status_snq_color(struct hdhomerun_tuner_status_t *status) +-{ +- if (status->signal_to_noise_quality >= 70) { +- return HDHOMERUN_STATUS_COLOR_GREEN; +- } +- if (status->signal_to_noise_quality >= 50) { +- return HDHOMERUN_STATUS_COLOR_YELLOW; +- } +- +- return HDHOMERUN_STATUS_COLOR_RED; +-} +- +-uint32_t hdhomerun_device_get_tuner_status_seq_color(struct hdhomerun_tuner_status_t *status) +-{ +- if (status->symbol_error_quality >= 100) { +- return HDHOMERUN_STATUS_COLOR_GREEN; +- } +- +- return HDHOMERUN_STATUS_COLOR_RED; +-} +- +-int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, char **pstatus_str, struct hdhomerun_tuner_status_t *status) ++int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status) + { + memset(status, 0, sizeof(struct hdhomerun_tuner_status_t)); + +@@ -374,18 +109,9 @@ + return ret; + } + +- if (pstatus_str) { +- *pstatus_str = status_str; +- } +- + char *channel = strstr(status_str, "ch="); + if (channel) { +- sscanf(channel + 3, "%31s", status->channel); +- } +- +- char *lock = strstr(status_str, "lock="); +- if (lock) { +- sscanf(lock + 5, "%31s", status->lock_str); ++ sscanf(channel + 3, "%s", status->channel); + } + + status->signal_strength = (unsigned int)hdhomerun_device_get_status_parse(status_str, "ss="); +@@ -394,16 +120,6 @@ + status->raw_bits_per_second = hdhomerun_device_get_status_parse(status_str, "bps="); + status->packets_per_second = hdhomerun_device_get_status_parse(status_str, "pps="); + +- status->signal_present = status->signal_strength >= 45; +- +- if (strcmp(status->lock_str, "none") != 0) { +- if (status->lock_str[0] == '(') { +- status->lock_unsupported = TRUE; +- } else { +- status->lock_supported = TRUE; +- } +- } +- + return 1; + } + +@@ -435,74 +151,26 @@ + return hdhomerun_control_get(hd->cs, name, pfilter, NULL); + } + +-int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, char **pprogram) ++int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, uint16_t *pprogram_number) + { + char name[32]; + sprintf(name, "/tuner%u/program", hd->tuner); +- return hdhomerun_control_get(hd->cs, name, pprogram, NULL); +-} +- +-int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget) +-{ +- char name[32]; +- sprintf(name, "/tuner%u/target", hd->tuner); +- return hdhomerun_control_get(hd->cs, name, ptarget, NULL); +-} +- +-int hdhomerun_device_get_tuner_plotsample(struct hdhomerun_device_t *hd, struct hdhomerun_plotsample_t **psamples, size_t *pcount) +-{ +- char name[32]; +- sprintf(name, "/tuner%u/plotsample", hd->tuner); + +- char *result; +- int ret = hdhomerun_control_get(hd->cs, name, &result, NULL); ++ char *program_str; ++ int ret = hdhomerun_control_get(hd->cs, name, &program_str, NULL); + if (ret <= 0) { + return ret; + } + +- struct hdhomerun_plotsample_t *samples = (struct hdhomerun_plotsample_t *)result; +- *psamples = samples; +- size_t count = 0; +- +- while (1) { +- char *ptr = strchr(result, ' '); +- if (!ptr) { +- break; +- } +- *ptr++ = 0; +- +- unsigned long raw; +- if (sscanf(result, "%lx", &raw) != 1) { +- break; +- } +- +- uint16_t real = (raw >> 12) & 0x0FFF; +- if (real & 0x0800) { +- real |= 0xF000; +- } +- +- uint16_t imag = (raw >> 0) & 0x0FFF; +- if (imag & 0x0800) { +- imag |= 0xF000; +- } +- +- samples->real = (int16_t)real; +- samples->imag = (int16_t)imag; +- samples++; +- count++; +- +- result = ptr; +- } +- +- *pcount = count; ++ *pprogram_number = (uint16_t)atol(program_str); + return 1; + } + +-int hdhomerun_device_get_tuner_lockkey_owner(struct hdhomerun_device_t *hd, char **powner) ++int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget) + { + char name[32]; +- sprintf(name, "/tuner%u/lockkey", hd->tuner); +- return hdhomerun_control_get(hd->cs, name, powner, NULL); ++ sprintf(name, "/tuner%u/target", hd->tuner); ++ return hdhomerun_control_get(hd->cs, name, ptarget, NULL); + } + + int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget) +@@ -510,11 +178,6 @@ + return hdhomerun_control_get(hd->cs, "/ir/target", ptarget, NULL); + } + +-int hdhomerun_device_get_lineup_location(struct hdhomerun_device_t *hd, char **plocation) +-{ +- return hdhomerun_control_get(hd->cs, "/lineup/location", plocation, NULL); +-} +- + int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num) + { + char *version_str; +@@ -543,119 +206,44 @@ + { + char name[32]; + sprintf(name, "/tuner%u/channel", hd->tuner); +- return hdhomerun_control_set_with_lockkey(hd->cs, name, channel, hd->lockkey, NULL, NULL); ++ return hdhomerun_control_set(hd->cs, name, channel, NULL, NULL); + } + + int hdhomerun_device_set_tuner_channelmap(struct hdhomerun_device_t *hd, const char *channelmap) + { + char name[32]; + sprintf(name, "/tuner%u/channelmap", hd->tuner); +- return hdhomerun_control_set_with_lockkey(hd->cs, name, channelmap, hd->lockkey, NULL, NULL); ++ return hdhomerun_control_set(hd->cs, name, channelmap, NULL, NULL); + } + + int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char *filter) + { + char name[32]; + sprintf(name, "/tuner%u/filter", hd->tuner); +- return hdhomerun_control_set_with_lockkey(hd->cs, name, filter, hd->lockkey, NULL, NULL); +-} +- +-static int hdhomerun_device_set_tuner_filter_by_array_append(char **pptr, char *end, uint16_t range_begin, uint16_t range_end) +-{ +- char *ptr = *pptr; +- +- size_t available = end - ptr; +- size_t required; +- +- if (range_begin == range_end) { +- required = snprintf(ptr, available, "0x%04x ", range_begin) + 1; +- } else { +- required = snprintf(ptr, available, "0x%04x-0x%04x ", range_begin, range_end) + 1; +- } +- +- if (required > available) { +- return FALSE; +- } +- +- *pptr = strchr(ptr, 0); +- return TRUE; +-} +- +-int hdhomerun_device_set_tuner_filter_by_array(struct hdhomerun_device_t *hd, unsigned char filter_array[0x2000]) +-{ +- char filter[1024]; +- char *ptr = filter; +- char *end = filter + sizeof(filter); +- +- uint16_t range_begin = 0xFFFF; +- uint16_t range_end = 0xFFFF; +- +- uint16_t i; +- for (i = 0; i <= 0x1FFF; i++) { +- if (!filter_array[i]) { +- if (range_begin == 0xFFFF) { +- continue; +- } +- if (!hdhomerun_device_set_tuner_filter_by_array_append(&ptr, end, range_begin, range_end)) { +- return 0; +- } +- range_begin = 0xFFFF; +- range_end = 0xFFFF; +- continue; +- } +- +- if (range_begin == 0xFFFF) { +- range_begin = i; +- range_end = i; +- continue; +- } +- +- range_end = i; +- } +- +- if (range_begin != 0xFFFF) { +- if (!hdhomerun_device_set_tuner_filter_by_array_append(&ptr, end, range_begin, range_end)) { +- return 0; +- } +- } +- +- /* Remove trailing space. */ +- if (ptr > filter) { +- ptr--; +- } +- *ptr = 0; +- +- return hdhomerun_device_set_tuner_filter(hd, filter); ++ return hdhomerun_control_set(hd->cs, name, filter, NULL, NULL); + } + +-int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, const char *program) ++int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, uint16_t program_number) + { +- char name[32]; ++ char name[32], value[32]; + sprintf(name, "/tuner%u/program", hd->tuner); +- return hdhomerun_control_set_with_lockkey(hd->cs, name, program, hd->lockkey, NULL, NULL); ++ sprintf(value, "%u", program_number); ++ return hdhomerun_control_set(hd->cs, name, value, NULL, NULL); + } + +-int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, const char *target) ++int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, char *target) + { + char name[32]; + sprintf(name, "/tuner%u/target", hd->tuner); +- return hdhomerun_control_set_with_lockkey(hd->cs, name, target, hd->lockkey, NULL, NULL); ++ return hdhomerun_control_set(hd->cs, name, target, NULL, NULL); + } + +-int hdhomerun_device_set_tuner_target_to_local_protocol(struct hdhomerun_device_t *hd, const char *protocol) ++static int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd) + { +- /* Create video socket. */ +- hdhomerun_device_get_video_sock(hd); +- if (!hd->vs) { +- return -1; +- } +- +- /* Set target. */ + char target[64]; + uint32_t local_ip = hdhomerun_control_get_local_addr(hd->cs); + uint16_t local_port = hdhomerun_video_get_local_port(hd->vs); +- sprintf(target, "%s://%u.%u.%u.%u:%u", +- protocol, ++ sprintf(target, "%u.%u.%u.%u:%u", + (unsigned int)(local_ip >> 24) & 0xFF, (unsigned int)(local_ip >> 16) & 0xFF, + (unsigned int)(local_ip >> 8) & 0xFF, (unsigned int)(local_ip >> 0) & 0xFF, + (unsigned int)local_port +@@ -664,21 +252,11 @@ + return hdhomerun_device_set_tuner_target(hd, target); + } + +-int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd) +-{ +- return hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_UDP); +-} +- + int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target) + { + return hdhomerun_control_set(hd->cs, "/ir/target", target, NULL, NULL); + } + +-int hdhomerun_device_set_lineup_location(struct hdhomerun_device_t *hd, const char *location) +-{ +- return hdhomerun_control_set(hd->cs, "/lineup/location", location, NULL, NULL); +-} +- + int hdhomerun_device_get_var(struct hdhomerun_device_t *hd, const char *name, char **pvalue, char **perror) + { + return hdhomerun_control_get(hd->cs, name, pvalue, perror); +@@ -686,183 +264,41 @@ + + int hdhomerun_device_set_var(struct hdhomerun_device_t *hd, const char *name, const char *value, char **pvalue, char **perror) + { +- return hdhomerun_control_set_with_lockkey(hd->cs, name, value, hd->lockkey, pvalue, perror); +-} +- +-int hdhomerun_device_tuner_lockkey_request(struct hdhomerun_device_t *hd, char **perror) +-{ +- uint32_t new_lockkey = (uint32_t)getcurrenttime(); +- +- char name[32]; +- sprintf(name, "/tuner%u/lockkey", hd->tuner); +- +- char new_lockkey_str[64]; +- sprintf(new_lockkey_str, "%u", (unsigned int)new_lockkey); +- +- int ret = hdhomerun_control_set_with_lockkey(hd->cs, name, new_lockkey_str, hd->lockkey, NULL, perror); +- if (ret <= 0) { +- hd->lockkey = 0; +- return ret; +- } +- +- hd->lockkey = new_lockkey; +- return ret; +-} +- +-int hdhomerun_device_tuner_lockkey_release(struct hdhomerun_device_t *hd) +-{ +- if (hd->lockkey == 0) { +- return 1; +- } +- +- char name[32]; +- sprintf(name, "/tuner%u/lockkey", hd->tuner); +- int ret = hdhomerun_control_set_with_lockkey(hd->cs, name, "none", hd->lockkey, NULL, NULL); +- +- hd->lockkey = 0; +- return ret; +-} +- +-int hdhomerun_device_tuner_lockkey_force(struct hdhomerun_device_t *hd) +-{ +- char name[32]; +- sprintf(name, "/tuner%u/lockkey", hd->tuner); +- int ret = hdhomerun_control_set(hd->cs, name, "force", NULL, NULL); +- +- hd->lockkey = 0; +- return ret; +-} +- +-void hdhomerun_device_tuner_lockkey_use_value(struct hdhomerun_device_t *hd, uint32_t lockkey) +-{ +- hd->lockkey = lockkey; ++ return hdhomerun_control_set(hd->cs, name, value, pvalue, perror); + } + +-int hdhomerun_device_wait_for_lock(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status) ++int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd) + { +- /* Delay for SS reading to be valid (signal present). */ +- msleep(250); +- +- /* Wait for up to 2.5 seconds for lock. */ +- uint64_t timeout = getcurrenttime() + 2500; +- while (1) { +- /* Get status to check for lock. Quality numbers will not be valid yet. */ +- int ret = hdhomerun_device_get_tuner_status(hd, NULL, status); +- if (ret <= 0) { +- return ret; +- } +- +- if (!status->signal_present) { +- return 1; +- } +- if (status->lock_supported || status->lock_unsupported) { +- return 1; +- } +- +- if (getcurrenttime() >= timeout) { +- return 1; +- } +- +- msleep(250); ++ /* Create video socket. */ ++ hdhomerun_device_get_video_sock(hd); ++ if (!hd->vs) { ++ return -1; + } +-} + +-int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd) +-{ + /* Set target. */ +- int ret = hdhomerun_device_stream_refresh_target(hd); ++ int ret = hdhomerun_device_set_tuner_target_to_local(hd); + if (ret <= 0) { + return ret; + } + + /* Flush video buffer. */ +- msleep(64); ++ usleep(64000); + hdhomerun_video_flush(hd->vs); + + /* Success. */ + return 1; + } + +-int hdhomerun_device_stream_refresh_target(struct hdhomerun_device_t *hd) +-{ +- int ret = hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_RTP); +- if (ret == 0) { +- ret = hdhomerun_device_set_tuner_target_to_local_protocol(hd, HDHOMERUN_TARGET_PROTOCOL_UDP); +- } +- return ret; +-} +- + uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size) + { +- if (!hd->vs) { +- return NULL; +- } + return hdhomerun_video_recv(hd->vs, max_size, pactual_size); + } + +-void hdhomerun_device_stream_flush(struct hdhomerun_device_t *hd) +-{ +- hdhomerun_video_flush(hd->vs); +-} +- + void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd) + { + hdhomerun_device_set_tuner_target(hd, "none"); + } + +-int hdhomerun_device_channelscan_init(struct hdhomerun_device_t *hd, const char *channelmap) +-{ +- if (hd->scan) { +- channelscan_destroy(hd->scan); +- } +- +- hd->scan = channelscan_create(hd, channelmap); +- if (!hd->scan) { +- return -1; +- } +- +- return 1; +-} +- +-int hdhomerun_device_channelscan_advance(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result) +-{ +- if (!hd->scan) { +- return 0; +- } +- +- int ret = channelscan_advance(hd->scan, result); +- if (ret <= 0) { +- channelscan_destroy(hd->scan); +- hd->scan = NULL; +- } +- +- return ret; +-} +- +-int hdhomerun_device_channelscan_detect(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result) +-{ +- if (!hd->scan) { +- return 0; +- } +- +- int ret = channelscan_detect(hd->scan, result); +- if (ret <= 0) { +- channelscan_destroy(hd->scan); +- hd->scan = NULL; +- } +- +- return ret; +-} +- +-uint8_t hdhomerun_device_channelscan_get_progress(struct hdhomerun_device_t *hd) +-{ +- if (!hd->scan) { +- return 0; +- } +- +- return channelscan_get_progress(hd->scan); +-} +- + int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features) + { + uint32_t version; +@@ -870,74 +306,16 @@ + return -1; + } + +- if (version < 20070219) { +- return 0; ++ if (version >= 20061213) { ++ return 1; + } + +- return 1; +-} +- +-const char *hdhomerun_device_get_model_str(struct hdhomerun_device_t *hd) +-{ +- if (*hd->model) { +- return hd->model; +- } +- +- char *model_str; +- int ret = hdhomerun_control_get(hd->cs, "/sys/model", &model_str, NULL); +- if (ret < 0) { +- return NULL; +- } +- if (ret == 0) { +- model_str = "hdhomerun_atsc"; +- } +- +- strncpy(hd->model, model_str, sizeof(hd->model) - 1); +- hd->model[sizeof(hd->model) - 1] = 0; +- +- return hd->model; ++ return 0; + } + + int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file) + { +- hdhomerun_control_set(hd->cs, "/tuner0/lockkey", "force", NULL, NULL); + hdhomerun_control_set(hd->cs, "/tuner0/channel", "none", NULL, NULL); +- +- hdhomerun_control_set(hd->cs, "/tuner1/lockkey", "force", NULL, NULL); + hdhomerun_control_set(hd->cs, "/tuner1/channel", "none", NULL, NULL); +- + return hdhomerun_control_upgrade(hd->cs, upgrade_file); + } +- +-void hdhomerun_device_debug_print_video_stats(struct hdhomerun_device_t *hd) +-{ +- if (!hdhomerun_debug_enabled(hd->dbg)) { +- return; +- } +- +- char name[32]; +- sprintf(name, "/tuner%u/debug", hd->tuner); +- +- char *debug_str; +- char *error_str; +- int ret = hdhomerun_control_get(hd->cs, name, &debug_str, &error_str); +- if (ret < 0) { +- hdhomerun_debug_printf(hd->dbg, "video dev: communication error getting debug stats\n"); +- return; +- } +- +- if (error_str) { +- hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", error_str); +- } else { +- hdhomerun_debug_printf(hd->dbg, "video dev: %s\n", debug_str); +- } +- +- if (hd->vs) { +- hdhomerun_video_debug_print_stats(hd->vs); +- } +-} +- +-void hdhomerun_device_get_video_stats(struct hdhomerun_device_t *hd, struct hdhomerun_video_stats_t *stats) +-{ +- hdhomerun_video_get_stats(hd->vs, stats); +-} +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_device.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_device.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_device.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_device.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_device.h + * +- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,20 +14,8 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + + #ifdef __cplusplus +@@ -38,8 +26,16 @@ + #define HDHOMERUN_DEVICE_MAX_LOCK_TO_DATA_TIME 2000 + #define HDHOMERUN_DEVICE_MAX_TUNE_TO_DATA_TIME (HDHOMERUN_DEVICE_MAX_TUNE_TO_LOCK_TIME + HDHOMERUN_DEVICE_MAX_LOCK_TO_DATA_TIME) + +-#define HDHOMERUN_TARGET_PROTOCOL_UDP "udp" +-#define HDHOMERUN_TARGET_PROTOCOL_RTP "rtp" ++struct hdhomerun_device_t; ++ ++struct hdhomerun_tuner_status_t { ++ char channel[32]; ++ unsigned int signal_strength; ++ unsigned int signal_to_noise_quality; ++ unsigned int symbol_error_quality; ++ uint32_t raw_bits_per_second; ++ uint32_t packets_per_second; ++}; + + /* + * Create a device object. +@@ -49,49 +45,22 @@ + * + * For example, a threaded application that streams video from 4 tuners (2 HDHomeRun devices) and has + * GUI feedback to the user of the selected tuner might use 5 device objects: 4 for streaming video +- * (one per thread) and one for the GUI display that can switch between tuners. ++ * (one per thread) and one for the GUI display that can just between tuners. + * +- * This function will not attempt to connect to the device. The connection will be established when first used. ++ * This function will not attempt to connect to the device. ++ * The connection will be established when first used. + * + * uint32_t device_id = 32-bit device id of device. Set to HDHOMERUN_DEVICE_ID_WILDCARD to match any device ID. + * uint32_t device_ip = IP address of device. Set to 0 to auto-detect. + * unsigned int tuner = tuner index (0 or 1). Can be changed later by calling hdhomerun_device_set_tuner. +- * struct hdhomerun_debug_t *dbg: Pointer to debug logging object. May be NULL. + * + * Returns a pointer to the newly created device object. + * + * When no longer needed, the socket should be destroyed by calling hdhomerun_device_destroy. +- * +- * The hdhomerun_device_create_from_str function creates a device object from the given device_str. +- * The device_str parameter can be any of the following forms: +- * <device id> +- * <device id>-<tuner index> +- * <ip address> +- * If the tuner index is not included in the device_str then it is set to zero. Use hdhomerun_device_set_tuner +- * or hdhomerun_device_set_tuner_from_str to set the tuner. +- * +- * The hdhomerun_device_set_tuner_from_str function sets the tuner from the given tuner_str. +- * The tuner_str parameter can be any of the following forms: +- * <tuner index> +- * /tuner<tuner index> + */ +-extern LIBTYPE struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner, struct hdhomerun_debug_t *dbg); +-extern LIBTYPE struct hdhomerun_device_t *hdhomerun_device_create_from_str(const char *device_str, struct hdhomerun_debug_t *dbg); +-extern LIBTYPE void hdhomerun_device_destroy(struct hdhomerun_device_t *hd); +- +-/* +- * Get the device id, ip, or tuner of the device instance. +- */ +-extern LIBTYPE const char *hdhomerun_device_get_name(struct hdhomerun_device_t *hd); +-extern LIBTYPE uint32_t hdhomerun_device_get_device_id(struct hdhomerun_device_t *hd); +-extern LIBTYPE uint32_t hdhomerun_device_get_device_ip(struct hdhomerun_device_t *hd); +-extern LIBTYPE uint32_t hdhomerun_device_get_device_id_requested(struct hdhomerun_device_t *hd); +-extern LIBTYPE uint32_t hdhomerun_device_get_device_ip_requested(struct hdhomerun_device_t *hd); +-extern LIBTYPE unsigned int hdhomerun_device_get_tuner(struct hdhomerun_device_t *hd); +- +-extern LIBTYPE void hdhomerun_device_set_device(struct hdhomerun_device_t *hd, uint32_t device_id, uint32_t device_ip); +-extern LIBTYPE void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner); +-extern LIBTYPE int hdhomerun_device_set_tuner_from_str(struct hdhomerun_device_t *hd, const char *tuner_str); ++extern struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner); ++extern void hdhomerun_device_destroy(struct hdhomerun_device_t *hd); ++extern void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner); + + /* + * Get the local machine IP address used when communicating with the device. +@@ -100,7 +69,7 @@ + * + * Returns 32-bit IP address with native endianness, or 0 on error. + */ +-extern LIBTYPE uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd); ++extern uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd); + + /* + * Get operations. +@@ -113,24 +82,15 @@ + * Returns 0 if the operation was rejected. + * Returns -1 if a communication error occurred. + */ +-extern LIBTYPE int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, char **pstatus_str, struct hdhomerun_tuner_status_t *status); +-extern LIBTYPE int hdhomerun_device_get_tuner_streaminfo(struct hdhomerun_device_t *hd, char **pstreaminfo); +-extern LIBTYPE int hdhomerun_device_get_tuner_channel(struct hdhomerun_device_t *hd, char **pchannel); +-extern LIBTYPE int hdhomerun_device_get_tuner_channelmap(struct hdhomerun_device_t *hd, char **pchannelmap); +-extern LIBTYPE int hdhomerun_device_get_tuner_filter(struct hdhomerun_device_t *hd, char **pfilter); +-extern LIBTYPE int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, char **pprogram); +-extern LIBTYPE int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget); +-extern LIBTYPE int hdhomerun_device_get_tuner_plotsample(struct hdhomerun_device_t *hd, struct hdhomerun_plotsample_t **psamples, size_t *pcount); +-extern LIBTYPE int hdhomerun_device_get_tuner_lockkey_owner(struct hdhomerun_device_t *hd, char **powner); +-extern LIBTYPE int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget); +-extern LIBTYPE int hdhomerun_device_get_lineup_location(struct hdhomerun_device_t *hd, char **plocation); +-extern LIBTYPE int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num); +- +-extern LIBTYPE uint32_t hdhomerun_device_get_tuner_status_ss_color(struct hdhomerun_tuner_status_t *status); +-extern LIBTYPE uint32_t hdhomerun_device_get_tuner_status_snq_color(struct hdhomerun_tuner_status_t *status); +-extern LIBTYPE uint32_t hdhomerun_device_get_tuner_status_seq_color(struct hdhomerun_tuner_status_t *status); +- +-extern LIBTYPE const char *hdhomerun_device_get_model_str(struct hdhomerun_device_t *hd); ++extern int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status); ++extern int hdhomerun_device_get_tuner_streaminfo(struct hdhomerun_device_t *hd, char **pstreaminfo); ++extern int hdhomerun_device_get_tuner_channel(struct hdhomerun_device_t *hd, char **pchannel); ++extern int hdhomerun_device_get_tuner_channelmap(struct hdhomerun_device_t *hd, char **pchannelmap); ++extern int hdhomerun_device_get_tuner_filter(struct hdhomerun_device_t *hd, char **pfilter); ++extern int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, uint16_t *pprogram_number); ++extern int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget); ++extern int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget); ++extern int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num); + + /* + * Set operations. +@@ -141,16 +101,12 @@ + * Returns 0 if the operation was rejected. + * Returns -1 if a communication error occurred. + */ +-extern LIBTYPE int hdhomerun_device_set_tuner_channel(struct hdhomerun_device_t *hd, const char *channel); +-extern LIBTYPE int hdhomerun_device_set_tuner_channelmap(struct hdhomerun_device_t *hd, const char *channelmap); +-extern LIBTYPE int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char *filter); +-extern LIBTYPE int hdhomerun_device_set_tuner_filter_by_array(struct hdhomerun_device_t *hd, unsigned char filter_array[0x2000]); +-extern LIBTYPE int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, const char *program); +-extern LIBTYPE int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, const char *target); +-extern LIBTYPE int hdhomerun_device_set_tuner_target_to_local_protocol(struct hdhomerun_device_t *hd, const char *protocol); +-extern LIBTYPE int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd); +-extern LIBTYPE int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target); +-extern LIBTYPE int hdhomerun_device_set_lineup_location(struct hdhomerun_device_t *hd, const char *location); ++extern int hdhomerun_device_set_tuner_channel(struct hdhomerun_device_t *hd, const char *channel); ++extern int hdhomerun_device_set_tuner_channelmap(struct hdhomerun_device_t *hd, const char *channelmap); ++extern int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char *filter); ++extern int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, uint16_t program_number); ++extern int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, char *target); ++extern int hdhomerun_device_set_ir_target(struct hdhomerun_device_t *hd, const char *target); + + /* + * Get/set a named control variable on the device. +@@ -169,42 +125,8 @@ + * Returns 0 if the operation was rejected (pvalue NULL, perror set). + * Returns -1 if a communication error occurs. + */ +-extern LIBTYPE int hdhomerun_device_get_var(struct hdhomerun_device_t *hd, const char *name, char **pvalue, char **perror); +-extern LIBTYPE int hdhomerun_device_set_var(struct hdhomerun_device_t *hd, const char *name, const char *value, char **pvalue, char **perror); +- +-/* +- * Tuner locking. +- * +- * The hdhomerun_device_tuner_lockkey_request function is used to obtain a lock +- * or to verify that the hdhomerun_device object still holds the lock. +- * Returns 1 if the lock request was successful and the lock was obtained. +- * Returns 0 if the lock request was rejected. +- * Returns -1 if a communication error occurs. +- * +- * The hdhomerun_device_tuner_lockkey_release function is used to release a +- * previously held lock. If locking is used then this function must be called +- * before destroying the hdhomerun_device object. +- */ +-extern LIBTYPE int hdhomerun_device_tuner_lockkey_request(struct hdhomerun_device_t *hd, char **perror); +-extern LIBTYPE int hdhomerun_device_tuner_lockkey_release(struct hdhomerun_device_t *hd); +-extern LIBTYPE int hdhomerun_device_tuner_lockkey_force(struct hdhomerun_device_t *hd); +- +-/* +- * Intended only for non persistent connections; eg, hdhomerun_config. +- */ +-extern LIBTYPE void hdhomerun_device_tuner_lockkey_use_value(struct hdhomerun_device_t *hd, uint32_t lockkey); +- +-/* +- * Wait for tuner lock after channel change. +- * +- * The hdhomerun_device_wait_for_lock function is used to detect/wait for a lock vs no lock indication +- * after a channel change. +- * +- * It will return quickly if a lock is aquired. +- * It will return quickly if there is no signal detected. +- * Worst case it will time out after 1.5 seconds - the case where there is signal but no lock. +- */ +-extern LIBTYPE int hdhomerun_device_wait_for_lock(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status); ++extern int hdhomerun_device_get_var(struct hdhomerun_device_t *hd, const char *name, char **pvalue, char **perror); ++extern int hdhomerun_device_set_var(struct hdhomerun_device_t *hd, const char *name, const char *value, char **pvalue, char **perror); + + /* + * Stream a filtered program or the unfiltered stream. +@@ -222,19 +144,9 @@ + * + * The hdhomerun_device_stream_stop function tells the device to stop streaming data. + */ +-extern LIBTYPE int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd); +-extern LIBTYPE int hdhomerun_device_stream_refresh_target(struct hdhomerun_device_t *hd); +-extern LIBTYPE uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size); +-extern LIBTYPE void hdhomerun_device_stream_flush(struct hdhomerun_device_t *hd); +-extern LIBTYPE void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd); +- +-/* +- * Channel scan API. +- */ +-extern LIBTYPE int hdhomerun_device_channelscan_init(struct hdhomerun_device_t *hd, const char *channelmap); +-extern LIBTYPE int hdhomerun_device_channelscan_advance(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result); +-extern LIBTYPE int hdhomerun_device_channelscan_detect(struct hdhomerun_device_t *hd, struct hdhomerun_channelscan_result_t *result); +-extern LIBTYPE uint8_t hdhomerun_device_channelscan_get_progress(struct hdhomerun_device_t *hd); ++extern int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd); ++extern uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size); ++extern void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd); + + /* + * Check that the device is running the recommended firmware. +@@ -245,7 +157,7 @@ + * Returns 0 if th firmware does not meet the minimum requriements for all operations. + * Returns -1 if an error occurs. + */ +-extern LIBTYPE int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features); ++extern int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features); + + /* + * Upload new firmware to the device. +@@ -256,19 +168,13 @@ + * Returns 0 if the upload was rejected. + * Returns -1 if an error occurs. + */ +-extern LIBTYPE int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file); ++extern int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file); + + /* + * Low level accessor functions. + */ +-extern LIBTYPE struct hdhomerun_control_sock_t *hdhomerun_device_get_control_sock(struct hdhomerun_device_t *hd); +-extern LIBTYPE struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_device_t *hd); +- +-/* +- * Debug print internal stats. +- */ +-extern LIBTYPE void hdhomerun_device_debug_print_video_stats(struct hdhomerun_device_t *hd); +-extern LIBTYPE void hdhomerun_device_get_video_stats(struct hdhomerun_device_t *hd, struct hdhomerun_video_stats_t *stats); ++extern struct hdhomerun_control_sock_t *hdhomerun_device_get_control_sock(struct hdhomerun_device_t *hd); ++extern struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_device_t *hd); + + #ifdef __cplusplus + } +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_device_selector.c +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_device_selector.h +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_dhcp.c +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_dhcp.h +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_discover.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_discover.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_discover.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_discover.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_discover.c + * +- * Copyright © 2006-2007 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,93 +14,206 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#include "hdhomerun.h" ++#include "hdhomerun_os.h" ++#include "hdhomerun_pkt.h" ++#include "hdhomerun_discover.h" + + #if defined(__CYGWIN__) || defined(__WINDOWS__) + #include <windows.h> ++#include <iptypes.h> + #include <iphlpapi.h> +-#define USE_IPHLPAPI 1 +-#else +-#include <net/if.h> +-#include <sys/ioctl.h> +-#ifndef _SIZEOF_ADDR_IFREQ +-#define _SIZEOF_ADDR_IFREQ(x) sizeof(x) +-#endif + #endif + +-#define HDHOMERUN_DISOCVER_MAX_SOCK_COUNT 16 ++// for OSX ++#include <unistd.h> // execl, pipe, sysconf ++#include <sys/types.h> // waitpid ++#include <sys/wait.h> // waitpid + + struct hdhomerun_discover_sock_t { + int sock; +- uint32_t local_ip; +- uint32_t subnet_mask; + }; + +-struct hdhomerun_discover_t { +- struct hdhomerun_discover_sock_t socks[HDHOMERUN_DISOCVER_MAX_SOCK_COUNT]; +- unsigned int sock_count; +- struct hdhomerun_pkt_t tx_pkt; +- struct hdhomerun_pkt_t rx_pkt; +-}; +- +-static bool_t hdhomerun_discover_sock_create(struct hdhomerun_discover_t *ds, uint32_t local_ip, uint32_t subnet_mask) ++static struct hdhomerun_discover_sock_t *hdhomerun_discover_create(void) + { +- if (ds->sock_count >= HDHOMERUN_DISOCVER_MAX_SOCK_COUNT) { +- return FALSE; ++ struct hdhomerun_discover_sock_t *ds = (struct hdhomerun_discover_sock_t *)malloc(sizeof(struct hdhomerun_discover_sock_t)); ++ if (!ds) { ++ return NULL; + } +- ++ + /* Create socket. */ +- int sock = (int)socket(AF_INET, SOCK_DGRAM, 0); +- if (sock == -1) { +- return FALSE; ++ ds->sock = (int)socket(AF_INET, SOCK_DGRAM, 0); ++ if (ds->sock == -1) { ++ free(ds); ++ return NULL; + } + + /* Set timeouts. */ +- setsocktimeout(sock, SOL_SOCKET, SO_SNDTIMEO, 1000); +- setsocktimeout(sock, SOL_SOCKET, SO_RCVTIMEO, 1000); ++ setsocktimeout(ds->sock, SOL_SOCKET, SO_SNDTIMEO, 1000); ++ setsocktimeout(ds->sock, SOL_SOCKET, SO_RCVTIMEO, 1000); + + /* Allow broadcast. */ + int sock_opt = 1; +- setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt)); ++ setsockopt(ds->sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt)); + + /* Bind socket. */ + struct sockaddr_in sock_addr; + memset(&sock_addr, 0, sizeof(sock_addr)); + sock_addr.sin_family = AF_INET; +- sock_addr.sin_addr.s_addr = htonl(local_ip); ++ sock_addr.sin_addr.s_addr = htonl(INADDR_ANY); + sock_addr.sin_port = htons(0); +- if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { +- close(sock); +- return FALSE; ++ if (bind(ds->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { ++ close(ds->sock); ++ free(ds); ++ return NULL; + } + +- /* Write sock entry. */ +- struct hdhomerun_discover_sock_t *dss = &ds->socks[ds->sock_count++]; +- dss->sock = sock; +- dss->local_ip = local_ip; +- dss->subnet_mask = subnet_mask; ++ /* Success. */ ++ return ds; ++} + +- return TRUE; ++static void hdhomerun_discover_destroy(struct hdhomerun_discover_sock_t *ds) ++{ ++ close(ds->sock); ++ free(ds); + } + +-#if defined(USE_IPHLPAPI) +-static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds) ++static int hdhomerun_discover_send_packet(struct hdhomerun_discover_sock_t *ds, uint32_t ip_addr, uint32_t device_type, uint32_t device_id) ++{ ++ uint8_t buffer[1024]; ++ uint8_t *ptr = buffer; ++ hdhomerun_write_discover_request(&ptr, device_type, device_id); ++ ++ struct sockaddr_in sock_addr; ++ memset(&sock_addr, 0, sizeof(sock_addr)); ++ sock_addr.sin_family = AF_INET; ++ sock_addr.sin_addr.s_addr = htonl(ip_addr); ++ sock_addr.sin_port = htons(HDHOMERUN_DISCOVER_UDP_PORT); ++ ++ int length = (int)(ptr - buffer); ++ if (sendto(ds->sock, (char *)buffer, (int)length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != length) { ++ return -1; ++ } ++ ++ return 0; ++} ++ ++#if defined(__APPLE__) ++static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id) ++{ ++ /* printf("Looking for 0x%lx with id 0x%lx\n", device_type, device_id); */ ++ int fds[2]; ++ if (pipe(fds) < 0) ++ { ++ printf("Pipe Failed\n"); ++ return -1; ++ } ++ ++ pid_t child = fork(); ++ if (child < 0) ++ { ++ printf("Fork Failed\n"); ++ return -1; ++ } ++ else if (child == 0) ++ { ++ /* Child */ ++ int i = 0; ++ ++ /* Attach stdout to pipe */ ++ close(1); ++ dup2(fds[1], 1); ++ ++ /* Close all open file descriptors except stdout/stderr */ ++ for (i = sysconf(_SC_OPEN_MAX) - 1; i > 2; i--) ++ close(i); ++ ++ /* Run command */ ++ execl("/bin/sh", "sh", "-c", "ifconfig", NULL); ++ ++ /* Failed to exec */ ++ _exit(1); /* this exit is ok */ ++ } ++ else ++ { ++ /* Parent */ ++ int send_count = 0; ++ int status; ++ FILE *fp; ++ char line[1024]; ++ char adaptor[1024]; ++ ++ close(fds[1]); ++ ++ if (waitpid(child, &status, 0) < 0) ++ return -1; ++ ++ if (WEXITSTATUS(status)) ++ return -1; ++ ++ fp = fdopen(fds[0], "r"); ++ while (1) ++ { ++ char *ptr = NULL; ++ int netmask, broadcast; ++ int a,b,c,d; ++ ++ if (!fgets(line, sizeof(line) - 1, fp)) ++ { ++ break; ++ } ++ ++ line[1023] = 0; ++ ++ /* find ": flags" */ ++ ptr = strnstr(line, ": flags", 1024 - 1); ++ if (ptr >= line) ++ { ++ /* grab adaptor before that */ ++ strncpy(adaptor, line, ptr-line); ++ adaptor[ptr-line] = 0; ++ } ++ ++ /* find "netmask " */ ++ ptr = strnstr(line, "netmask ", 1024 - 1); ++ if (ptr <= line) ++ continue; ++ ptr += strlen("netmask "); ++ sscanf(ptr, "%x", &netmask); ++ ++ /* find "broadcast " */ ++ ptr = strnstr(ptr, "broadcast ", 1024 - 1); ++ if (ptr <= line) ++ continue; ++ ptr += strlen("broadcast "); ++ sscanf(ptr, "%i.%i.%i.%i", &a, &b, &c, &d); ++ broadcast = a<<24 | b<<16 | c<<8 | d; ++ /* ++ printf("Adaptor: '%s' 0x%08x %i.%i.%i.%i\n", ++ adaptor, broadcast, a,b,c,d); ++ */ ++ ++ /* send discover packet this adaptor */ ++ if (hdhomerun_discover_send_packet( ++ ds, broadcast, device_type, device_id) >= 0) ++ { ++ send_count++; ++ } ++ } ++ ++ fclose(fp); /* this closes fds[0] as well */ ++ ++ /* printf("send_count: %i\n\n", send_count); */ ++ return (send_count == 0) ? -1 : 0; ++ } ++} ++ ++#elif defined(__CYGWIN__) || defined(__WINDOWS__) ++ ++static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id) + { + PIP_ADAPTER_INFO pAdapterInfo = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO)); + ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO); +@@ -109,29 +222,37 @@ + if (Ret != NO_ERROR) { + free(pAdapterInfo); + if (Ret != ERROR_BUFFER_OVERFLOW) { +- return; ++ return -1; + } + pAdapterInfo = (IP_ADAPTER_INFO *)malloc(ulOutBufLen); + Ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen); + if (Ret != NO_ERROR) { + free(pAdapterInfo); +- return; ++ return -1; + } + } + ++ unsigned int send_count = 0; + PIP_ADAPTER_INFO pAdapter = pAdapterInfo; + while (pAdapter) { + IP_ADDR_STRING *pIPAddr = &pAdapter->IpAddressList; + while (pIPAddr) { +- uint32_t local_ip = ntohl(inet_addr(pIPAddr->IpAddress.String)); ++ uint32_t addr = ntohl(inet_addr(pIPAddr->IpAddress.String)); + uint32_t mask = ntohl(inet_addr(pIPAddr->IpMask.String)); ++ ++ uint32_t broadcast = addr | ~mask; ++ if ((broadcast == 0x00000000) || (broadcast == 0xFFFFFFFF)) { ++ pIPAddr = pIPAddr->Next; ++ continue; ++ } + +- if (local_ip == 0) { ++ if (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) { + pIPAddr = pIPAddr->Next; + continue; + } + +- hdhomerun_discover_sock_create(ds, local_ip, mask); ++ send_count++; ++ + pIPAddr = pIPAddr->Next; + } + +@@ -139,198 +260,111 @@ + } + + free(pAdapterInfo); +-} +- +-#else + +-static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds) +-{ +- int fd = socket(AF_INET, SOCK_DGRAM, 0); +- if (fd == -1) { +- return; ++ if (send_count == 0) { ++ return -1; + } ++ return 0; ++} + +- struct ifconf ifc; +- uint8_t buf[8192]; +- ifc.ifc_len = sizeof(buf); +- ifc.ifc_buf = (char *)buf; +- +- memset(buf, 0, sizeof(buf)); ++#elif defined(__linux__) + +- if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) { +- close(fd); +- return; ++static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id) ++{ ++ FILE *fp = fopen("/proc/net/route", "r"); ++ if (!fp) { ++ return -1; + } + +- uint8_t *ptr = (uint8_t *)ifc.ifc_req; +- uint8_t *end = (uint8_t *)&ifc.ifc_buf[ifc.ifc_len]; +- +- while (ptr <= end) { +- struct ifreq *ifr = (struct ifreq *)ptr; +- ptr += _SIZEOF_ADDR_IFREQ(*ifr); ++ unsigned int send_count = 0; ++ while (1) { ++ char line[256]; ++ if (!fgets(line, sizeof(line), fp)) { ++ break; ++ } ++ line[255] = 0; + +- if (ioctl(fd, SIOCGIFADDR, ifr) != 0) { ++ uint32_t dest; ++ uint32_t mask; ++ if (sscanf(line, "%*s %x %*x %*x %*d %*d %*d %x", &dest, &mask) != 2) { + continue; + } +- struct sockaddr_in *addr_in = (struct sockaddr_in *)&(ifr->ifr_addr); +- uint32_t local_ip = ntohl(addr_in->sin_addr.s_addr); +- if (local_ip == 0) { ++ dest = ntohl(dest); ++ mask = ntohl(mask); ++ ++ uint32_t broadcast = dest | ~mask; ++ ++ if ((broadcast == 0x00000000) || (broadcast == 0xFFFFFFFF)) { + continue; + } + +- if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) { ++ if (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) { + continue; + } +- struct sockaddr_in *mask_in = (struct sockaddr_in *)&(ifr->ifr_addr); +- uint32_t mask = ntohl(mask_in->sin_addr.s_addr); + +- hdhomerun_discover_sock_create(ds, local_ip, mask); ++ send_count++; + } +-} +-#endif + +-static struct hdhomerun_discover_t *hdhomerun_discover_create(void) +-{ +- struct hdhomerun_discover_t *ds = (struct hdhomerun_discover_t *)calloc(1, sizeof(struct hdhomerun_discover_t)); +- if (!ds) { +- return NULL; +- } +- +- /* Create a routable socket. */ +- if (!hdhomerun_discover_sock_create(ds, 0, 0)) { +- free(ds); +- return NULL; ++ fclose(fp); ++ if (send_count == 0) { ++ return -1; + } +- +- /* Detect & create local sockets. */ +- hdhomerun_discover_sock_detect(ds); +- +- /* Success. */ +- return ds; ++ return 0; + } + +-static void hdhomerun_discover_destroy(struct hdhomerun_discover_t *ds) +-{ +- unsigned int i; +- for (i = 0; i < ds->sock_count; i++) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; +- close(dss->sock); +- } +- +- free(ds); +-} ++#else + +-static bool_t hdhomerun_discover_send_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, uint32_t target_ip, uint32_t device_type, uint32_t device_id) ++static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id) + { +- struct hdhomerun_pkt_t *tx_pkt = &ds->tx_pkt; +- hdhomerun_pkt_reset(tx_pkt); +- +- hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_DEVICE_TYPE); +- hdhomerun_pkt_write_var_length(tx_pkt, 4); +- hdhomerun_pkt_write_u32(tx_pkt, device_type); +- hdhomerun_pkt_write_u8(tx_pkt, HDHOMERUN_TAG_DEVICE_ID); +- hdhomerun_pkt_write_var_length(tx_pkt, 4); +- hdhomerun_pkt_write_u32(tx_pkt, device_id); +- hdhomerun_pkt_seal_frame(tx_pkt, HDHOMERUN_TYPE_DISCOVER_REQ); +- +- struct sockaddr_in sock_addr; +- memset(&sock_addr, 0, sizeof(sock_addr)); +- sock_addr.sin_family = AF_INET; +- sock_addr.sin_addr.s_addr = htonl(target_ip); +- sock_addr.sin_port = htons(HDHOMERUN_DISCOVER_UDP_PORT); +- +- int length = (int)(tx_pkt->end - tx_pkt->start); +- if (sendto(dss->sock, (char *)tx_pkt->start, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != length) { +- return FALSE; +- } +- +- return TRUE; ++ return -1; + } ++#endif + +-static bool_t hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *ds, uint32_t device_type, uint32_t device_id) ++static int hdhomerun_discover_send(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id) + { +- bool_t result = FALSE; +- +- /* +- * Send subnet broadcast using each local ip socket. +- * This will work with multiple separate 169.254.x.x interfaces. +- */ +- unsigned int i; +- for (i = 1; i < ds->sock_count; i++) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; +- uint32_t target_ip = dss->local_ip | ~dss->subnet_mask; +- result |= hdhomerun_discover_send_internal(ds, dss, target_ip, device_type, device_id); +- } +- +- /* +- * If no local ip sockets then fall back to sending a global broadcast letting the OS choose the interface. +- */ +- if (!result) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[0]; +- result = hdhomerun_discover_send_internal(ds, dss, 0xFFFFFFFF, device_type, device_id); ++ if (hdhomerun_discover_send_internal(ds, device_type, device_id) < 0) { ++ return hdhomerun_discover_send_packet(ds, 0xFFFFFFFF, device_type, device_id); + } +- +- return result; ++ return 0; + } + +-static bool_t hdhomerun_discover_send_target_ip(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id) ++static int hdhomerun_discover_recv(struct hdhomerun_discover_sock_t *ds, struct hdhomerun_discover_device_t *result) + { +- bool_t result = FALSE; +- +- /* +- * Send targeted packet from any local ip that is in the same subnet. +- * This will work with multiple separate 169.254.x.x interfaces. +- */ +- unsigned int i; +- for (i = 1; i < ds->sock_count; i++) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; +- if ((target_ip & dss->subnet_mask) != (dss->local_ip & dss->subnet_mask)) { +- continue; +- } ++ struct timeval t; ++ t.tv_sec = 0; ++ t.tv_usec = 250000; + +- result |= hdhomerun_discover_send_internal(ds, dss, target_ip, device_type, device_id); +- } ++ fd_set readfds; ++ FD_ZERO(&readfds); ++ FD_SET(ds->sock, &readfds); + +- /* +- * If target IP does not match a local subnet then fall back to letting the OS choose the gateway interface. +- */ +- if (!result) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[0]; +- result = hdhomerun_discover_send_internal(ds, dss, target_ip, device_type, device_id); ++ if (select(ds->sock+1, &readfds, NULL, NULL, &t) < 0) { ++ return -1; + } +- +- return result; +-} +- +-static bool_t hdhomerun_discover_send(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id) +-{ +- if (target_ip != 0) { +- return hdhomerun_discover_send_target_ip(ds, target_ip, device_type, device_id); ++ if (!FD_ISSET(ds->sock, &readfds)) { ++ return 0; + } + +- return hdhomerun_discover_send_wildcard_ip(ds, device_type, device_id); +-} +- +-static int hdhomerun_discover_recv_internal(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_sock_t *dss, struct hdhomerun_discover_device_t *result) +-{ +- struct hdhomerun_pkt_t *rx_pkt = &ds->rx_pkt; +- hdhomerun_pkt_reset(rx_pkt); +- ++ uint8_t buffer[1024]; + struct sockaddr_in sock_addr; +- memset(&sock_addr, 0, sizeof(sock_addr)); + socklen_t sockaddr_size = sizeof(sock_addr); +- +- int rx_length = recvfrom(dss->sock, (char *)rx_pkt->end, (int)(rx_pkt->limit - rx_pkt->end), 0, (struct sockaddr *)&sock_addr, &sockaddr_size); ++ int rx_length = recvfrom(ds->sock, (char *)buffer, sizeof(buffer), 0, (struct sockaddr *)&sock_addr, &sockaddr_size); + if (rx_length <= 0) { + /* Don't return error - windows machine on VPN can sometimes cause a sock error here but otherwise works. */ + return 0; + } +- rx_pkt->end += rx_length; ++ if (rx_length < HDHOMERUN_MIN_PEEK_LENGTH) { ++ return 0; ++ } + +- uint16_t type; +- if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) { ++ size_t length = hdhomerun_peek_packet_length(buffer); ++ if (length > (size_t)rx_length) { + return 0; + } ++ ++ uint8_t *ptr = buffer; ++ uint8_t *end = buffer + length; ++ int type = hdhomerun_process_packet(&ptr, &end); + if (type != HDHOMERUN_TYPE_DISCOVER_RPY) { + return 0; + } +@@ -338,12 +372,11 @@ + result->ip_addr = ntohl(sock_addr.sin_addr.s_addr); + result->device_type = 0; + result->device_id = 0; +- + while (1) { + uint8_t tag; + size_t len; +- uint8_t *next = hdhomerun_pkt_read_tlv(rx_pkt, &tag, &len); +- if (!next) { ++ uint8_t *value; ++ if (hdhomerun_read_tlv(&ptr, end, &tag, &len, &value) < 0) { + break; + } + +@@ -352,71 +385,28 @@ + if (len != 4) { + break; + } +- result->device_type = hdhomerun_pkt_read_u32(rx_pkt); ++ result->device_type = hdhomerun_read_u32(&value); + break; +- + case HDHOMERUN_TAG_DEVICE_ID: + if (len != 4) { + break; + } +- result->device_id = hdhomerun_pkt_read_u32(rx_pkt); ++ result->device_id = hdhomerun_read_u32(&value); + break; +- + default: + break; + } +- +- rx_pkt->pos = next; + } + + return 1; + } + +-static int hdhomerun_discover_recv(struct hdhomerun_discover_t *ds, struct hdhomerun_discover_device_t *result) +-{ +- struct timeval t; +- t.tv_sec = 0; +- t.tv_usec = 250000; +- +- fd_set readfds; +- FD_ZERO(&readfds); +- int max_sock = -1; +- +- unsigned int i; +- for (i = 0; i < ds->sock_count; i++) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; +- FD_SET(dss->sock, &readfds); +- if (dss->sock > max_sock) { +- max_sock = dss->sock; +- } +- } +- +- if (select(max_sock+1, &readfds, NULL, NULL, &t) < 0) { +- return -1; +- } +- +- for (i = 0; i < ds->sock_count; i++) { +- struct hdhomerun_discover_sock_t *dss = &ds->socks[i]; +- if (!FD_ISSET(dss->sock, &readfds)) { +- continue; +- } +- +- if (hdhomerun_discover_recv_internal(ds, dss, result) <= 0) { +- continue; +- } +- +- return 1; +- } +- +- return 0; +-} +- +-static struct hdhomerun_discover_device_t *hdhomerun_discover_find_in_list(struct hdhomerun_discover_device_t result_list[], int count, uint32_t ip_addr) ++static struct hdhomerun_discover_device_t *hdhomerun_discover_find_in_list(struct hdhomerun_discover_device_t result_list[], int count, uint32_t device_id) + { + int index; + for (index = 0; index < count; index++) { + struct hdhomerun_discover_device_t *result = &result_list[index]; +- if (result->ip_addr == ip_addr) { ++ if (result->device_id == device_id) { + return result; + } + } +@@ -424,12 +414,13 @@ + return NULL; + } + +-static int hdhomerun_discover_find_devices_internal(struct hdhomerun_discover_t *ds, uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count) ++static int hdhomerun_discover_find_devices_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count) + { + int count = 0; ++ + int attempt; + for (attempt = 0; attempt < 4; attempt++) { +- if (!hdhomerun_discover_send(ds, target_ip, device_type, device_id)) { ++ if (hdhomerun_discover_send(ds, device_type, device_id) < 0) { + return -1; + } + +@@ -442,7 +433,7 @@ + return -1; + } + if (ret == 0) { +- continue; ++ break; + } + + /* Filter. */ +@@ -458,7 +449,7 @@ + } + + /* Ensure not already in list. */ +- if (hdhomerun_discover_find_in_list(result_list, count, result->ip_addr)) { ++ if (hdhomerun_discover_find_in_list(result_list, count, result->device_id)) { + continue; + } + +@@ -473,14 +464,27 @@ + return count; + } + +-int hdhomerun_discover_find_devices_custom(uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count) ++int hdhomerun_discover_find_device(uint32_t device_id, struct hdhomerun_discover_device_t *result) ++{ ++ struct hdhomerun_discover_sock_t *ds = hdhomerun_discover_create(); ++ if (!ds) { ++ return -1; ++ } ++ ++ int ret = hdhomerun_discover_find_devices_internal(ds, HDHOMERUN_DEVICE_TYPE_WILDCARD, device_id, result, 1); ++ ++ hdhomerun_discover_destroy(ds); ++ return ret; ++} ++ ++int hdhomerun_discover_find_devices(uint32_t device_type, struct hdhomerun_discover_device_t result_list[], int max_count) + { +- struct hdhomerun_discover_t *ds = hdhomerun_discover_create(); ++ struct hdhomerun_discover_sock_t *ds = hdhomerun_discover_create(); + if (!ds) { + return -1; + } + +- int ret = hdhomerun_discover_find_devices_internal(ds, target_ip, device_type, device_id, result_list, max_count); ++ int ret = hdhomerun_discover_find_devices_internal(ds, device_type, HDHOMERUN_DEVICE_ID_WILDCARD, result_list, max_count); + + hdhomerun_discover_destroy(ds); + return ret; +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_discover.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_discover.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_discover.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_discover.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_discover.h + * +- * Copyright © 2006-2007 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,20 +14,8 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + #ifdef __cplusplus + extern "C" { +@@ -40,18 +28,29 @@ + }; + + /* +- * Find devices. ++ * Find a device by device ID. ++ * ++ * The device information is stored in caller-supplied hdhomerun_discover_device_t var. ++ * Multiple attempts are made to find the device. ++ * Worst-case execution time is 1 second. ++ * ++ * Returns 1 on success. ++ * Returns 0 if not found. ++ * Retruns -1 on error. ++ */ ++extern int hdhomerun_discover_find_device(uint32_t device_id, struct hdhomerun_discover_device_t *result); ++ ++/* ++ * Find all devices of a given type. + * + * The device information is stored in caller-supplied array of hdhomerun_discover_device_t vars. + * Multiple attempts are made to find devices. + * Execution time is 1 second. + * +- * Set target_ip to zero to auto-detect IP address. +- * + * Returns the number of devices found. + * Retruns -1 on error. + */ +-extern LIBTYPE int hdhomerun_discover_find_devices_custom(uint32_t target_ip, uint32_t device_type, uint32_t device_id, struct hdhomerun_discover_device_t result_list[], int max_count); ++extern int hdhomerun_discover_find_devices(uint32_t device_type, struct hdhomerun_discover_device_t result_list[], int max_count); + + /* + * Verify that the device ID given is valid. +@@ -62,7 +61,7 @@ + * Returns TRUE if valid. + * Returns FALSE if not valid. + */ +-extern LIBTYPE bool_t hdhomerun_discover_validate_device_id(uint32_t device_id); ++extern bool_t hdhomerun_discover_validate_device_id(uint32_t device_id); + + #ifdef __cplusplus + } +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_os.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_os.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_os.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_os.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_os.h + * +- * Copyright © 2006-2008 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,36 +14,97 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#if defined(_WIN32) || defined(_WIN64) ++#include <stdlib.h> ++#include <stdio.h> ++#include <string.h> ++ ++#if defined(WIN32) + #define __WINDOWS__ + #endif + + #if defined(__WINDOWS__) +-#include "hdhomerun_os_windows.h" ++#include <windows.h> ++#include <sys/types.h> ++#include <sys/timeb.h> + #else +-#include "hdhomerun_os_posix.h" ++#include <unistd.h> ++#include <errno.h> ++#include <sys/types.h> ++#include <sys/socket.h> ++#include <netinet/in.h> ++#include <arpa/inet.h> ++#include <netdb.h> ++#include <sys/time.h> ++#include <sys/timeb.h> ++#include <fcntl.h> + #endif + ++#include <pthread.h> ++ + #if !defined(TRUE) + #define TRUE 1 + #endif +- + #if !defined(FALSE) + #define FALSE 0 + #endif ++ ++#if defined(__WINDOWS__) ++ ++typedef int bool_t; ++typedef unsigned __int8 uint8_t; ++typedef unsigned __int16 uint16_t; ++typedef unsigned __int32 uint32_t; ++typedef unsigned __int64 uint64_t; ++ ++#define socklen_t int ++#define close closesocket ++#define sock_getlasterror WSAGetLastError() ++#define sock_getlasterror_socktimeout (WSAGetLastError() == WSAETIMEDOUT) ++#define atoll _atoi64 ++#define strcasecmp _stricmp ++#define fseeko _fseeki64 ++#define ftello _ftelli64 ++#define usleep(us) Sleep((us)/1000) ++#define sleep(sec) Sleep((sec)*1000) ++ ++static inline uint64_t getcurrenttime(void) ++{ ++ struct timeb tb; ++ ftime(&tb); ++ return ((uint64_t)tb.time * 1000) + tb.millitm; ++} ++ ++static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout) ++{ ++ int t = (int)timeout; ++ return setsockopt(s, level, optname, (char *)&t, sizeof(t)); ++} ++ ++#else ++ ++typedef int bool_t; ++ ++#define sock_getlasterror errno ++#define sock_getlasterror_socktimeout (errno == EAGAIN) ++ ++static inline uint64_t getcurrenttime(void) ++{ ++ struct timeval t; ++ gettimeofday(&t, NULL); ++ return ((uint64_t)t.tv_sec * 1000) + (t.tv_usec / 1000); ++} ++ ++static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout) ++{ ++ struct timeval t; ++ t.tv_sec = timeout / 1000; ++ t.tv_usec = (timeout % 1000) * 1000; ++ return setsockopt(s, level, optname, (char *)&t, sizeof(t)); ++} ++ ++#endif ++ +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_os_posix.h +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_os_windows.h +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_pkt.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_pkt.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_pkt.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_pkt.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_pkt.c + * +- * Copyright © 2005-2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2005-2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,232 +14,255 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#include "hdhomerun.h" ++#include "hdhomerun_os.h" ++#include "hdhomerun_pkt.h" + +-struct hdhomerun_pkt_t *hdhomerun_pkt_create(void) ++uint8_t hdhomerun_read_u8(uint8_t **pptr) + { +- struct hdhomerun_pkt_t *pkt = (struct hdhomerun_pkt_t *)calloc(1, sizeof(struct hdhomerun_pkt_t)); +- if (!pkt) { +- return NULL; +- } +- +- hdhomerun_pkt_reset(pkt); +- +- return pkt; +-} +- +-void hdhomerun_pkt_destroy(struct hdhomerun_pkt_t *pkt) +-{ +- free(pkt); +-} +- +-void hdhomerun_pkt_reset(struct hdhomerun_pkt_t *pkt) +-{ +- pkt->limit = pkt->buffer + sizeof(pkt->buffer) - 4; +- pkt->start = pkt->buffer + 1024; +- pkt->end = pkt->start; +- pkt->pos = pkt->start; +-} +- +-static uint32_t hdhomerun_pkt_calc_crc(uint8_t *start, uint8_t *end) +-{ +- uint8_t *pos = start; +- uint32_t crc = 0xFFFFFFFF; +- while (pos < end) { +- uint8_t x = (uint8_t)(crc) ^ *pos++; +- crc >>= 8; +- if (x & 0x01) crc ^= 0x77073096; +- if (x & 0x02) crc ^= 0xEE0E612C; +- if (x & 0x04) crc ^= 0x076DC419; +- if (x & 0x08) crc ^= 0x0EDB8832; +- if (x & 0x10) crc ^= 0x1DB71064; +- if (x & 0x20) crc ^= 0x3B6E20C8; +- if (x & 0x40) crc ^= 0x76DC4190; +- if (x & 0x80) crc ^= 0xEDB88320; +- } +- return crc ^ 0xFFFFFFFF; +-} +- +-uint8_t hdhomerun_pkt_read_u8(struct hdhomerun_pkt_t *pkt) +-{ +- uint8_t v = *pkt->pos++; ++ uint8_t *ptr = *pptr; ++ uint8_t v = *ptr++; ++ *pptr = ptr; + return v; + } + +-uint16_t hdhomerun_pkt_read_u16(struct hdhomerun_pkt_t *pkt) ++uint16_t hdhomerun_read_u16(uint8_t **pptr) + { ++ uint8_t *ptr = *pptr; + uint16_t v; +- v = (uint16_t)*pkt->pos++ << 8; +- v |= (uint16_t)*pkt->pos++ << 0; ++ v = (uint16_t)*ptr++ << 8; ++ v |= (uint16_t)*ptr++ << 0; ++ *pptr = ptr; + return v; + } + +-uint32_t hdhomerun_pkt_read_u32(struct hdhomerun_pkt_t *pkt) ++uint32_t hdhomerun_read_u32(uint8_t **pptr) + { ++ uint8_t *ptr = *pptr; + uint32_t v; +- v = (uint32_t)*pkt->pos++ << 24; +- v |= (uint32_t)*pkt->pos++ << 16; +- v |= (uint32_t)*pkt->pos++ << 8; +- v |= (uint32_t)*pkt->pos++ << 0; ++ v = (uint32_t)*ptr++ << 24; ++ v |= (uint32_t)*ptr++ << 16; ++ v |= (uint32_t)*ptr++ << 8; ++ v |= (uint32_t)*ptr++ << 0; ++ *pptr = ptr; + return v; + } + +-size_t hdhomerun_pkt_read_var_length(struct hdhomerun_pkt_t *pkt) ++size_t hdhomerun_read_var_length(uint8_t **pptr, uint8_t *end) + { ++ uint8_t *ptr = *pptr; + size_t length; + +- if (pkt->pos + 1 > pkt->end) { +- return (size_t)-1; ++ if (ptr + 1 > end) { ++ return -1; + } + +- length = (size_t)*pkt->pos++; ++ length = (size_t)*ptr++; + if (length & 0x0080) { +- if (pkt->pos + 1 > pkt->end) { +- return (size_t)-1; ++ if (ptr + 1 > end) { ++ return -1; + } + + length &= 0x007F; +- length |= (size_t)*pkt->pos++ << 7; ++ length |= (size_t)*ptr++ << 7; + } + ++ *pptr = ptr; + return length; + } + +-uint8_t *hdhomerun_pkt_read_tlv(struct hdhomerun_pkt_t *pkt, uint8_t *ptag, size_t *plength) ++int hdhomerun_read_tlv(uint8_t **pptr, uint8_t *end, uint8_t *ptag, size_t *plength, uint8_t **pvalue) + { +- if (pkt->pos + 2 > pkt->end) { +- return NULL; ++ if (end - *pptr < 2) { ++ return -1; + } + +- *ptag = hdhomerun_pkt_read_u8(pkt); +- *plength = hdhomerun_pkt_read_var_length(pkt); +- +- if (pkt->pos + *plength > pkt->end) { +- return NULL; ++ *ptag = hdhomerun_read_u8(pptr); ++ *plength = hdhomerun_read_var_length(pptr, end); ++ *pvalue = *pptr; ++ ++ if ((size_t)(end - *pptr) < *plength) { ++ return -1; + } + +- return pkt->pos + *plength; ++ *pptr += *plength; ++ return 0; + } + +-void hdhomerun_pkt_write_u8(struct hdhomerun_pkt_t *pkt, uint8_t v) ++void hdhomerun_write_u8(uint8_t **pptr, uint8_t v) + { +- *pkt->pos++ = v; ++ uint8_t *ptr = *pptr; ++ *ptr++ = v; ++ *pptr = ptr; ++} + +- if (pkt->pos > pkt->end) { +- pkt->end = pkt->pos; +- } ++void hdhomerun_write_u16(uint8_t **pptr, uint16_t v) ++{ ++ uint8_t *ptr = *pptr; ++ *ptr++ = (uint8_t)(v >> 8); ++ *ptr++ = (uint8_t)(v >> 0); ++ *pptr = ptr; + } + +-void hdhomerun_pkt_write_u16(struct hdhomerun_pkt_t *pkt, uint16_t v) ++void hdhomerun_write_u32(uint8_t **pptr, uint32_t v) + { +- *pkt->pos++ = (uint8_t)(v >> 8); +- *pkt->pos++ = (uint8_t)(v >> 0); ++ uint8_t *ptr = *pptr; ++ *ptr++ = (uint8_t)(v >> 24); ++ *ptr++ = (uint8_t)(v >> 16); ++ *ptr++ = (uint8_t)(v >> 8); ++ *ptr++ = (uint8_t)(v >> 0); ++ *pptr = ptr; ++} + +- if (pkt->pos > pkt->end) { +- pkt->end = pkt->pos; ++void hdhomerun_write_var_length(uint8_t **pptr, size_t v) ++{ ++ uint8_t *ptr = *pptr; ++ if (v <= 127) { ++ *ptr++ = (uint8_t)v; ++ } else { ++ *ptr++ = (uint8_t)(v | 0x80); ++ *ptr++ = (uint8_t)(v >> 7); + } ++ *pptr = ptr; + } + +-void hdhomerun_pkt_write_u32(struct hdhomerun_pkt_t *pkt, uint32_t v) ++static void hdhomerun_write_mem(uint8_t **pptr, void *mem, size_t length) + { +- *pkt->pos++ = (uint8_t)(v >> 24); +- *pkt->pos++ = (uint8_t)(v >> 16); +- *pkt->pos++ = (uint8_t)(v >> 8); +- *pkt->pos++ = (uint8_t)(v >> 0); ++ uint8_t *ptr = *pptr; ++ memcpy(ptr, mem, length); ++ ptr += length; ++ *pptr = ptr; ++} + +- if (pkt->pos > pkt->end) { +- pkt->end = pkt->pos; ++static uint32_t hdhomerun_calc_crc(uint8_t *start, uint8_t *end) ++{ ++ uint8_t *ptr = start; ++ uint32_t crc = 0xFFFFFFFF; ++ while (ptr < end) { ++ uint8_t x = (uint8_t)(crc) ^ *ptr++; ++ crc >>= 8; ++ if (x & 0x01) crc ^= 0x77073096; ++ if (x & 0x02) crc ^= 0xEE0E612C; ++ if (x & 0x04) crc ^= 0x076DC419; ++ if (x & 0x08) crc ^= 0x0EDB8832; ++ if (x & 0x10) crc ^= 0x1DB71064; ++ if (x & 0x20) crc ^= 0x3B6E20C8; ++ if (x & 0x40) crc ^= 0x76DC4190; ++ if (x & 0x80) crc ^= 0xEDB88320; + } ++ return crc ^ 0xFFFFFFFF; + } + +-void hdhomerun_pkt_write_var_length(struct hdhomerun_pkt_t *pkt, size_t v) ++static int hdhomerun_check_crc(uint8_t *start, uint8_t *end) + { +- if (v <= 127) { +- *pkt->pos++ = (uint8_t)v; +- } else { +- *pkt->pos++ = (uint8_t)(v | 0x80); +- *pkt->pos++ = (uint8_t)(v >> 7); ++ if (end - start < 8) { ++ return -1; + } +- +- if (pkt->pos > pkt->end) { +- pkt->end = pkt->pos; ++ uint8_t *ptr = end -= 4; ++ uint32_t actual_crc = hdhomerun_calc_crc(start, ptr); ++ uint32_t packet_crc; ++ packet_crc = (uint32_t)*ptr++ << 0; ++ packet_crc |= (uint32_t)*ptr++ << 8; ++ packet_crc |= (uint32_t)*ptr++ << 16; ++ packet_crc |= (uint32_t)*ptr++ << 24; ++ if (actual_crc != packet_crc) { ++ return -1; + } ++ return 0; + } + +-void hdhomerun_pkt_write_mem(struct hdhomerun_pkt_t *pkt, const void *mem, size_t length) ++static void hdhomerun_write_header_length(uint8_t *ptr, size_t length) + { +- memcpy(pkt->pos, mem, length); +- pkt->pos += length; ++ hdhomerun_write_u16(&ptr, (uint16_t)length); ++} + +- if (pkt->pos > pkt->end) { +- pkt->end = pkt->pos; +- } ++void hdhomerun_write_crc(uint8_t **pptr, uint8_t *start) ++{ ++ uint8_t *ptr = *pptr; ++ uint32_t crc = hdhomerun_calc_crc(start, ptr); ++ *ptr++ = (uint8_t)(crc >> 0); ++ *ptr++ = (uint8_t)(crc >> 8); ++ *ptr++ = (uint8_t)(crc >> 16); ++ *ptr++ = (uint8_t)(crc >> 24); ++ *pptr = ptr; + } + +-int hdhomerun_pkt_open_frame(struct hdhomerun_pkt_t *pkt, uint16_t *ptype) ++void hdhomerun_write_discover_request(uint8_t **pptr, uint32_t device_type, uint32_t device_id) + { +- pkt->pos = pkt->start; ++ uint8_t *start = *pptr; ++ hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_DISCOVER_REQ); ++ hdhomerun_write_u16(pptr, 0); + +- if (pkt->pos + 4 > pkt->end) { +- return 0; +- } ++ hdhomerun_write_u8(pptr, HDHOMERUN_TAG_DEVICE_TYPE); ++ hdhomerun_write_var_length(pptr, 4); ++ hdhomerun_write_u32(pptr, device_type); ++ hdhomerun_write_u8(pptr, HDHOMERUN_TAG_DEVICE_ID); ++ hdhomerun_write_var_length(pptr, 4); ++ hdhomerun_write_u32(pptr, device_id); + +- *ptype = hdhomerun_pkt_read_u16(pkt); +- size_t length = hdhomerun_pkt_read_u16(pkt); +- pkt->pos += length; ++ hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4)); ++ hdhomerun_write_crc(pptr, start); ++} + +- if (pkt->pos + 4 > pkt->end) { +- pkt->pos = pkt->start; +- return 0; +- } ++void hdhomerun_write_get_set_request(uint8_t **pptr, const char *name, const char *value) ++{ ++ uint8_t *start = *pptr; ++ hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_GETSET_REQ); ++ hdhomerun_write_u16(pptr, 0); + +- uint32_t calc_crc = hdhomerun_pkt_calc_crc(pkt->start, pkt->pos); ++ int name_len = (int)strlen(name) + 1; ++ hdhomerun_write_u8(pptr, HDHOMERUN_TAG_GETSET_NAME); ++ hdhomerun_write_var_length(pptr, name_len); ++ hdhomerun_write_mem(pptr, (void *)name, name_len); + +- uint32_t packet_crc; +- packet_crc = (uint32_t)*pkt->pos++ << 0; +- packet_crc |= (uint32_t)*pkt->pos++ << 8; +- packet_crc |= (uint32_t)*pkt->pos++ << 16; +- packet_crc |= (uint32_t)*pkt->pos++ << 24; +- if (calc_crc != packet_crc) { +- return -1; ++ if (value) { ++ int value_len = (int)strlen(value) + 1; ++ hdhomerun_write_u8(pptr, HDHOMERUN_TAG_GETSET_VALUE); ++ hdhomerun_write_var_length(pptr, value_len); ++ hdhomerun_write_mem(pptr, (void *)value, value_len); + } + +- pkt->start += 4; +- pkt->end = pkt->start + length; +- pkt->pos = pkt->start; +- return 1; ++ hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4)); ++ hdhomerun_write_crc(pptr, start); + } + +-void hdhomerun_pkt_seal_frame(struct hdhomerun_pkt_t *pkt, uint16_t frame_type) ++void hdhomerun_write_upgrade_request(uint8_t **pptr, uint32_t sequence, void *data, size_t length) + { +- size_t length = pkt->end - pkt->start; ++ uint8_t *start = *pptr; ++ hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_UPGRADE_REQ); ++ hdhomerun_write_u16(pptr, 0); + +- pkt->start -= 4; +- pkt->pos = pkt->start; +- hdhomerun_pkt_write_u16(pkt, frame_type); +- hdhomerun_pkt_write_u16(pkt, (uint16_t)length); ++ hdhomerun_write_u32(pptr, sequence); ++ if (length > 0) { ++ hdhomerun_write_mem(pptr, data, length); ++ } + +- uint32_t crc = hdhomerun_pkt_calc_crc(pkt->start, pkt->end); +- *pkt->end++ = (uint8_t)(crc >> 0); +- *pkt->end++ = (uint8_t)(crc >> 8); +- *pkt->end++ = (uint8_t)(crc >> 16); +- *pkt->end++ = (uint8_t)(crc >> 24); ++ hdhomerun_write_header_length(start + 2, *pptr - start - 4); ++ hdhomerun_write_crc(pptr, start); ++} + +- pkt->pos = pkt->start; ++size_t hdhomerun_peek_packet_length(uint8_t *ptr) ++{ ++ ptr += 2; ++ return (size_t)hdhomerun_read_u16(&ptr) + 8; + } ++ ++int hdhomerun_process_packet(uint8_t **pptr, uint8_t **pend) ++{ ++ if (hdhomerun_check_crc(*pptr, *pend) < 0) { ++ return -1; ++ } ++ *pend -= 4; ++ ++ uint16_t type = hdhomerun_read_u16(pptr); ++ uint16_t length = hdhomerun_read_u16(pptr); ++ if ((*pend - *pptr) < length) { ++ return -1; ++ } ++ *pend = *pptr + length; ++ return (int)type; ++} ++ +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_pkt.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_pkt.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_pkt.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_pkt.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_pkt.h + * +- * Copyright © 2005-2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2005-2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,20 +14,8 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + #ifdef __cplusplus + extern "C" { +@@ -122,9 +110,6 @@ + #define HDHOMERUN_DISCOVER_UDP_PORT 65001 + #define HDHOMERUN_CONTROL_TCP_PORT 65001 + +-#define HDHOMERUN_MAX_PACKET_SIZE 1460 +-#define HDHOMERUN_MAX_PAYLOAD_SIZE 1452 +- + #define HDHOMERUN_TYPE_DISCOVER_REQ 0x0002 + #define HDHOMERUN_TYPE_DISCOVER_RPY 0x0003 + #define HDHOMERUN_TYPE_GETSET_REQ 0x0004 +@@ -136,7 +121,6 @@ + #define HDHOMERUN_TAG_DEVICE_ID 0x02 + #define HDHOMERUN_TAG_GETSET_NAME 0x03 + #define HDHOMERUN_TAG_GETSET_VALUE 0x04 +-#define HDHOMERUN_TAG_GETSET_LOCKKEY 0x15 + #define HDHOMERUN_TAG_ERROR_MESSAGE 0x05 + + #define HDHOMERUN_DEVICE_TYPE_WILDCARD 0xFFFFFFFF +@@ -145,33 +129,25 @@ + + #define HDHOMERUN_MIN_PEEK_LENGTH 4 + +-struct hdhomerun_pkt_t { +- uint8_t *pos; +- uint8_t *start; +- uint8_t *end; +- uint8_t *limit; +- uint8_t buffer[3074]; +-}; +- +-extern LIBTYPE struct hdhomerun_pkt_t *hdhomerun_pkt_create(void); +-extern LIBTYPE void hdhomerun_pkt_destroy(struct hdhomerun_pkt_t *pkt); +-extern LIBTYPE void hdhomerun_pkt_reset(struct hdhomerun_pkt_t *pkt); +- +-extern LIBTYPE uint8_t hdhomerun_pkt_read_u8(struct hdhomerun_pkt_t *pkt); +-extern LIBTYPE uint16_t hdhomerun_pkt_read_u16(struct hdhomerun_pkt_t *pkt); +-extern LIBTYPE uint32_t hdhomerun_pkt_read_u32(struct hdhomerun_pkt_t *pkt); +-extern LIBTYPE size_t hdhomerun_pkt_read_var_length(struct hdhomerun_pkt_t *pkt); +-extern LIBTYPE uint8_t *hdhomerun_pkt_read_tlv(struct hdhomerun_pkt_t *pkt, uint8_t *ptag, size_t *plength); +- +-extern LIBTYPE void hdhomerun_pkt_write_u8(struct hdhomerun_pkt_t *pkt, uint8_t v); +-extern LIBTYPE void hdhomerun_pkt_write_u16(struct hdhomerun_pkt_t *pkt, uint16_t v); +-extern LIBTYPE void hdhomerun_pkt_write_u32(struct hdhomerun_pkt_t *pkt, uint32_t v); +-extern LIBTYPE void hdhomerun_pkt_write_var_length(struct hdhomerun_pkt_t *pkt, size_t v); +-extern LIBTYPE void hdhomerun_pkt_write_mem(struct hdhomerun_pkt_t *pkt, const void *mem, size_t length); +- +-extern LIBTYPE bool_t hdhomerun_pkt_open_frame(struct hdhomerun_pkt_t *pkt, uint16_t *ptype); +-extern LIBTYPE void hdhomerun_pkt_seal_frame(struct hdhomerun_pkt_t *pkt, uint16_t frame_type); ++extern uint8_t hdhomerun_read_u8(uint8_t **pptr); ++extern uint16_t hdhomerun_read_u16(uint8_t **pptr); ++extern uint32_t hdhomerun_read_u32(uint8_t **pptr); ++extern size_t hdhomerun_read_var_length(uint8_t **pptr, uint8_t *end); ++extern void hdhomerun_write_u8(uint8_t **pptr, uint8_t v); ++extern void hdhomerun_write_u16(uint8_t **pptr, uint16_t v); ++extern void hdhomerun_write_u32(uint8_t **pptr, uint32_t v); ++extern void hdhomerun_write_var_length(uint8_t **pptr, size_t v); ++extern void hdhomerun_write_crc(uint8_t **pptr, uint8_t *start); ++ ++extern size_t hdhomerun_peek_packet_length(uint8_t *ptr); ++extern int hdhomerun_process_packet(uint8_t **pptr, uint8_t **pend); ++extern int hdhomerun_read_tlv(uint8_t **pptr, uint8_t *end, uint8_t *ptag, size_t *plength, uint8_t **pvalue); ++ ++extern void hdhomerun_write_discover_request(uint8_t **pptr, uint32_t device_type, uint32_t device_id); ++extern void hdhomerun_write_get_set_request(uint8_t **pptr, const char *name, const char *value); ++extern void hdhomerun_write_upgrade_request(uint8_t **pptr, uint32_t sequence, void *data, size_t length); + + #ifdef __cplusplus + } + #endif ++ +Only in branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun: hdhomerun_types.h +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_video.c src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_video.c +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_video.c 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_video.c 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_video.c + * +- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,82 +14,93 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +-#include "hdhomerun.h" ++#include "hdhomerun_os.h" ++#include "hdhomerun_pkt.h" ++#include "hdhomerun_video.h" + + struct hdhomerun_video_sock_t { +- pthread_mutex_t lock; + uint8_t *buffer; + size_t buffer_size; + volatile size_t head; + volatile size_t tail; + size_t advance; ++ volatile bool_t running; + volatile bool_t terminate; + pthread_t thread; + int sock; +- uint32_t rtp_sequence; +- struct hdhomerun_debug_t *dbg; +- volatile uint32_t packet_count; +- volatile uint32_t transport_error_count; +- volatile uint32_t network_error_count; +- volatile uint32_t sequence_error_count; +- volatile uint32_t overflow_error_count; +- volatile uint8_t sequence[0x2000]; + }; + +-static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg); ++static void *hdhomerun_video_thread(void *arg); + +-struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, size_t buffer_size, struct hdhomerun_debug_t *dbg) ++static bool_t hdhomerun_video_bind_sock_internal(struct hdhomerun_video_sock_t *vs, uint16_t listen_port) ++{ ++ struct sockaddr_in sock_addr; ++ memset(&sock_addr, 0, sizeof(sock_addr)); ++ sock_addr.sin_family = AF_INET; ++ sock_addr.sin_addr.s_addr = htonl(INADDR_ANY); ++ sock_addr.sin_port = htons(listen_port); ++ if (bind(vs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { ++ return FALSE; ++ } ++ return TRUE; ++} ++ ++static bool_t hdhomerun_video_bind_sock(struct hdhomerun_video_sock_t *vs, uint16_t listen_port) ++{ ++ if (listen_port != 0) { ++ return hdhomerun_video_bind_sock_internal(vs, listen_port); ++ } ++ ++#if defined(__CYGWIN__) || defined(__WINDOWS__) ++ /* Windows firewall silently blocks a listening port if the port number is not explicitly given. */ ++ /* Workaround - pick a random port number. The port may already be in use to try multiple port numbers. */ ++ srand((int)getcurrenttime()); ++ int retry; ++ for (retry = 8; retry > 0; retry--) { ++ uint16_t listen_port = (uint16_t)((rand() % 32768) + 32768); ++ if (hdhomerun_video_bind_sock_internal(vs, listen_port)) { ++ return TRUE; ++ } ++ } ++ return FALSE; ++#else ++ return hdhomerun_video_bind_sock_internal(vs, listen_port); ++#endif ++} ++ ++struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, size_t buffer_size) + { + /* Create object. */ + struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)calloc(1, sizeof(struct hdhomerun_video_sock_t)); + if (!vs) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate video object\n"); + return NULL; + } + +- vs->dbg = dbg; +- vs->sock = -1; +- pthread_mutex_init(&vs->lock, NULL); +- +- /* Reset sequence tracking. */ +- hdhomerun_video_flush(vs); +- + /* Buffer size. */ + vs->buffer_size = (buffer_size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE; + if (vs->buffer_size == 0) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: invalid buffer size (%lu bytes)\n", (unsigned long)buffer_size); +- goto error; ++ free(vs); ++ return NULL; + } + vs->buffer_size += VIDEO_DATA_PACKET_SIZE; + + /* Create buffer. */ + vs->buffer = (uint8_t *)malloc(vs->buffer_size); + if (!vs->buffer) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate buffer (%lu bytes)\n", (unsigned long)vs->buffer_size); +- goto error; ++ free(vs); ++ return NULL; + } + + /* Create socket. */ + vs->sock = (int)socket(AF_INET, SOCK_DGRAM, 0); + if (vs->sock == -1) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate socket\n"); +- goto error; ++ free(vs->buffer); ++ free(vs); ++ return NULL; + } + + /* Expand socket buffer size. */ +@@ -101,44 +112,30 @@ + setsocktimeout(vs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000); + + /* Bind socket. */ +- struct sockaddr_in sock_addr; +- memset(&sock_addr, 0, sizeof(sock_addr)); +- sock_addr.sin_family = AF_INET; +- sock_addr.sin_addr.s_addr = htonl(INADDR_ANY); +- sock_addr.sin_port = htons(listen_port); +- if (bind(vs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to bind socket (port %u)\n", listen_port); +- goto error; ++ if (!hdhomerun_video_bind_sock(vs, listen_port)) { ++ hdhomerun_video_destroy(vs); ++ return NULL; + } + + /* Start thread. */ +- if (pthread_create(&vs->thread, NULL, &hdhomerun_video_thread_execute, vs) != 0) { +- hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to start thread\n"); +- goto error; ++ if (pthread_create(&vs->thread, NULL, &hdhomerun_video_thread, vs) != 0) { ++ hdhomerun_video_destroy(vs); ++ return NULL; + } ++ vs->running = 1; + + /* Success. */ + return vs; +- +-error: +- if (vs->sock != -1) { +- close(vs->sock); +- } +- if (vs->buffer) { +- free(vs->buffer); +- } +- free(vs); +- return NULL; + } + + void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs) + { +- vs->terminate = TRUE; +- pthread_join(vs->thread, NULL); +- ++ if (vs->running) { ++ vs->terminate = 1; ++ pthread_join(vs->thread, NULL); ++ } + close(vs->sock); + free(vs->buffer); +- + free(vs); + } + +@@ -147,85 +144,25 @@ + struct sockaddr_in sock_addr; + socklen_t sockaddr_size = sizeof(sock_addr); + if (getsockname(vs->sock, (struct sockaddr*)&sock_addr, &sockaddr_size) != 0) { +- hdhomerun_debug_printf(vs->dbg, "hdhomerun_video_get_local_port: getsockname failed (%d)\n", sock_getlasterror); + return 0; + } +- + return ntohs(sock_addr.sin_port); + } + +-static void hdhomerun_video_stats_ts_pkt(struct hdhomerun_video_sock_t *vs, uint8_t *ptr) +-{ +- uint16_t packet_identifier = ((uint16_t)(ptr[1] & 0x1F) << 8) | (uint16_t)ptr[2]; +- if (packet_identifier == 0x1FFF) { +- return; +- } +- +- bool_t transport_error = ptr[1] >> 7; +- if (transport_error) { +- vs->transport_error_count++; +- vs->sequence[packet_identifier] = 0xFF; +- return; +- } +- +- uint8_t continuity_counter = ptr[3] & 0x0F; +- uint8_t previous_sequence = vs->sequence[packet_identifier]; +- +- if (continuity_counter == ((previous_sequence + 1) & 0x0F)) { +- vs->sequence[packet_identifier] = continuity_counter; +- return; +- } +- if (previous_sequence == 0xFF) { +- vs->sequence[packet_identifier] = continuity_counter; +- return; +- } +- if (continuity_counter == previous_sequence) { +- return; +- } +- +- vs->sequence_error_count++; +- vs->sequence[packet_identifier] = continuity_counter; +-} +- +-static void hdhomerun_video_parse_rtp(struct hdhomerun_video_sock_t *vs, struct hdhomerun_pkt_t *pkt) ++int hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs) + { +- pkt->pos += 2; +- uint32_t rtp_sequence = hdhomerun_pkt_read_u16(pkt); +- pkt->pos += 8; +- +- if (rtp_sequence != ((vs->rtp_sequence + 1) & 0xFFFF)) { +- if (vs->rtp_sequence != 0xFFFFFFFF) { +- vs->network_error_count++; +- +- /* restart pid sequence check */ +- /* can't use memset bcs sequence is volatile */ +- int i; +- for (i = 0; i < sizeof(vs->sequence) / sizeof(uint8_t) ; i++) +- vs->sequence[i] = 0xFF; +- } +- } +- +- vs->rtp_sequence = rtp_sequence; ++ return vs->sock; + } + +-static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg) ++static void *hdhomerun_video_thread(void *arg) + { + struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)arg; +- struct hdhomerun_pkt_t pkt_inst; + + while (!vs->terminate) { +- struct hdhomerun_pkt_t *pkt = &pkt_inst; +- hdhomerun_pkt_reset(pkt); ++ size_t head = vs->head; + + /* Receive. */ +- int length = recv(vs->sock, (char *)pkt->end, VIDEO_RTP_DATA_PACKET_SIZE, 0); +- pkt->end += length; +- +- if (length == VIDEO_RTP_DATA_PACKET_SIZE) { +- hdhomerun_video_parse_rtp(vs, pkt); +- length = (int)(pkt->end - pkt->pos); +- } +- ++ int length = recv(vs->sock, (char *)vs->buffer + head, VIDEO_DATA_PACKET_SIZE, 0); + if (length != VIDEO_DATA_PACKET_SIZE) { + if (length > 0) { + /* Data received but not valid - ignore. */ +@@ -235,27 +172,10 @@ + /* Wait for more data. */ + continue; + } +- vs->terminate = TRUE; ++ vs->terminate = 1; + return NULL; + } + +- pthread_mutex_lock(&vs->lock); +- +- /* Store in ring buffer. */ +- size_t head = vs->head; +- uint8_t *ptr = vs->buffer + head; +- memcpy(ptr, pkt->pos, length); +- +- /* Stats. */ +- vs->packet_count++; +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 0); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 1); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 2); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 3); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 4); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 5); +- hdhomerun_video_stats_ts_pkt(vs, ptr + TS_PACKET_SIZE * 6); +- + /* Calculate new head. */ + head += length; + if (head >= vs->buffer_size) { +@@ -264,15 +184,11 @@ + + /* Check for buffer overflow. */ + if (head == vs->tail) { +- vs->overflow_error_count++; +- pthread_mutex_unlock(&vs->lock); + continue; + } + + /* Atomic update. */ + vs->head = head; +- +- pthread_mutex_unlock(&vs->lock); + } + + return NULL; +@@ -280,8 +196,6 @@ + + uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size) + { +- pthread_mutex_lock(&vs->lock); +- + size_t head = vs->head; + size_t tail = vs->tail; + +@@ -298,7 +212,6 @@ + if (head == tail) { + vs->advance = 0; + *pactual_size = 0; +- pthread_mutex_unlock(&vs->lock); + return NULL; + } + +@@ -306,7 +219,6 @@ + if (size == 0) { + vs->advance = 0; + *pactual_size = 0; +- pthread_mutex_unlock(&vs->lock); + return NULL; + } + +@@ -321,58 +233,13 @@ + } + vs->advance = size; + *pactual_size = size; +- uint8_t *result = vs->buffer + tail; +- +- pthread_mutex_unlock(&vs->lock); +- return result; ++ return vs->buffer + tail; + } + + void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs) + { +- pthread_mutex_lock(&vs->lock); +- ++ /* Atomic update of tail. */ + vs->tail = vs->head; + vs->advance = 0; +- +- /* can't use memset bcs sequence is volatile */ +- int i; +- for (i = 0; i < sizeof(vs->sequence) / sizeof(uint8_t) ; i++) +- vs->sequence[i] = 0xFF; +- +- vs->rtp_sequence = 0xFFFFFFFF; +- +- vs->packet_count = 0; +- vs->transport_error_count = 0; +- vs->network_error_count = 0; +- vs->sequence_error_count = 0; +- vs->overflow_error_count = 0; +- +- pthread_mutex_unlock(&vs->lock); + } + +-void hdhomerun_video_debug_print_stats(struct hdhomerun_video_sock_t *vs) +-{ +- struct hdhomerun_video_stats_t stats; +- hdhomerun_video_get_stats(vs, &stats); +- +- hdhomerun_debug_printf(vs->dbg, "video sock: pkt=%ld net=%ld te=%ld miss=%ld drop=%ld\n", +- stats.packet_count, stats.network_error_count, +- stats.transport_error_count, stats.sequence_error_count, +- stats.overflow_error_count +- ); +-} +- +-void hdhomerun_video_get_stats(struct hdhomerun_video_sock_t *vs, struct hdhomerun_video_stats_t *stats) +-{ +- memset(stats, 0, sizeof(struct hdhomerun_video_stats_t)); +- +- pthread_mutex_lock(&vs->lock); +- +- stats->packet_count = vs->packet_count; +- stats->network_error_count = vs->network_error_count; +- stats->transport_error_count = vs->transport_error_count; +- stats->sequence_error_count = vs->sequence_error_count; +- stats->overflow_error_count = vs->overflow_error_count; +- +- pthread_mutex_unlock(&vs->lock); +-} +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_video.h src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_video.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/hdhomerun_video.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/hdhomerun_video.h 2009-01-09 13:14:56.000000000 +1030 +@@ -1,12 +1,12 @@ + /* + * hdhomerun_video.h + * +- * Copyright © 2006 Silicondust USA Inc. <www.silicondust.com>. ++ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>. + * +- * This library is free software; you can redistribute it and/or ++ * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either +- * version 3 of the License, or (at your option) any later version. ++ * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of +@@ -14,20 +14,8 @@ + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public +- * License along with this library. If not, see <http://www.gnu.org/licenses/>. +- * +- * As a special exception to the GNU Lesser General Public License, +- * you may link, statically or dynamically, an application with a +- * publicly distributed version of the Library to produce an +- * executable file containing portions of the Library, and +- * distribute that executable file under terms of your choice, +- * without any of the additional requirements listed in clause 4 of +- * the GNU Lesser General Public License. +- * +- * By "a publicly distributed version of the Library", we mean +- * either the unmodified Library as distributed by Silicondust, or a +- * modified version of the Library that is distributed under the +- * conditions defined in the GNU Lesser General Public License. ++ * License along with this library; if not, write to the Free Software ++ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + #ifdef __cplusplus + extern "C" { +@@ -35,40 +23,34 @@ + + struct hdhomerun_video_sock_t; + +-struct hdhomerun_video_stats_t { +- uint32_t packet_count; +- uint32_t network_error_count; +- uint32_t transport_error_count; +- uint32_t sequence_error_count; +- uint32_t overflow_error_count; +-}; +- + #define TS_PACKET_SIZE 188 + #define VIDEO_DATA_PACKET_SIZE (188 * 7) + #define VIDEO_DATA_BUFFER_SIZE_1S (20000000 / 8) + +-#define VIDEO_RTP_DATA_PACKET_SIZE ((188 * 7) + 12) +- + /* + * Create a video/data socket. + * + * uint16_t listen_port: Port number to listen on. Set to 0 to auto-select. + * size_t buffer_size: Size of receive buffer. For 1 second of buffer use VIDEO_DATA_BUFFER_SIZE_1S. +- * struct hdhomerun_debug_t *dbg: Pointer to debug logging object. May be NULL. + * + * Returns a pointer to the newly created control socket. + * + * When no longer needed, the socket should be destroyed by calling hdhomerun_control_destroy. + */ +-extern LIBTYPE struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, size_t buffer_size, struct hdhomerun_debug_t *dbg); +-extern LIBTYPE void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs); ++extern struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, size_t buffer_size); ++extern void hdhomerun_video_destroy(struct hdhomerun_video_sock_t *vs); + + /* + * Get the port the socket is listening on. + * + * Returns 16-bit port with native endianness, or 0 on error. + */ +-extern LIBTYPE uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs); ++extern uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs); ++ ++/* ++ * Get the low-level socket handle. ++ */ ++extern int hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs); + + /* + * Read data from buffer. +@@ -87,18 +69,12 @@ + * The buffer is implemented as a ring buffer. It is possible for this function to return a small + * amount of data when more is available due to the wrap-around case. + */ +-extern LIBTYPE uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size); ++extern uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size); + + /* + * Flush the buffer. + */ +-extern LIBTYPE void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs); +- +-/* +- * Debug print internal stats. +- */ +-extern LIBTYPE void hdhomerun_video_debug_print_stats(struct hdhomerun_video_sock_t *vs); +-extern LIBTYPE void hdhomerun_video_get_stats(struct hdhomerun_video_sock_t *vs, struct hdhomerun_video_stats_t *stats); ++extern void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs); + + #ifdef __cplusplus + } +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/lgpl.txt src/mythtv-0.21/libs/libmythtv/hdhomerun/lgpl.txt +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhomerun/lgpl.txt 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhomerun/lgpl.txt 2009-01-09 13:14:56.000000000 +1030 +@@ -1,165 +1,504 @@ +- GNU LESSER GENERAL PUBLIC LICENSE +- Version 3, 29 June 2007 ++ GNU LESSER GENERAL PUBLIC LICENSE ++ Version 2.1, February 1999 + +- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/> ++ Copyright (C) 1991, 1999 Free Software Foundation, Inc. ++ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +- +- This version of the GNU Lesser General Public License incorporates +-the terms and conditions of version 3 of the GNU General Public +-License, supplemented by the additional permissions listed below. +- +- 0. Additional Definitions. +- +- As used herein, "this License" refers to version 3 of the GNU Lesser +-General Public License, and the "GNU GPL" refers to version 3 of the GNU +-General Public License. +- +- "The Library" refers to a covered work governed by this License, +-other than an Application or a Combined Work as defined below. +- +- An "Application" is any work that makes use of an interface provided +-by the Library, but which is not otherwise based on the Library. +-Defining a subclass of a class defined by the Library is deemed a mode +-of using an interface provided by the Library. +- +- A "Combined Work" is a work produced by combining or linking an +-Application with the Library. The particular version of the Library +-with which the Combined Work was made is also called the "Linked +-Version". +- +- The "Minimal Corresponding Source" for a Combined Work means the +-Corresponding Source for the Combined Work, excluding any source code +-for portions of the Combined Work that, considered in isolation, are +-based on the Application, and not on the Linked Version. +- +- The "Corresponding Application Code" for a Combined Work means the +-object code and/or source code for the Application, including any data +-and utility programs needed for reproducing the Combined Work from the +-Application, but excluding the System Libraries of the Combined Work. +- +- 1. Exception to Section 3 of the GNU GPL. +- +- You may convey a covered work under sections 3 and 4 of this License +-without being bound by section 3 of the GNU GPL. +- +- 2. Conveying Modified Versions. +- +- If you modify a copy of the Library, and, in your modifications, a +-facility refers to a function or data to be supplied by an Application +-that uses the facility (other than as an argument passed when the +-facility is invoked), then you may convey a copy of the modified +-version: +- +- a) under this License, provided that you make a good faith effort to +- ensure that, in the event an Application does not supply the +- function or data, the facility still operates, and performs +- whatever part of its purpose remains meaningful, or +- +- b) under the GNU GPL, with none of the additional permissions of +- this License applicable to that copy. +- +- 3. Object Code Incorporating Material from Library Header Files. +- +- The object code form of an Application may incorporate material from +-a header file that is part of the Library. You may convey such object +-code under terms of your choice, provided that, if the incorporated +-material is not limited to numerical parameters, data structure +-layouts and accessors, or small macros, inline functions and templates +-(ten or fewer lines in length), you do both of the following: +- +- a) Give prominent notice with each copy of the object code that the +- Library is used in it and that the Library and its use are +- covered by this License. +- +- b) Accompany the object code with a copy of the GNU GPL and this license +- document. +- +- 4. Combined Works. +- +- You may convey a Combined Work under terms of your choice that, +-taken together, effectively do not restrict modification of the +-portions of the Library contained in the Combined Work and reverse +-engineering for debugging such modifications, if you also do each of +-the following: +- +- a) Give prominent notice with each copy of the Combined Work that +- the Library is used in it and that the Library and its use are +- covered by this License. +- +- b) Accompany the Combined Work with a copy of the GNU GPL and this license +- document. +- +- c) For a Combined Work that displays copyright notices during +- execution, include the copyright notice for the Library among +- these notices, as well as a reference directing the user to the +- copies of the GNU GPL and this license document. +- +- d) Do one of the following: +- +- 0) Convey the Minimal Corresponding Source under the terms of this +- License, and the Corresponding Application Code in a form +- suitable for, and under terms that permit, the user to +- recombine or relink the Application with a modified version of +- the Linked Version to produce a modified Combined Work, in the +- manner specified by section 6 of the GNU GPL for conveying +- Corresponding Source. +- +- 1) Use a suitable shared library mechanism for linking with the +- Library. A suitable mechanism is one that (a) uses at run time +- a copy of the Library already present on the user's computer +- system, and (b) will operate properly with a modified version +- of the Library that is interface-compatible with the Linked +- Version. +- +- e) Provide Installation Information, but only if you would otherwise +- be required to provide such information under section 6 of the +- GNU GPL, and only to the extent that such information is +- necessary to install and execute a modified version of the +- Combined Work produced by recombining or relinking the +- Application with a modified version of the Linked Version. (If +- you use option 4d0, the Installation Information must accompany +- the Minimal Corresponding Source and Corresponding Application +- Code. If you use option 4d1, you must provide the Installation +- Information in the manner specified by section 6 of the GNU GPL +- for conveying Corresponding Source.) +- +- 5. Combined Libraries. +- +- You may place library facilities that are a work based on the +-Library side by side in a single library together with other library +-facilities that are not Applications and are not covered by this +-License, and convey such a combined library under terms of your +-choice, if you do both of the following: +- +- a) Accompany the combined library with a copy of the same work based +- on the Library, uncombined with any other library facilities, +- conveyed under the terms of this License. +- +- b) Give prominent notice with the combined library that part of it +- is a work based on the Library, and explaining where to find the +- accompanying uncombined form of the same work. +- +- 6. Revised Versions of the GNU Lesser General Public License. +- +- The Free Software Foundation may publish revised and/or new versions +-of the GNU Lesser General Public License from time to time. Such new +-versions will be similar in spirit to the present version, but may +-differ in detail to address new problems or concerns. +- +- Each version is given a distinguishing version number. If the +-Library as you received it specifies that a certain numbered version +-of the GNU Lesser General Public License "or any later version" +-applies to it, you have the option of following the terms and +-conditions either of that published version or of any later version +-published by the Free Software Foundation. If the Library as you +-received it does not specify a version number of the GNU Lesser +-General Public License, you may choose any version of the GNU Lesser +-General Public License ever published by the Free Software Foundation. +- +- If the Library as you received it specifies that a proxy can decide +-whether future versions of the GNU Lesser General Public License shall +-apply, that proxy's public statement of acceptance of any version is +-permanent authorization for you to choose that version for the ++[This is the first released version of the Lesser GPL. It also counts ++ as the successor of the GNU Library Public License, version 2, hence ++ the version number 2.1.] ++ ++ Preamble ++ ++ The licenses for most software are designed to take away your ++freedom to share and change it. By contrast, the GNU General Public ++Licenses are intended to guarantee your freedom to share and change ++free software--to make sure the software is free for all its users. ++ ++ This license, the Lesser General Public License, applies to some ++specially designated software packages--typically libraries--of the ++Free Software Foundation and other authors who decide to use it. You ++can use it too, but we suggest you first think carefully about whether ++this license or the ordinary General Public License is the better ++strategy to use in any particular case, based on the explanations below. ++ ++ When we speak of free software, we are referring to freedom of use, ++not price. Our General Public Licenses are designed to make sure that ++you have the freedom to distribute copies of free software (and charge ++for this service if you wish); that you receive source code or can get ++it if you want it; that you can change the software and use pieces of ++it in new free programs; and that you are informed that you can do ++these things. ++ ++ To protect your rights, we need to make restrictions that forbid ++distributors to deny you these rights or to ask you to surrender these ++rights. These restrictions translate to certain responsibilities for ++you if you distribute copies of the library or if you modify it. ++ ++ For example, if you distribute copies of the library, whether gratis ++or for a fee, you must give the recipients all the rights that we gave ++you. You must make sure that they, too, receive or can get the source ++code. If you link other code with the library, you must provide ++complete object files to the recipients, so that they can relink them ++with the library after making changes to the library and recompiling ++it. And you must show them these terms so they know their rights. ++ ++ We protect your rights with a two-step method: (1) we copyright the ++library, and (2) we offer you this license, which gives you legal ++permission to copy, distribute and/or modify the library. ++ ++ To protect each distributor, we want to make it very clear that ++there is no warranty for the free library. Also, if the library is ++modified by someone else and passed on, the recipients should know ++that what they have is not the original version, so that the original ++author's reputation will not be affected by problems that might be ++introduced by others. ++ ++ Finally, software patents pose a constant threat to the existence of ++any free program. We wish to make sure that a company cannot ++effectively restrict the users of a free program by obtaining a ++restrictive license from a patent holder. Therefore, we insist that ++any patent license obtained for a version of the library must be ++consistent with the full freedom of use specified in this license. ++ ++ Most GNU software, including some libraries, is covered by the ++ordinary GNU General Public License. This license, the GNU Lesser ++General Public License, applies to certain designated libraries, and ++is quite different from the ordinary General Public License. We use ++this license for certain libraries in order to permit linking those ++libraries into non-free programs. ++ ++ When a program is linked with a library, whether statically or using ++a shared library, the combination of the two is legally speaking a ++combined work, a derivative of the original library. The ordinary ++General Public License therefore permits such linking only if the ++entire combination fits its criteria of freedom. The Lesser General ++Public License permits more lax criteria for linking other code with ++the library. ++ ++ We call this license the "Lesser" General Public License because it ++does Less to protect the user's freedom than the ordinary General ++Public License. It also provides other free software developers Less ++of an advantage over competing non-free programs. These disadvantages ++are the reason we use the ordinary General Public License for many ++libraries. However, the Lesser license provides advantages in certain ++special circumstances. ++ ++ For example, on rare occasions, there may be a special need to ++encourage the widest possible use of a certain library, so that it becomes ++a de-facto standard. To achieve this, non-free programs must be ++allowed to use the library. A more frequent case is that a free ++library does the same job as widely used non-free libraries. In this ++case, there is little to gain by limiting the free library to free ++software only, so we use the Lesser General Public License. ++ ++ In other cases, permission to use a particular library in non-free ++programs enables a greater number of people to use a large body of ++free software. For example, permission to use the GNU C Library in ++non-free programs enables many more people to use the whole GNU ++operating system, as well as its variant, the GNU/Linux operating ++system. ++ ++ Although the Lesser General Public License is Less protective of the ++users' freedom, it does ensure that the user of a program that is ++linked with the Library has the freedom and the wherewithal to run ++that program using a modified version of the Library. ++ ++ The precise terms and conditions for copying, distribution and ++modification follow. Pay close attention to the difference between a ++"work based on the library" and a "work that uses the library". The ++former contains code derived from the library, whereas the latter must ++be combined with the library in order to run. ++ ++ GNU LESSER GENERAL PUBLIC LICENSE ++ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION ++ ++ 0. This License Agreement applies to any software library or other ++program which contains a notice placed by the copyright holder or ++other authorized party saying it may be distributed under the terms of ++this Lesser General Public License (also called "this License"). ++Each licensee is addressed as "you". ++ ++ A "library" means a collection of software functions and/or data ++prepared so as to be conveniently linked with application programs ++(which use some of those functions and data) to form executables. ++ ++ The "Library", below, refers to any such software library or work ++which has been distributed under these terms. A "work based on the ++Library" means either the Library or any derivative work under ++copyright law: that is to say, a work containing the Library or a ++portion of it, either verbatim or with modifications and/or translated ++straightforwardly into another language. (Hereinafter, translation is ++included without limitation in the term "modification".) ++ ++ "Source code" for a work means the preferred form of the work for ++making modifications to it. For a library, complete source code means ++all the source code for all modules it contains, plus any associated ++interface definition files, plus the scripts used to control compilation ++and installation of the library. ++ ++ Activities other than copying, distribution and modification are not ++covered by this License; they are outside its scope. The act of ++running a program using the Library is not restricted, and output from ++such a program is covered only if its contents constitute a work based ++on the Library (independent of the use of the Library in a tool for ++writing it). Whether that is true depends on what the Library does ++and what the program that uses the Library does. ++ ++ 1. You may copy and distribute verbatim copies of the Library's ++complete source code as you receive it, in any medium, provided that ++you conspicuously and appropriately publish on each copy an ++appropriate copyright notice and disclaimer of warranty; keep intact ++all the notices that refer to this License and to the absence of any ++warranty; and distribute a copy of this License along with the + Library. ++ ++ You may charge a fee for the physical act of transferring a copy, ++and you may at your option offer warranty protection in exchange for a ++fee. ++ ++ 2. You may modify your copy or copies of the Library or any portion ++of it, thus forming a work based on the Library, and copy and ++distribute such modifications or work under the terms of Section 1 ++above, provided that you also meet all of these conditions: ++ ++ a) The modified work must itself be a software library. ++ ++ b) You must cause the files modified to carry prominent notices ++ stating that you changed the files and the date of any change. ++ ++ c) You must cause the whole of the work to be licensed at no ++ charge to all third parties under the terms of this License. ++ ++ d) If a facility in the modified Library refers to a function or a ++ table of data to be supplied by an application program that uses ++ the facility, other than as an argument passed when the facility ++ is invoked, then you must make a good faith effort to ensure that, ++ in the event an application does not supply such function or ++ table, the facility still operates, and performs whatever part of ++ its purpose remains meaningful. ++ ++ (For example, a function in a library to compute square roots has ++ a purpose that is entirely well-defined independent of the ++ application. Therefore, Subsection 2d requires that any ++ application-supplied function or table used by this function must ++ be optional: if the application does not supply it, the square ++ root function must still compute square roots.) ++ ++These requirements apply to the modified work as a whole. If ++identifiable sections of that work are not derived from the Library, ++and can be reasonably considered independent and separate works in ++themselves, then this License, and its terms, do not apply to those ++sections when you distribute them as separate works. But when you ++distribute the same sections as part of a whole which is a work based ++on the Library, the distribution of the whole must be on the terms of ++this License, whose permissions for other licensees extend to the ++entire whole, and thus to each and every part regardless of who wrote ++it. ++ ++Thus, it is not the intent of this section to claim rights or contest ++your rights to work written entirely by you; rather, the intent is to ++exercise the right to control the distribution of derivative or ++collective works based on the Library. ++ ++In addition, mere aggregation of another work not based on the Library ++with the Library (or with a work based on the Library) on a volume of ++a storage or distribution medium does not bring the other work under ++the scope of this License. ++ ++ 3. You may opt to apply the terms of the ordinary GNU General Public ++License instead of this License to a given copy of the Library. To do ++this, you must alter all the notices that refer to this License, so ++that they refer to the ordinary GNU General Public License, version 2, ++instead of to this License. (If a newer version than version 2 of the ++ordinary GNU General Public License has appeared, then you can specify ++that version instead if you wish.) Do not make any other change in ++these notices. ++ ++ Once this change is made in a given copy, it is irreversible for ++that copy, so the ordinary GNU General Public License applies to all ++subsequent copies and derivative works made from that copy. ++ ++ This option is useful when you wish to copy part of the code of ++the Library into a program that is not a library. ++ ++ 4. You may copy and distribute the Library (or a portion or ++derivative of it, under Section 2) in object code or executable form ++under the terms of Sections 1 and 2 above provided that you accompany ++it with the complete corresponding machine-readable source code, which ++must be distributed under the terms of Sections 1 and 2 above on a ++medium customarily used for software interchange. ++ ++ If distribution of object code is made by offering access to copy ++from a designated place, then offering equivalent access to copy the ++source code from the same place satisfies the requirement to ++distribute the source code, even though third parties are not ++compelled to copy the source along with the object code. ++ ++ 5. A program that contains no derivative of any portion of the ++Library, but is designed to work with the Library by being compiled or ++linked with it, is called a "work that uses the Library". Such a ++work, in isolation, is not a derivative work of the Library, and ++therefore falls outside the scope of this License. ++ ++ However, linking a "work that uses the Library" with the Library ++creates an executable that is a derivative of the Library (because it ++contains portions of the Library), rather than a "work that uses the ++library". The executable is therefore covered by this License. ++Section 6 states terms for distribution of such executables. ++ ++ When a "work that uses the Library" uses material from a header file ++that is part of the Library, the object code for the work may be a ++derivative work of the Library even though the source code is not. ++Whether this is true is especially significant if the work can be ++linked without the Library, or if the work is itself a library. The ++threshold for this to be true is not precisely defined by law. ++ ++ If such an object file uses only numerical parameters, data ++structure layouts and accessors, and small macros and small inline ++functions (ten lines or less in length), then the use of the object ++file is unrestricted, regardless of whether it is legally a derivative ++work. (Executables containing this object code plus portions of the ++Library will still fall under Section 6.) ++ ++ Otherwise, if the work is a derivative of the Library, you may ++distribute the object code for the work under the terms of Section 6. ++Any executables containing that work also fall under Section 6, ++whether or not they are linked directly with the Library itself. ++ ++ 6. As an exception to the Sections above, you may also combine or ++link a "work that uses the Library" with the Library to produce a ++work containing portions of the Library, and distribute that work ++under terms of your choice, provided that the terms permit ++modification of the work for the customer's own use and reverse ++engineering for debugging such modifications. ++ ++ You must give prominent notice with each copy of the work that the ++Library is used in it and that the Library and its use are covered by ++this License. You must supply a copy of this License. If the work ++during execution displays copyright notices, you must include the ++copyright notice for the Library among them, as well as a reference ++directing the user to the copy of this License. Also, you must do one ++of these things: ++ ++ a) Accompany the work with the complete corresponding ++ machine-readable source code for the Library including whatever ++ changes were used in the work (which must be distributed under ++ Sections 1 and 2 above); and, if the work is an executable linked ++ with the Library, with the complete machine-readable "work that ++ uses the Library", as object code and/or source code, so that the ++ user can modify the Library and then relink to produce a modified ++ executable containing the modified Library. (It is understood ++ that the user who changes the contents of definitions files in the ++ Library will not necessarily be able to recompile the application ++ to use the modified definitions.) ++ ++ b) Use a suitable shared library mechanism for linking with the ++ Library. A suitable mechanism is one that (1) uses at run time a ++ copy of the library already present on the user's computer system, ++ rather than copying library functions into the executable, and (2) ++ will operate properly with a modified version of the library, if ++ the user installs one, as long as the modified version is ++ interface-compatible with the version that the work was made with. ++ ++ c) Accompany the work with a written offer, valid for at ++ least three years, to give the same user the materials ++ specified in Subsection 6a, above, for a charge no more ++ than the cost of performing this distribution. ++ ++ d) If distribution of the work is made by offering access to copy ++ from a designated place, offer equivalent access to copy the above ++ specified materials from the same place. ++ ++ e) Verify that the user has already received a copy of these ++ materials or that you have already sent this user a copy. ++ ++ For an executable, the required form of the "work that uses the ++Library" must include any data and utility programs needed for ++reproducing the executable from it. However, as a special exception, ++the materials to be distributed need not include anything that is ++normally distributed (in either source or binary form) with the major ++components (compiler, kernel, and so on) of the operating system on ++which the executable runs, unless that component itself accompanies ++the executable. ++ ++ It may happen that this requirement contradicts the license ++restrictions of other proprietary libraries that do not normally ++accompany the operating system. Such a contradiction means you cannot ++use both them and the Library together in an executable that you ++distribute. ++ ++ 7. You may place library facilities that are a work based on the ++Library side-by-side in a single library together with other library ++facilities not covered by this License, and distribute such a combined ++library, provided that the separate distribution of the work based on ++the Library and of the other library facilities is otherwise ++permitted, and provided that you do these two things: ++ ++ a) Accompany the combined library with a copy of the same work ++ based on the Library, uncombined with any other library ++ facilities. This must be distributed under the terms of the ++ Sections above. ++ ++ b) Give prominent notice with the combined library of the fact ++ that part of it is a work based on the Library, and explaining ++ where to find the accompanying uncombined form of the same work. ++ ++ 8. You may not copy, modify, sublicense, link with, or distribute ++the Library except as expressly provided under this License. Any ++attempt otherwise to copy, modify, sublicense, link with, or ++distribute the Library is void, and will automatically terminate your ++rights under this License. However, parties who have received copies, ++or rights, from you under this License will not have their licenses ++terminated so long as such parties remain in full compliance. ++ ++ 9. You are not required to accept this License, since you have not ++signed it. However, nothing else grants you permission to modify or ++distribute the Library or its derivative works. These actions are ++prohibited by law if you do not accept this License. Therefore, by ++modifying or distributing the Library (or any work based on the ++Library), you indicate your acceptance of this License to do so, and ++all its terms and conditions for copying, distributing or modifying ++the Library or works based on it. ++ ++ 10. Each time you redistribute the Library (or any work based on the ++Library), the recipient automatically receives a license from the ++original licensor to copy, distribute, link with or modify the Library ++subject to these terms and conditions. You may not impose any further ++restrictions on the recipients' exercise of the rights granted herein. ++You are not responsible for enforcing compliance by third parties with ++this License. ++ ++ 11. If, as a consequence of a court judgment or allegation of patent ++infringement or for any other reason (not limited to patent issues), ++conditions are imposed on you (whether by court order, agreement or ++otherwise) that contradict the conditions of this License, they do not ++excuse you from the conditions of this License. If you cannot ++distribute so as to satisfy simultaneously your obligations under this ++License and any other pertinent obligations, then as a consequence you ++may not distribute the Library at all. For example, if a patent ++license would not permit royalty-free redistribution of the Library by ++all those who receive copies directly or indirectly through you, then ++the only way you could satisfy both it and this License would be to ++refrain entirely from distribution of the Library. ++ ++If any portion of this section is held invalid or unenforceable under any ++particular circumstance, the balance of the section is intended to apply, ++and the section as a whole is intended to apply in other circumstances. ++ ++It is not the purpose of this section to induce you to infringe any ++patents or other property right claims or to contest validity of any ++such claims; this section has the sole purpose of protecting the ++integrity of the free software distribution system which is ++implemented by public license practices. Many people have made ++generous contributions to the wide range of software distributed ++through that system in reliance on consistent application of that ++system; it is up to the author/donor to decide if he or she is willing ++to distribute software through any other system and a licensee cannot ++impose that choice. ++ ++This section is intended to make thoroughly clear what is believed to ++be a consequence of the rest of this License. ++ ++ 12. If the distribution and/or use of the Library is restricted in ++certain countries either by patents or by copyrighted interfaces, the ++original copyright holder who places the Library under this License may add ++an explicit geographical distribution limitation excluding those countries, ++so that distribution is permitted only in or among countries not thus ++excluded. In such case, this License incorporates the limitation as if ++written in the body of this License. ++ ++ 13. The Free Software Foundation may publish revised and/or new ++versions of the Lesser General Public License from time to time. ++Such new versions will be similar in spirit to the present version, ++but may differ in detail to address new problems or concerns. ++ ++Each version is given a distinguishing version number. If the Library ++specifies a version number of this License which applies to it and ++"any later version", you have the option of following the terms and ++conditions either of that version or of any later version published by ++the Free Software Foundation. If the Library does not specify a ++license version number, you may choose any version ever published by ++the Free Software Foundation. ++ ++ 14. If you wish to incorporate parts of the Library into other free ++programs whose distribution conditions are incompatible with these, ++write to the author to ask for permission. For software which is ++copyrighted by the Free Software Foundation, write to the Free ++Software Foundation; we sometimes make exceptions for this. Our ++decision will be guided by the two goals of preserving the free status ++of all derivatives of our free software and of promoting the sharing ++and reuse of software generally. ++ ++ NO WARRANTY ++ ++ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO ++WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. ++EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR ++OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY ++KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE ++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR ++PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE ++LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME ++THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. ++ ++ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN ++WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY ++AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU ++FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR ++CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE ++LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING ++RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A ++FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF ++SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH ++DAMAGES. ++ ++ END OF TERMS AND CONDITIONS ++ ++ How to Apply These Terms to Your New Libraries ++ ++ If you develop a new library, and you want it to be of the greatest ++possible use to the public, we recommend making it free software that ++everyone can redistribute and change. You can do so by permitting ++redistribution under these terms (or, alternatively, under the terms of the ++ordinary General Public License). ++ ++ To apply these terms, attach the following notices to the library. It is ++safest to attach them to the start of each source file to most effectively ++convey the exclusion of warranty; and each file should have at least the ++"copyright" line and a pointer to where the full notice is found. ++ ++ <one line to give the library's name and a brief idea of what it does.> ++ Copyright (C) <year> <name of author> ++ ++ This library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ This library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with this library; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA ++ ++Also add information on how to contact you by electronic and paper mail. ++ ++You should also get your employer (if you work as a programmer) or your ++school, if any, to sign a "copyright disclaimer" for the library, if ++necessary. Here is a sample; alter the names: ++ ++ Yoyodyne, Inc., hereby disclaims all copyright interest in the ++ library `Frob' (a library for tweaking knobs) written by James Random Hacker. ++ ++ <signature of Ty Coon>, 1 April 1990 ++ Ty Coon, President of Vice ++ ++That's all there is to it! ++ ++ +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrchannel.cpp src/mythtv-0.21/libs/libmythtv/hdhrchannel.cpp +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrchannel.cpp 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhrchannel.cpp 2009-01-09 13:14:58.000000000 +1030 +@@ -1,6 +1,6 @@ + /** +- * HDHRChannel +- * Copyright (c) 2006-2009 by Silicondust Engineering Ltd. ++ * DBox2Channel ++ * Copyright (c) 2006 by Silicondust Engineering Ltd. + * Distributed as part of MythTV under GPL v2 and later. + */ + +@@ -24,6 +24,7 @@ + #include "hdhrchannel.h" + #include "videosource.h" + #include "channelutil.h" ++#include "frequencytables.h" + + #define DEBUG_PID_FILTERS + +@@ -31,7 +32,7 @@ + #define LOC_ERR QString("HDHRChan(%1), Error: ").arg(GetDevice()) + + HDHRChannel::HDHRChannel(TVRec *parent, const QString &device, uint tuner) +- : DTVChannel(parent), _hdhomerun_device(NULL), ++ : DTVChannel(parent), _control_socket(NULL), + _device_id(0), _device_ip(0), + _tuner(tuner), _lock(true) + { +@@ -41,8 +42,6 @@ + if (valid && hdhomerun_discover_validate_device_id(_device_id)) + return; + +- _device_id = HDHOMERUN_DEVICE_ID_WILDCARD; +- + /* Otherwise, is it a valid IP address? */ + struct in_addr address; + if (inet_aton(device, &address)) +@@ -55,6 +54,7 @@ + VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Invalid DeviceID '%1'") + .arg(device)); + ++ _device_id = HDHOMERUN_DEVICE_ID_WILDCARD; + } + + HDHRChannel::~HDHRChannel(void) +@@ -67,38 +67,77 @@ + if (IsOpen()) + return true; + ++ if (!FindDevice()) ++ return false; ++ + if (!InitializeInputs()) + return false; + +- return Connect(); ++ return (_device_ip != 0) && Connect(); + } + + void HDHRChannel::Close(void) + { +- if (_hdhomerun_device) ++ if (_control_socket) + { +- hdhomerun_device_destroy(_hdhomerun_device); +- _hdhomerun_device = NULL; ++ hdhomerun_control_destroy(_control_socket); ++ _control_socket = NULL; + } + } + + bool HDHRChannel::EnterPowerSavingMode(void) + { +- return hdhomerun_device_set_tuner_channel(_hdhomerun_device, "none") > 0; ++ return QString::null != TunerSet("channel", "none", false); ++} ++ ++bool HDHRChannel::FindDevice(void) ++{ ++ if (!_device_id) ++ return _device_ip; ++ ++ _device_ip = 0; ++ ++ /* Discover. */ ++ struct hdhomerun_discover_device_t result; ++ int ret = hdhomerun_discover_find_device(_device_id, &result); ++ if (ret < 0) ++ { ++ VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to send discovery request" + ENO); ++ return false; ++ } ++ if (ret == 0) ++ { ++ VERBOSE(VB_IMPORTANT, LOC_ERR + QString("device not found")); ++ return false; ++ } ++ ++ /* Found. */ ++ _device_ip = result.ip_addr; ++ ++ VERBOSE(VB_IMPORTANT, LOC + ++ QString("device found at address %1.%2.%3.%4") ++ .arg((_device_ip>>24) & 0xFF).arg((_device_ip>>16) & 0xFF) ++ .arg((_device_ip>> 8) & 0xFF).arg((_device_ip>> 0) & 0xFF)); ++ ++ return true; + } + + bool HDHRChannel::Connect(void) + { +- _hdhomerun_device = hdhomerun_device_create( +- _device_id, _device_ip, _tuner, NULL); ++ _control_socket = hdhomerun_control_create(_device_id, _device_ip); ++ if (!_control_socket) ++ { ++ VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to create control socket"); ++ return false; ++ } + +- if (!_hdhomerun_device) ++ if (hdhomerun_control_get_local_addr(_control_socket) == 0) + { +- VERBOSE(VB_IMPORTANT, +- LOC_ERR + "Unable to create hdhomerun device object"); ++ VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to connect to device"); + return false; + } + ++ VERBOSE(VB_CHANNEL, LOC + "Successfully connected to device"); + return true; + } + +@@ -106,7 +145,7 @@ + { + QMutexLocker locker(&_lock); + +- if (!_hdhomerun_device) ++ if (!_control_socket) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + "Get request failed (not connected)"); + return QString::null; +@@ -114,7 +153,7 @@ + + char *value = NULL; + char *error = NULL; +- if (hdhomerun_device_get_var(_hdhomerun_device, name, &value, &error) < 0) ++ if (hdhomerun_control_get(_control_socket, name, &value, &error) < 0) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + "Get request failed" + ENO); + return QString::null; +@@ -136,7 +175,7 @@ + { + QMutexLocker locker(&_lock); + +- if (!_hdhomerun_device) ++ if (!_control_socket) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + "Set request failed (not connected)"); + return QString::null; +@@ -144,8 +183,7 @@ + + char *value = NULL; + char *error = NULL; +- if (hdhomerun_device_set_var( +- _hdhomerun_device, name, val, &value, &error) < 0) ++ if (hdhomerun_control_set(_control_socket, name, val, &value, &error) < 0) + { + VERBOSE(VB_IMPORTANT, LOC_ERR + "Set request failed" + ENO); + +@@ -163,11 +201,6 @@ + return QString(value); + } + +-struct hdhomerun_device_t *HDHRChannel::GetHDHRDevice(void) +-{ +- return _hdhomerun_device; +-} +- + QString HDHRChannel::TunerGet(const QString &name, bool report_error_return) + { + return DeviceGet(QString("/tuner%1/%2").arg(_tuner).arg(name), +@@ -188,8 +221,7 @@ + return false; + } + +- unsigned long localIP = hdhomerun_device_get_local_machine_addr( +- _hdhomerun_device); ++ unsigned long localIP = hdhomerun_control_get_local_addr(_control_socket); + if (localIP == 0) + { + return false; +@@ -200,7 +232,7 @@ + .arg((localIP >> 8) & 0xFF).arg((localIP >> 0) & 0xFF) + .arg(localPort); + +- if (hdhomerun_device_set_tuner_target(_hdhomerun_device, configValue) <= 0) ++ if (!TunerSet("target", configValue)) + { + return false; + } +@@ -208,9 +240,9 @@ + return true; + } + +-bool HDHRChannel::DeviceClearTarget(void) ++bool HDHRChannel::DeviceClearTarget() + { +- return hdhomerun_device_set_tuner_target(_hdhomerun_device, "none") > 0; ++ return TunerSet("target", "0.0.0.0:0"); + } + + bool HDHRChannel::SetChannelByString(const QString &channum) +@@ -316,8 +348,7 @@ + if (mpeg_prog_num && (GetTuningMode() == "mpeg")) + { + QString pnum = QString::number(mpeg_prog_num); +- _ignore_filters = (hdhomerun_device_set_tuner_program( +- _hdhomerun_device, pnum) > 0); ++ _ignore_filters = QString::null != TunerSet("program", pnum, false); + } + + return true; +@@ -360,27 +391,22 @@ + bool HDHRChannel::Tune(uint frequency, QString /*input*/, + QString modulation, QString si_std) + { +- // Convert dtv_multiplex.modulation strings to something the HDHR can use: +- modulation.replace("qam_", "qam"); // e.g. qam_256 -> qam256 +-#if 0 +- if (modulation == "qamauto") +- modulation = "qam"; // "auto" works just as well? +-#endif +- +- if (modulation.isEmpty()) +- modulation = "auto"; ++ bool ok = false; + +- QString chan = modulation + ':' + QString::number(frequency); ++ VERBOSE(VB_CHANNEL, LOC + ++ QString("TuneTo(%1,%2)").arg(frequency).arg(modulation)); + +- VERBOSE(VB_CHANNEL, LOC + "Tune()ing to " + chan); ++ if (modulation == "8vsb") ++ ok = TunerSet("channel", QString("8vsb:%1").arg(frequency)); ++ else if (modulation == "qam_64") ++ ok = TunerSet("channel", QString("qam64:%1").arg(frequency)); ++ else if (modulation == "qam_256") ++ ok = TunerSet("channel", QString("qam256:%1").arg(frequency)); + +- if (hdhomerun_device_set_tuner_channel(_hdhomerun_device, chan) > 0) +- { ++ if (ok) + SetSIStandard(si_std); +- return true; +- } + +- return false; ++ return ok; + } + + bool HDHRChannel::AddPID(uint pid, bool do_update) +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrchannel.h src/mythtv-0.21/libs/libmythtv/hdhrchannel.h +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrchannel.h 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhrchannel.h 2009-01-09 13:14:58.000000000 +1030 +@@ -39,7 +39,7 @@ + bool SetChannelByString(const QString &chan); + + // Gets +- bool IsOpen(void) const { return (_hdhomerun_device != NULL); } ++ bool IsOpen(void) const { return (_control_socket != NULL); } + QString GetDevice(void) const + { return QString("%1/%2").arg(_device_id, 8, 16).arg(_tuner); } + vector<uint> GetPIDs(void) const +@@ -57,13 +57,11 @@ + bool Tune(const DTVMultiplex &tuning, QString inputname); + + private: ++ bool FindDevice(void); + bool Connect(void); + bool Tune(uint frequency, QString inputname, + QString modulation, QString si_std); + +- +- struct hdhomerun_device_t *GetHDHRDevice(void); +- + bool DeviceSetTarget(unsigned short localPort); + bool DeviceClearTarget(void); + +@@ -76,7 +74,7 @@ + bool report_error_return = true); + + private: +- struct hdhomerun_device_t *_hdhomerun_device; ++ hdhr_socket_t *_control_socket; + uint _device_id; + uint _device_ip; + uint _tuner; +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrrecorder.cpp src/mythtv-0.21/libs/libmythtv/hdhrrecorder.cpp +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrrecorder.cpp 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhrrecorder.cpp 2009-01-22 18:52:43.000000000 +1030 +@@ -1,6 +1,6 @@ + /** -*- Mode: c++ -*- + * HDHRRecorder +- * Copyright (c) 2006-2009 by Silicondust Engineering Ltd, and ++ * Copyright (c) 2006 by Silicondust Engineering Ltd, and + * Daniel Thor Kristjansson + * Distributed as part of MythTV under GPL v2 and later. + */ +@@ -27,7 +27,6 @@ + #include "hdhrrecorder.h" + #include "atsctables.h" + #include "atscstreamdata.h" +-#include "dvbstreamdata.h" + #include "eithelper.h" + #include "tv_rec.h" + +@@ -110,7 +109,7 @@ + buffersize = max(49 * TSPacket::SIZE * 128, buffersize); + + /* Create TS socket. */ +- _video_socket = hdhomerun_video_create(0, buffersize, NULL); ++ _video_socket = hdhomerun_video_create(0, buffersize); + if (!_video_socket) + { + VERBOSE(VB_IMPORTANT, LOC + "Open() failed to open socket"); +@@ -177,13 +176,10 @@ + data->AddMPEGListener(this); + + ATSCStreamData *atsc = dynamic_cast<ATSCStreamData*>(data); +- DVBStreamData *dvb = dynamic_cast<DVBStreamData*>(data); + + if (atsc && atsc->DesiredMinorChannel()) + atsc->SetDesiredChannel(atsc->DesiredMajorChannel(), + atsc->DesiredMinorChannel()); +- else if (dvb) +- dvb->AddDVBMainListener(this); + else if (data->DesiredProgram() >= 0) + data->SetDesiredProgram(data->DesiredProgram()); + } +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrsignalmonitor.cpp src/mythtv-0.21/libs/libmythtv/hdhrsignalmonitor.cpp +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/hdhrsignalmonitor.cpp 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/hdhrsignalmonitor.cpp 2009-01-09 13:14:58.000000000 +1030 +@@ -139,17 +139,19 @@ + { + dtvMonitorRunning = true; + +- HDHRChannel *hdrc = dynamic_cast<HDHRChannel*>(channel); +- struct hdhomerun_device_t *_hdhomerun_device = hdrc->GetHDHRDevice(); +- +- if (!_hdhomerun_device) ++ struct hdhomerun_video_sock_t *_video_socket; ++ _video_socket = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S); ++ if (!_video_socket) + { +- VERBOSE(VB_IMPORTANT, "Failed to get HDHomeRun device handle"); ++ VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to get video socket"); + return; + } + +- if (!hdhomerun_device_stream_start(_hdhomerun_device)) ++ HDHRChannel *hdrc = dynamic_cast<HDHRChannel*>(channel); ++ uint localPort = hdhomerun_video_get_local_port(_video_socket); ++ if (!hdrc->DeviceSetTarget(localPort)) + { ++ hdhomerun_video_destroy(_video_socket); + VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to set target"); + return; + } +@@ -164,7 +166,7 @@ + + size_t data_length; + unsigned char *data_buffer = +- hdhomerun_device_stream_recv(_hdhomerun_device, ++ hdhomerun_video_recv(_video_socket, + VIDEO_DATA_BUFFER_SIZE_1S / 5, + &data_length); + +@@ -177,7 +179,8 @@ + usleep(2500); + } + +- hdhomerun_device_stream_stop(_hdhomerun_device); ++ hdrc->DeviceClearTarget(); ++ hdhomerun_video_destroy(_video_socket); + + VERBOSE(VB_CHANNEL, LOC + "RunTableMonitor(): -- shutdown"); + +@@ -212,15 +215,16 @@ + return; + } + +- HDHRChannel *hdrc = dynamic_cast<HDHRChannel*>(channel); +- struct hdhomerun_device_t *_hdhomerun_device = hdrc->GetHDHRDevice(); +- struct hdhomerun_tuner_status_t status; +- hdhomerun_device_get_tuner_status(_hdhomerun_device, NULL, &status); +- +- uint sig = status.signal_strength; +- uint snq = status.signal_to_noise_quality; +- uint seq = status.symbol_error_quality; +- ++ QString msg = ((HDHRChannel*)channel)->TunerGet("status"); ++ //ss = signal strength, [0,100] ++ //snq = signal to noise quality [0,100] ++ //seq = signal error quality [0,100] ++ int loc_sig = msg.find("ss="), loc_snq = msg.find("snq="); ++ int loc_seq = msg.find("seq="), loc_end = msg.length(); ++ bool ok0, ok1, ok2; ++ uint sig = msg.mid(loc_sig + 3, loc_snq - loc_sig - 4).toUInt(&ok0); ++ uint snq = msg.mid(loc_snq + 4, loc_seq - loc_snq - 5).toUInt(&ok1); ++ uint seq = msg.mid(loc_seq + 4, loc_end - loc_seq - 4).toUInt(&ok2); + (void) snq; // TODO should convert to S/N + (void) seq; // TODO should report this... + +@@ -232,8 +236,9 @@ + bool isLocked = false; + { + QMutexLocker locker(&statusLock); +- signalStrength.SetValue(sig); +- signalLock.SetValue(status.lock_supported); ++ if (loc_sig > 0 && loc_snq > 0 && ok0) ++ signalStrength.SetValue(sig); ++ signalLock.SetValue(signalStrength.IsGood() ? 1 : 0); + isLocked = signalLock.IsGood(); + } + +diff -aur branches/release-0-21-fixes/mythtv/libs/libmythtv/libmythtv.pro src/mythtv-0.21/libs/libmythtv/libmythtv.pro +--- branches/release-0-21-fixes/mythtv/libs/libmythtv/libmythtv.pro 2009-07-13 15:44:12.000000000 +0930 ++++ src/mythtv-0.21/libs/libmythtv/libmythtv.pro 2009-01-09 13:14:58.000000000 +1030 +@@ -459,28 +459,12 @@ + DEFINES += USING_HDHOMERUN + + # HDHomeRun library +- HEADERS += hdhomerun/hdhomerun.h ++ HEADERS += hdhomerun/hdhomerun_pkt.h hdhomerun/hdhomerun_discover.h ++ HEADERS += hdhomerun/hdhomerun_video.h hdhomerun/hdhomerun_control.h + HEADERS += hdhomerun/hdhomerun_os.h +- HEADERS += hdhomerun/hdhomerun_os_posix.h +- HEADERS += hdhomerun/hdhomerun_os_windows.h +- HEADERS += hdhomerun/hdhomerun_channelscan.h +- HEADERS += hdhomerun/hdhomerun_channels.h +- HEADERS += hdhomerun/hdhomerun_control.h +- HEADERS += hdhomerun/hdhomerun_debug.h +- HEADERS += hdhomerun/hdhomerun_pkt.h +- HEADERS += hdhomerun/hdhomerun_device.h +- HEADERS += hdhomerun/hdhomerun_types.h +- HEADERS += hdhomerun/hdhomerun_discover.h +- HEADERS += hdhomerun/hdhomerun_video.h +- +- SOURCES += hdhomerun/hdhomerun_pkt.c +- SOURCES += hdhomerun/hdhomerun_debug.c +- SOURCES += hdhomerun/hdhomerun_discover.c +- SOURCES += hdhomerun/hdhomerun_channels.c +- SOURCES += hdhomerun/hdhomerun_channelscan.c +- SOURCES += hdhomerun/hdhomerun_control.c +- SOURCES += hdhomerun/hdhomerun_video.c +- SOURCES += hdhomerun/hdhomerun_device.c ++ ++ SOURCES += hdhomerun/hdhomerun_pkt.c hdhomerun/hdhomerun_discover.c ++ SOURCES += hdhomerun/hdhomerun_video.c hdhomerun/hdhomerun_control.c + } + + # Support for PVR-150/250/350/500, etc. on Linux |