Ticket #6672: 6672-v3.patch

libs/libmythtv/hdhomerun/hdhomerun_control.h

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 #ifdef __cplusplus
 extern "C" {
@@ -31 +43 @@
  *
  * 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 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);
+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);
+
+/*
  * Get the local machine IP address used when communicating with the device.
  *
  * This function is useful for determining the IP address to use with set target commands.
  *
  * Returns 32-bit IP address with native endianness, or 0 on error.
  */
-extern uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs);
+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);
+
+/*
  * Get/set a control variable on the device.
  *
  * const char *name: The name of var to get/set (c-string). The supported vars is device/firmware dependant.
@@ -65 +95 @@
  * Returns 0 if the operation was rejected (pvalue NULL, perror set).
  * Returns -1 if a communication error occurs.
  */
-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);
+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);
 
 /*
  * Upload new firmware to the device.
@@ -77 +108 @@
  * Returns 0 if the upload was rejected.
  * Returns -1 if an error occurs.
  */
-extern int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file);
+extern LIBTYPE int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file);
 
 #ifdef __cplusplus
 }

libs/libmythtv/hdhomerun/hdhomerun.h

@@ +1 @@
+#ifndef __HDHOMERUN_INCLUDES__
+#define __HDHOMERUN_INCLUDES__
 /*
- * hdhomerun_device.h
+ * hdhomerun.h
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2008 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +16 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
 #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"
+
+#endif /* __HDHOMERUN_INCLUDES__ */
+

libs/libmythtv/hdhomerun/hdhomerun_debug.c

@@ +1 @@
+/*
+ * hdhomerun_debug.c
+ *
+ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+/*
+ * The debug logging includes optional support for connecting to the
+ * Silicondust support server. This option should not be used without
+ * being explicitly enabled by the user. Debug information should be
+ * limited to information useful to diagnosing a problem.
+ *  - Silicondust.
+ */
+
+#include "hdhomerun.h"
+
+#if !defined(HDHOMERUN_DEBUG_HOST)
+#define HDHOMERUN_DEBUG_HOST "debug.silicondust.com"
+#endif
+#if !defined(HDHOMERUN_DEBUG_PORT)
+#define HDHOMERUN_DEBUG_PORT "8002"
+#endif
+
+struct hdhomerun_debug_message_t
+{
+        struct hdhomerun_debug_message_t *next;
+        struct hdhomerun_debug_message_t *prev;
+        char buffer[2048];
+};
+
+struct hdhomerun_debug_t
+{
+        pthread_t thread;
+        volatile bool_t enabled;
+        volatile bool_t terminate;
+        char *prefix;
+
+        pthread_mutex_t print_lock;
+        pthread_mutex_t queue_lock;
+        pthread_mutex_t send_lock;
+
+        struct hdhomerun_debug_message_t *queue_head;
+        struct hdhomerun_debug_message_t *queue_tail;
+        uint32_t queue_depth;
+
+        uint64_t connect_delay;
+
+        char *file_name;
+        FILE *file_fp;
+        int sock;
+};
+
+static THREAD_FUNC_PREFIX hdhomerun_debug_thread_execute(void *arg);
+
+struct hdhomerun_debug_t *hdhomerun_debug_create(void)
+{
+        struct hdhomerun_debug_t *dbg = (struct hdhomerun_debug_t *)calloc(1, sizeof(struct hdhomerun_debug_t));
+        if (!dbg) {
+                return NULL;
+        }
+
+        dbg->sock = -1;
+
+        pthread_mutex_init(&dbg->print_lock, NULL);
+        pthread_mutex_init(&dbg->queue_lock, NULL);
+        pthread_mutex_init(&dbg->send_lock, NULL);
+
+        if (pthread_create(&dbg->thread, NULL, &hdhomerun_debug_thread_execute, dbg) != 0) {
+                free(dbg);
+                return NULL;
+        }
+
+        return dbg;
+}
+
+/* Send lock held by caller */
+static void hdhomerun_debug_close_file(struct hdhomerun_debug_t *dbg)
+{
+        if (!dbg->file_fp) {
+                return;
+        }
+
+        fclose(dbg->file_fp);
+        dbg->file_fp = NULL;
+}
+
+/* Send lock held by caller */
+static void hdhomerun_debug_close_sock(struct hdhomerun_debug_t *dbg)
+{
+        if (dbg->sock == -1) {
+                return;
+        }
+
+        close(dbg->sock);
+        dbg->sock = -1;
+}
+
+void hdhomerun_debug_destroy(struct hdhomerun_debug_t *dbg)
+{
+        dbg->terminate = TRUE;
+        pthread_join(dbg->thread, NULL);
+
+        hdhomerun_debug_close_file(dbg);
+        hdhomerun_debug_close_sock(dbg);
+
+        if (dbg->prefix) {
+                free(dbg->prefix);
+        }
+
+        free(dbg);
+}
+
+void hdhomerun_debug_set_prefix(struct hdhomerun_debug_t *dbg, const char *prefix)
+{
+        pthread_mutex_lock(&dbg->print_lock);
+
+        if (dbg->prefix) {
+                free(dbg->prefix);
+                dbg->prefix = NULL;
+        }
+
+        if (prefix) {
+                dbg->prefix = strdup(prefix);
+        }
+
+        pthread_mutex_unlock(&dbg->print_lock);
+}
+
+void hdhomerun_debug_set_filename(struct hdhomerun_debug_t *dbg, const char *filename)
+{
+        pthread_mutex_lock(&dbg->send_lock);
+
+        if (!filename && !dbg->file_name) {
+                pthread_mutex_unlock(&dbg->send_lock);
+                return;
+        }
+        if (filename && dbg->file_name) {
+                if (strcmp(filename, dbg->file_name) == 0) {
+                        pthread_mutex_unlock(&dbg->send_lock);
+                        return;
+                }
+        }
+
+        hdhomerun_debug_close_file(dbg);
+        hdhomerun_debug_close_sock(dbg);
+
+        if (dbg->file_name) {
+                free(dbg->file_name);
+                dbg->file_name = NULL;
+        }
+        if (filename) {
+                dbg->file_name = strdup(filename);
+        }
+
+        pthread_mutex_unlock(&dbg->send_lock);
+}
+
+void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg)
+{
+        pthread_mutex_lock(&dbg->send_lock);
+
+        dbg->enabled = TRUE;
+
+        pthread_mutex_unlock(&dbg->send_lock);
+}
+
+void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg)
+{
+        pthread_mutex_lock(&dbg->send_lock);
+
+        dbg->enabled = FALSE;
+        hdhomerun_debug_close_file(dbg);
+        hdhomerun_debug_close_sock(dbg);
+
+        pthread_mutex_unlock(&dbg->send_lock);
+}
+
+bool_t hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg)
+{
+        if (!dbg) {
+                return FALSE;
+        }
+
+        return dbg->enabled;
+}
+
+void hdhomerun_debug_flush(struct hdhomerun_debug_t *dbg, uint64_t timeout)
+{
+        timeout = getcurrenttime() + timeout;
+
+        while (getcurrenttime() < timeout) {
+                pthread_mutex_lock(&dbg->queue_lock);
+                struct hdhomerun_debug_message_t *message = dbg->queue_tail;
+                pthread_mutex_unlock(&dbg->queue_lock);
+
+                if (!message) {
+                        return;
+                }
+
+                msleep(10);
+        }
+}
+
+void hdhomerun_debug_printf(struct hdhomerun_debug_t *dbg, const char *fmt, ...)
+{
+        va_list args;
+        va_start(args, fmt);
+        hdhomerun_debug_vprintf(dbg, fmt, args);
+        va_end(args);
+}
+
+void hdhomerun_debug_vprintf(struct hdhomerun_debug_t *dbg, const char *fmt, va_list args)
+{
+        if (!dbg) {
+                return;
+        }
+        if (!dbg->enabled) {
+                return;
+        }
+
+        struct hdhomerun_debug_message_t *message = (struct hdhomerun_debug_message_t *)malloc(sizeof(struct hdhomerun_debug_message_t));
+        if (!message) {
+                return;
+        }
+
+        char *ptr = message->buffer;
+        char *end = message->buffer + sizeof(message->buffer) - 2;
+        *end = 0;
+
+        /*
+         * Timestamp.
+         */
+        time_t current_time = time(NULL);
+        ptr += strftime(ptr, end - ptr, "%Y%m%d-%H:%M:%S ", localtime(&current_time));
+        if (ptr > end) {
+                ptr = end;
+        }
+
+        /*
+         * Debug prefix.
+         */
+        pthread_mutex_lock(&dbg->print_lock);
+
+        if (dbg->prefix) {
+                int len = snprintf(ptr, end - ptr, "%s ", dbg->prefix);
+                len = (len <= 0) ? 0 : len;
+                ptr += len;
+                if (ptr > end) {
+                        ptr = end;
+                }
+        }
+
+        pthread_mutex_unlock(&dbg->print_lock);
+
+        /*
+         * Message text.
+         */
+        int len = vsnprintf(ptr, end - ptr, fmt, args);
+        len = (len < 0) ? 0 : len; /* len does not include null */
+        ptr += len;
+        if (ptr > end) {
+                ptr = end;
+        }
+
+        /*
+         * Force newline.
+         */
+        if ((ptr[-1] != '\n') && (ptr + 1 <= end)) {
+                *ptr++ = '\n';
+        }
+
+        /*
+         * Force NULL.
+         */
+        if (ptr + 1 > end) {
+                ptr = end - 1;
+        }
+        *ptr++ = 0;
+
+        /*
+         * Enqueue.
+         */
+        pthread_mutex_lock(&dbg->queue_lock);
+
+        message->prev = NULL;
+        message->next = dbg->queue_head;
+        dbg->queue_head = message;
+        if (message->next) {
+                message->next->prev = message;
+        } else {
+                dbg->queue_tail = message;
+        }
+        dbg->queue_depth++;
+
+        pthread_mutex_unlock(&dbg->queue_lock);
+}
+
+/* Send lock held by caller */
+static bool_t hdhomerun_debug_output_message_file(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
+{
+        if (!dbg->file_fp) {
+                uint64_t current_time = getcurrenttime();
+                if (current_time < dbg->connect_delay) {
+                        return FALSE;
+                }
+                dbg->connect_delay = current_time + 30*1000;
+
+                dbg->file_fp = fopen(dbg->file_name, "a");
+                if (!dbg->file_fp) {
+                        return FALSE;
+                }
+        }
+
+        fprintf(dbg->file_fp, "%s", message->buffer);
+        fflush(dbg->file_fp);
+
+        return TRUE;
+}
+
+/* Send lock held by caller */
+#if defined(__CYGWIN__)
+static bool_t hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
+{
+        return TRUE;
+}
+#else
+static bool_t hdhomerun_debug_output_message_sock(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
+{
+        if (dbg->sock == -1) {
+                uint64_t current_time = getcurrenttime();
+                if (current_time < dbg->connect_delay) {
+                        return FALSE;
+                }
+                dbg->connect_delay = current_time + 30*1000;
+
+                dbg->sock = (int)socket(AF_INET, SOCK_STREAM, 0);
+                if (dbg->sock == -1) {
+                        return FALSE;
+                }
+
+                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(HDHOMERUN_DEBUG_HOST, HDHOMERUN_DEBUG_PORT, &hints, &sock_info) != 0) {
+                        hdhomerun_debug_close_sock(dbg);
+                        return FALSE;
+                }
+                if (connect(dbg->sock, sock_info->ai_addr, (int)sock_info->ai_addrlen) != 0) {
+                        freeaddrinfo(sock_info);
+                        hdhomerun_debug_close_sock(dbg);
+                        return FALSE;
+                }
+                freeaddrinfo(sock_info);
+        }
+
+        size_t length = strlen(message->buffer);
+        if (send(dbg->sock, (char *)message->buffer, (int)length, 0) != length) {
+                hdhomerun_debug_close_sock(dbg);
+                return FALSE;
+        }
+
+        return TRUE;
+}
+#endif
+
+static bool_t hdhomerun_debug_output_message(struct hdhomerun_debug_t *dbg, struct hdhomerun_debug_message_t *message)
+{
+        pthread_mutex_lock(&dbg->send_lock);
+
+        if (!dbg->enabled) {
+                pthread_mutex_unlock(&dbg->send_lock);
+                return TRUE;
+        }
+
+        bool_t ret;
+        if (dbg->file_name) {
+                ret = hdhomerun_debug_output_message_file(dbg, message);
+        } else {
+                ret = hdhomerun_debug_output_message_sock(dbg, message);
+        }
+
+        pthread_mutex_unlock(&dbg->send_lock);
+        return ret;
+}
+
+static void hdhomerun_debug_pop_and_free_message(struct hdhomerun_debug_t *dbg)
+{
+        pthread_mutex_lock(&dbg->queue_lock);
+
+        struct hdhomerun_debug_message_t *message = dbg->queue_tail;
+        dbg->queue_tail = message->prev;
+        if (message->prev) {
+                message->prev->next = NULL;
+        } else {
+                dbg->queue_head = NULL;
+        }
+        dbg->queue_depth--;
+
+        pthread_mutex_unlock(&dbg->queue_lock);
+
+        free(message);
+}
+
+static THREAD_FUNC_PREFIX hdhomerun_debug_thread_execute(void *arg)
+{
+        struct hdhomerun_debug_t *dbg = (struct hdhomerun_debug_t *)arg;
+
+        while (!dbg->terminate) {
+
+                pthread_mutex_lock(&dbg->queue_lock);
+                struct hdhomerun_debug_message_t *message = dbg->queue_tail;
+                uint32_t queue_depth = dbg->queue_depth;
+                pthread_mutex_unlock(&dbg->queue_lock);
+
+                if (!message) {
+                        msleep(250);
+                        continue;
+                }
+
+                if (queue_depth > 256) {
+                        hdhomerun_debug_pop_and_free_message(dbg);
+                        continue;
+                }
+
+                if (!hdhomerun_debug_output_message(dbg, message)) {
+                        msleep(250);
+                        continue;
+                }
+
+                hdhomerun_debug_pop_and_free_message(dbg);
+        }
+
+        return 0;
+}

libs/libmythtv/hdhomerun/hdhomerun_os.h

@@ -1 +1 @@
 /*
  * hdhomerun_os.h
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2008 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#if defined(WIN32)
+#if defined(_WIN32) || defined(_WIN64)
 #define __WINDOWS__
 #endif
 
 #if defined(__WINDOWS__)
-#include <windows.h>
-#include <sys/types.h>
-#include <sys/timeb.h>
+#include "hdhomerun_os_windows.h"
 #else
-#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>
+#include "hdhomerun_os_posix.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
-

libs/libmythtv/hdhomerun/hdhomerun_debug.h

@@ +1 @@
+/*
+ * hdhomerun_debug.h
+ *
+ * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+/*
+ * The debug logging includes optional support for connecting to the
+ * Silicondust support server. This option should not be used without
+ * being explicitly enabled by the user. Debug information should be
+ * limited to information useful to diagnosing a problem.
+ *  - Silicondust.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct hdhomerun_debug_t;
+
+extern LIBTYPE struct hdhomerun_debug_t *hdhomerun_debug_create(void);
+extern LIBTYPE void hdhomerun_debug_destroy(struct hdhomerun_debug_t *dbg);
+
+extern LIBTYPE void hdhomerun_debug_set_prefix(struct hdhomerun_debug_t *dbg, const char *prefix);
+extern LIBTYPE void hdhomerun_debug_set_filename(struct hdhomerun_debug_t *dbg, const char *filename);
+extern LIBTYPE void hdhomerun_debug_enable(struct hdhomerun_debug_t *dbg);
+extern LIBTYPE void hdhomerun_debug_disable(struct hdhomerun_debug_t *dbg);
+extern LIBTYPE bool_t hdhomerun_debug_enabled(struct hdhomerun_debug_t *dbg);
+
+extern LIBTYPE void hdhomerun_debug_flush(struct hdhomerun_debug_t *dbg, uint64_t timeout);
+
+extern LIBTYPE void hdhomerun_debug_printf(struct hdhomerun_debug_t *dbg, const char *fmt, ...);
+extern LIBTYPE void hdhomerun_debug_vprintf(struct hdhomerun_debug_t *dbg, const char *fmt, va_list args);
+
+#ifdef __cplusplus
+}
+#endif

libs/libmythtv/hdhomerun/hdhomerun_channels.c

@@ +1 @@
+/*
+ * hdhomerun_channels.c
+ *
+ * Copyright © 2007-2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+#include "hdhomerun.h"
+
+#define FREQUENCY_RESOLUTION 62500
+
+struct hdhomerun_channel_entry_t {
+        struct hdhomerun_channel_entry_t *next;
+        struct hdhomerun_channel_entry_t *prev;
+        uint32_t frequency;
+        uint8_t channel_number;
+        char name[16];
+};
+
+struct hdhomerun_channel_list_t {
+        struct hdhomerun_channel_entry_t *head;
+        struct hdhomerun_channel_entry_t *tail;
+};
+
+struct hdhomerun_channelmap_range_t {
+        uint8_t channel_range_start;
+        uint8_t channel_range_end;
+        uint32_t frequency;
+        uint32_t spacing;
+};
+
+struct hdhomerun_channelmap_record_t {
+        const char *channelmap_prefix;
+        const char *channelmap;
+        const struct hdhomerun_channelmap_range_t *range_list;
+        const char *channelmap_scan_group;
+        const char *countrycodes;
+};
+
+/* AU antenna channels. Channels {0, 1, 2, 6, 7, 8, 9, 9A} are numbered {2, 3, 4, 5, 6, 7, 8, 9} by the HDHomeRun. */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_au_bcast[] = {
+        {  2,   2,  48500000, 7000000},
+        {  3,   4,  59500000, 7000000},
+        {  5,  12, 177500000, 7000000},
+        { 28,  69, 529500000, 7000000},
+        {  0,   0,         0,       0}
+};
+
+/* AU cable channels. TBD. */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_au_cable[] = {
+        {  0,   0,         0,       0}
+};
+
+/* EU antenna channels. */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_eu_bcast[] = {
+        {  2,   4,  50500000, 7000000},
+        {  5,  12, 177500000, 7000000},
+        { 21,  69, 474000000, 8000000},
+        {  0,   0,         0,       0}
+};
+
+/* EU cable channels. Channels do not have simple numbers - the HDHomeRun uses its own numbering scheme (subject to change). */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_eu_cable[] = {
+        {  6,   7, 113000000, 8000000},
+        {  9, 100, 138000000, 8000000},
+        {  0,   0,         0,       0}
+};
+
+/* US antenna channels. */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_us_bcast[] = {
+        {  2,   4,  57000000, 6000000},
+        {  5,   6,  79000000, 6000000},
+        {  7,  13, 177000000, 6000000},
+        { 14,  69, 473000000, 6000000},
+        {  0,   0,         0,       0}
+};
+
+/* US cable channels. */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_us_cable[] = {
+        {  2,   4,  57000000, 6000000},
+        {  5,   6,  79000000, 6000000},
+        {  7,  13, 177000000, 6000000},
+        { 14,  22, 123000000, 6000000},
+        { 23,  94, 219000000, 6000000},
+        { 95,  99,  93000000, 6000000},
+        {100, 135, 651000000, 6000000},
+        {  0,   0,         0,       0}
+};
+
+/* US cable channels (HRC). */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_us_hrc[] = {
+        {  2,   4,  55752700, 6000300},
+        {  5,   6,  79753900, 6000300},
+        {  7,  13, 175758700, 6000300},
+        { 14,  22, 121756000, 6000300},
+        { 23,  94, 217760800, 6000300},
+        { 95,  99,  91754500, 6000300},
+        {100, 135, 649782400, 6000300},
+        {  0,   0,         0,       0}
+};
+
+/* US cable channels (IRC). */
+static const struct hdhomerun_channelmap_range_t hdhomerun_channelmap_range_us_irc[] = {
+        {  2,   4,  57012500, 6000000},
+        {  5,   6,  81012500, 6000000},
+        {  7,  13, 177012500, 6000000},
+        { 14,  22, 123012500, 6000000},
+        { 23,  41, 219012500, 6000000},
+        { 42,  42, 333025000, 6000000},
+        { 43,  94, 339012500, 6000000},
+        { 95,  97,  93012500, 6000000},
+        { 98,  99, 111025000, 6000000},
+        {100, 135, 651012500, 6000000},
+        {  0,   0,         0,       0}
+};
+
+static const struct hdhomerun_channelmap_record_t hdhomerun_channelmap_table[] = {
+        {"au", "au-bcast", hdhomerun_channelmap_range_au_bcast, "au-bcast",               "AU"},
+        {"au", "au-cable", hdhomerun_channelmap_range_au_cable, "au-cable",               "AU"},
+        {"eu", "eu-bcast", hdhomerun_channelmap_range_eu_bcast, "eu-bcast",               "EU"},
+        {"eu", "eu-cable", hdhomerun_channelmap_range_eu_cable, "eu-cable",               "EU"},
+        {"tw", "tw-bcast", hdhomerun_channelmap_range_us_bcast, "tw-bcast",               "TW"},
+        {"tw", "tw-cable", hdhomerun_channelmap_range_us_cable, "tw-cable",               "TW"},
+        {"us", "us-bcast", hdhomerun_channelmap_range_us_bcast, "us-bcast",               "CA US"},
+        {"us", "us-cable", hdhomerun_channelmap_range_us_cable, "us-cable us-hrc us-irc", "CA US"},
+        {"us", "us-hrc",   hdhomerun_channelmap_range_us_hrc  , "us-cable us-hrc us-irc", "CA US"},
+        {"us", "us-irc",   hdhomerun_channelmap_range_us_irc,   "us-cable us-hrc us-irc", "CA US"},
+        {NULL, NULL,       NULL,                                NULL,                     NULL}
+};
+
+const char *hdhomerun_channelmap_convert_countrycode_to_channelmap_prefix(const char *countrycode)
+{
+        const struct hdhomerun_channelmap_record_t *record = hdhomerun_channelmap_table;
+        while (record->channelmap) {
+                if (strstr(record->countrycodes, countrycode)) {
+                        return record->channelmap_prefix;
+                }
+                record++;
+        }
+
+        return "eu";
+}
+
+const char *hdhomerun_channelmap_get_channelmap_scan_group(const char *channelmap)
+{
+        const struct hdhomerun_channelmap_record_t *record = hdhomerun_channelmap_table;
+        while (record->channelmap) {
+                if (strstr(channelmap, record->channelmap)) {
+                        return record->channelmap_scan_group;
+                }
+                record++;
+        }
+
+        return NULL;
+}
+
+uint8_t hdhomerun_channel_entry_channel_number(struct hdhomerun_channel_entry_t *entry)
+{
+        return entry->channel_number;
+}
+
+uint32_t hdhomerun_channel_entry_frequency(struct hdhomerun_channel_entry_t *entry)
+{
+        return entry->frequency;
+}
+
+const char *hdhomerun_channel_entry_name(struct hdhomerun_channel_entry_t *entry)
+{
+        return entry->name;
+}
+
+struct hdhomerun_channel_entry_t *hdhomerun_channel_list_first(struct hdhomerun_channel_list_t *channel_list)
+{
+        return channel_list->head;
+}
+
+struct hdhomerun_channel_entry_t *hdhomerun_channel_list_last(struct hdhomerun_channel_list_t *channel_list)
+{
+        return channel_list->tail;
+}
+
+struct hdhomerun_channel_entry_t *hdhomerun_channel_list_next(struct hdhomerun_channel_list_t *channel_list, struct hdhomerun_channel_entry_t *entry)
+{
+        return entry->next;
+}
+
+struct hdhomerun_channel_entry_t *hdhomerun_channel_list_prev(struct hdhomerun_channel_list_t *channel_list, struct hdhomerun_channel_entry_t *entry)
+{
+        return entry->prev;
+}
+
+uint32_t hdhomerun_channel_list_total_count(struct hdhomerun_channel_list_t *channel_list)
+{
+        uint32_t count = 0;
+
+        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
+        while (entry) {
+                count++;
+                entry = hdhomerun_channel_list_next(channel_list, entry);
+        }
+
+        return count;
+}
+
+uint32_t hdhomerun_channel_list_frequency_count(struct hdhomerun_channel_list_t *channel_list)
+{
+        uint32_t count = 0;
+        uint32_t last_frequency = 0;
+
+        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
+        while (entry) {
+                if (entry->frequency != last_frequency) {
+                        last_frequency = entry->frequency;
+                        count++;
+                }
+
+                entry = hdhomerun_channel_list_next(channel_list, entry);
+        }
+
+        return count;
+}
+
+uint32_t hdhomerun_channel_frequency_truncate(uint32_t frequency)
+{
+        return (frequency / FREQUENCY_RESOLUTION) * FREQUENCY_RESOLUTION;
+}
+
+uint32_t hdhomerun_channel_number_to_frequency(struct hdhomerun_channel_list_t *channel_list, uint8_t channel_number)
+{
+        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
+        while (entry) {
+                if (entry->channel_number == channel_number) {
+                        return entry->frequency;
+                }
+
+                entry = hdhomerun_channel_list_next(channel_list, entry);
+        }
+
+        return 0;
+}
+
+uint8_t hdhomerun_channel_frequency_to_number(struct hdhomerun_channel_list_t *channel_list, uint32_t frequency)
+{
+        frequency = hdhomerun_channel_frequency_truncate(frequency);
+
+        struct hdhomerun_channel_entry_t *entry = hdhomerun_channel_list_first(channel_list);
+        while (entry) {
+                if (entry->frequency == frequency) {
+                        return entry->channel_number;
+                }
+                if (entry->frequency > frequency) {
+                        return 0;
+                }
+
+                entry = hdhomerun_channel_list_next(channel_list, entry);
+        }
+
+        return 0;
+}
+
+static void hdhomerun_channel_list_build_insert(struct hdhomerun_channel_list_t *channel_list, struct hdhomerun_channel_entry_t *entry)
+{
+        struct hdhomerun_channel_entry_t *prev = NULL;
+        struct hdhomerun_channel_entry_t *next = channel_list->head;
+
+        while (next) {
+                if (next->frequency > entry->frequency) {
+                        break;
+                }
+
+                prev = next;
+                next = next->next;
+        }
+
+        entry->prev = prev;
+        entry->next = next;
+
+        if (prev) {
+                prev->next = entry;
+        } else {
+                channel_list->head = entry;
+        }
+
+        if (next) {
+                next->prev = entry;
+        } else {
+                channel_list->tail = entry;
+        }
+}
+
+static void hdhomerun_channel_list_build_range(struct hdhomerun_channel_list_t *channel_list, const char *channelmap, const struct hdhomerun_channelmap_range_t *range)
+{
+        uint8_t channel_number;
+        for (channel_number = range->channel_range_start; channel_number <= range->channel_range_end; channel_number++) {
+                struct hdhomerun_channel_entry_t *entry = (struct hdhomerun_channel_entry_t *)calloc(1, sizeof(struct hdhomerun_channel_entry_t));
+                if (!entry) {
+                        return;
+                }
+
+                entry->channel_number = channel_number;
+                entry->frequency = range->frequency + ((uint32_t)(channel_number - range->channel_range_start) * range->spacing);
+                entry->frequency = hdhomerun_channel_frequency_truncate(entry->frequency);
+                sprintf(entry->name, "%s:%u", channelmap, entry->channel_number);
+
+                hdhomerun_channel_list_build_insert(channel_list, entry);
+        }
+}
+
+static void hdhomerun_channel_list_build_ranges(struct hdhomerun_channel_list_t *channel_list, const struct hdhomerun_channelmap_record_t *record)
+{
+        const struct hdhomerun_channelmap_range_t *range = record->range_list;
+        while (range->frequency) {
+                hdhomerun_channel_list_build_range(channel_list, record->channelmap, range);
+                range++;
+        }
+}
+
+void hdhomerun_channel_list_destroy(struct hdhomerun_channel_list_t *channel_list)
+{
+        while (channel_list->head) {
+                struct hdhomerun_channel_entry_t *entry = channel_list->head;
+                channel_list->head = entry->next;
+                free(entry);
+        }
+
+        free(channel_list);
+}
+
+struct hdhomerun_channel_list_t *hdhomerun_channel_list_create(const char *channelmap)
+{
+        struct hdhomerun_channel_list_t *channel_list = (struct hdhomerun_channel_list_t *)calloc(1, sizeof(struct hdhomerun_channel_list_t));
+        if (!channel_list) {
+                return NULL;
+        }
+
+        const struct hdhomerun_channelmap_record_t *record = hdhomerun_channelmap_table;
+        while (record->channelmap) {
+                if (!strstr(channelmap, record->channelmap)) {
+                        record++;
+                        continue;
+                }
+
+                hdhomerun_channel_list_build_ranges(channel_list, record);
+                record++;
+        }
+
+        if (!channel_list->head) {
+                free(channel_list);
+                return NULL;
+        }
+
+        return channel_list;
+}

libs/libmythtv/hdhomerun/hdhomerun_pkt.c

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
+#include "hdhomerun.h"
 
-uint8_t hdhomerun_read_u8(uint8_t **pptr)
+struct hdhomerun_pkt_t *hdhomerun_pkt_create(void)
 {
-        uint8_t *ptr = *pptr;
-        uint8_t v = *ptr++;
-        *pptr = ptr;
+        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++;
         return v;
 }
 
-uint16_t hdhomerun_read_u16(uint8_t **pptr)
+uint16_t hdhomerun_pkt_read_u16(struct hdhomerun_pkt_t *pkt)
 {
-        uint8_t *ptr = *pptr;
         uint16_t v;
-        v =  (uint16_t)*ptr++ << 8;
-        v |= (uint16_t)*ptr++ << 0;
-        *pptr = ptr;
+        v =  (uint16_t)*pkt->pos++ << 8;
+        v |= (uint16_t)*pkt->pos++ << 0;
         return v;
 }
 
-uint32_t hdhomerun_read_u32(uint8_t **pptr)
+uint32_t hdhomerun_pkt_read_u32(struct hdhomerun_pkt_t *pkt)
 {
-        uint8_t *ptr = *pptr;
         uint32_t v;
-        v =  (uint32_t)*ptr++ << 24;
-        v |= (uint32_t)*ptr++ << 16;
-        v |= (uint32_t)*ptr++ << 8;
-        v |= (uint32_t)*ptr++ << 0;
-        *pptr = ptr;
+        v =  (uint32_t)*pkt->pos++ << 24;
+        v |= (uint32_t)*pkt->pos++ << 16;
+        v |= (uint32_t)*pkt->pos++ << 8;
+        v |= (uint32_t)*pkt->pos++ << 0;
         return v;
 }
 
-size_t hdhomerun_read_var_length(uint8_t **pptr, uint8_t *end)
+size_t hdhomerun_pkt_read_var_length(struct hdhomerun_pkt_t *pkt)
 {
-        uint8_t *ptr = *pptr;
         size_t length;
         
-        if (ptr + 1 > end) {
-                return -1;
+        if (pkt->pos + 1 > pkt->end) {
+                return (size_t)-1;
         }
 
-        length = (size_t)*ptr++;
+        length = (size_t)*pkt->pos++;
         if (length & 0x0080) {
-                if (ptr + 1 > end) {
-                        return -1;
+                if (pkt->pos + 1 > pkt->end) {
+                        return (size_t)-1;
                 }
 
                 length &= 0x007F;
-                length |= (size_t)*ptr++ << 7;
+                length |= (size_t)*pkt->pos++ << 7;
         }
         
-        *pptr = ptr;
         return length; 
 }
 
-int hdhomerun_read_tlv(uint8_t **pptr, uint8_t *end, uint8_t *ptag, size_t *plength, uint8_t **pvalue)
+uint8_t *hdhomerun_pkt_read_tlv(struct hdhomerun_pkt_t *pkt, uint8_t *ptag, size_t *plength)
 {
-        if (end - *pptr < 2) {
-                return -1;
+        if (pkt->pos + 2 > 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;
+        *ptag = hdhomerun_pkt_read_u8(pkt);
+        *plength = hdhomerun_pkt_read_var_length(pkt);
+
+        if (pkt->pos + *plength > pkt->end) {
+                return NULL;
         }
         
-        *pptr += *plength;
-        return 0;
+        return pkt->pos + *plength;
 }
 
-void hdhomerun_write_u8(uint8_t **pptr, uint8_t v)
+void hdhomerun_pkt_write_u8(struct hdhomerun_pkt_t *pkt, uint8_t v)
 {
-        uint8_t *ptr = *pptr;
-        *ptr++ = v;
-        *pptr = ptr;
-}
+        *pkt->pos++ = v;
 
-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;
+        if (pkt->pos > pkt->end) {
+                pkt->end = pkt->pos;
+        }
 }
 
-void hdhomerun_write_u32(uint8_t **pptr, uint32_t v)
+void hdhomerun_pkt_write_u16(struct hdhomerun_pkt_t *pkt, uint16_t v)
 {
-        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;
-}
+        *pkt->pos++ = (uint8_t)(v >> 8);
+        *pkt->pos++ = (uint8_t)(v >> 0);
 
-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);
+        if (pkt->pos > pkt->end) {
+                pkt->end = pkt->pos;
         }
-        *pptr = ptr;
 }
 
-static void hdhomerun_write_mem(uint8_t **pptr, void *mem, size_t length)
+void hdhomerun_pkt_write_u32(struct hdhomerun_pkt_t *pkt, uint32_t v)
 {
-        uint8_t *ptr = *pptr;
-        memcpy(ptr, mem, length);
-        ptr += length;
-        *pptr = ptr;
-}
+        *pkt->pos++ = (uint8_t)(v >> 24);
+        *pkt->pos++ = (uint8_t)(v >> 16);
+        *pkt->pos++ = (uint8_t)(v >> 8);
+        *pkt->pos++ = (uint8_t)(v >> 0);
 
-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;
+        if (pkt->pos > pkt->end) {
+                pkt->end = pkt->pos;
         }
-        return crc ^ 0xFFFFFFFF;
 }
 
-static int hdhomerun_check_crc(uint8_t *start, uint8_t *end)
+void hdhomerun_pkt_write_var_length(struct hdhomerun_pkt_t *pkt, size_t v)
 {
-        if (end - start < 8) {
-                return -1;
+        if (v <= 127) {
+                *pkt->pos++ = (uint8_t)v;
+        } else {
+                *pkt->pos++ = (uint8_t)(v | 0x80);
+                *pkt->pos++ = (uint8_t)(v >> 7);
         }
-        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;
+
+        if (pkt->pos > pkt->end) {
+                pkt->end = pkt->pos;
         }
-        return 0;
 }
 
-static void hdhomerun_write_header_length(uint8_t *ptr, size_t length)
+void hdhomerun_pkt_write_mem(struct hdhomerun_pkt_t *pkt, const void *mem, size_t length)
 {
-        hdhomerun_write_u16(&ptr, (uint16_t)length);
-}
+        memcpy(pkt->pos, mem, length);
+        pkt->pos += length;
 
-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;
+        if (pkt->pos > pkt->end) {
+                pkt->end = pkt->pos;
+        }
 }
 
-void hdhomerun_write_discover_request(uint8_t **pptr, uint32_t device_type, uint32_t device_id)
+int hdhomerun_pkt_open_frame(struct hdhomerun_pkt_t *pkt, uint16_t *ptype)
 {
-        uint8_t *start = *pptr;
-        hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_DISCOVER_REQ);
-        hdhomerun_write_u16(pptr, 0);
+        pkt->pos = pkt->start;
 
-        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);
+        if (pkt->pos + 4 > pkt->end) {
+                return 0;
+        }
 
-        hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4));
-        hdhomerun_write_crc(pptr, start);
-}
+        *ptype = hdhomerun_pkt_read_u16(pkt);
+        size_t length = hdhomerun_pkt_read_u16(pkt);
+        pkt->pos += length;
 
-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);
+        if (pkt->pos + 4 > pkt->end) {
+                pkt->pos = pkt->start;
+                return 0;
+        }
 
-        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 calc_crc = hdhomerun_pkt_calc_crc(pkt->start, pkt->pos);
 
-        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);
+        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;
         }
 
-        hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4));
-        hdhomerun_write_crc(pptr, start);
+        pkt->start += 4;
+        pkt->end = pkt->start + length;
+        pkt->pos = pkt->start;
+        return 1;
 }
 
-void hdhomerun_write_upgrade_request(uint8_t **pptr, uint32_t sequence, void *data, size_t length)
+void hdhomerun_pkt_seal_frame(struct hdhomerun_pkt_t *pkt, uint16_t frame_type)
 {
-        uint8_t *start = *pptr;
-        hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_UPGRADE_REQ);
-        hdhomerun_write_u16(pptr, 0);
+        size_t length = pkt->end - pkt->start;
 
-        hdhomerun_write_u32(pptr, sequence);
-        if (length > 0) {
-                hdhomerun_write_mem(pptr, data, length);
-        }
+        pkt->start -= 4;
+        pkt->pos = pkt->start;
+        hdhomerun_pkt_write_u16(pkt, frame_type);
+        hdhomerun_pkt_write_u16(pkt, (uint16_t)length);
 
-        hdhomerun_write_header_length(start + 2, *pptr - start - 4);
-        hdhomerun_write_crc(pptr, start);
-}
+        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);
 
-size_t hdhomerun_peek_packet_length(uint8_t *ptr)
-{
-        ptr += 2;
-        return (size_t)hdhomerun_read_u16(&ptr) + 8;
+        pkt->pos = pkt->start;
 }
-
-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;
-}
-

libs/libmythtv/hdhomerun/hdhomerun_device.c

@@ -1 +1 @@
 /*
- * hdhomerun_record.c
+ * hdhomerun_device.c
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2008 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
-#include "hdhomerun_control.h"
-#include "hdhomerun_video.h"
-#include "hdhomerun_device.h"
+#include "hdhomerun.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;
         unsigned int tuner;
-        char result_buffer[1024];
+        uint32_t lockkey;
+        char name[32];
+        char model[32];
 };
 
-struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner)
+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)hdhomerun_control_get_device_id(hd->cs), 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);
+        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 *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->tuner = tuner;
+        hd->dbg = dbg;
 
-        hd->cs = hdhomerun_control_create(device_id, device_ip);
+        hd->cs = hdhomerun_control_create(0, 0, hd->dbg);
         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);
         }
@@ -60 +102 @@
         free(hd);
 }
 
-void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner)
+static bool_t is_hex_char(char c)
 {
-        hd->tuner = tuner;
+        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];
+        unsigned int tuner;
+
+        if (sscanf(device_str, "%lu.%lu.%lu.%lu-%u", &a[0], &a[1], &a[2], &a[3], &tuner) != 5) {
+                tuner = 0;
+                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, tuner, 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;
+}
+
+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)
+{
+        return hd->tuner;
+}
+
 struct hdhomerun_control_sock_t *hdhomerun_device_get_control_sock(struct hdhomerun_device_t *hd)
 {
         return hd->cs;
@@ -72 +257 @@
 
 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) {
-                hd->vs = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S);
+                hdhomerun_debug_printf(hd->dbg, "hdhomerun_device_get_video_sock: failed to create video object\n");
+                return NULL;
         }
+
         return hd->vs;
 }
 
@@ -96 +288 @@
         return (uint32_t)value;
 }
 
-int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status)
+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)
+{
         memset(status, 0, sizeof(struct hdhomerun_tuner_status_t));
 
         char name[32];
@@ -109 +367 @@
                 return ret;
         }
 
+        if (pstatus_str) {
+                *pstatus_str = status_str;
+        }
+
         char *channel = strstr(status_str, "ch=");
         if (channel) {
-                sscanf(channel + 3, "%s", status->channel);
+                sscanf(channel + 3, "%31s", status->channel);
         }
 
+        char *lock = strstr(status_str, "lock=");
+        if (lock) {
+                sscanf(lock + 5, "%31s", status->lock_str);
+        }
+
         status->signal_strength = (unsigned int)hdhomerun_device_get_status_parse(status_str, "ss=");
         status->signal_to_noise_quality = (unsigned int)hdhomerun_device_get_status_parse(status_str, "snq=");
         status->symbol_error_quality = (unsigned int)hdhomerun_device_get_status_parse(status_str, "seq=");
         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;
 }
 
@@ -151 +428 @@
         return hdhomerun_control_get(hd->cs, name, pfilter, NULL);
 }
 
-int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, uint16_t *pprogram_number)
+int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, char **pprogram)
 {
         char name[32];
         sprintf(name, "/tuner%u/program", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, pprogram, NULL);
+}
 
-        char *program_str;
-        int ret = hdhomerun_control_get(hd->cs, name, &program_str, 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);
         if (ret <= 0) {
                 return ret;
         }
 
-        *pprogram_number = (uint16_t)atol(program_str);
+        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;
         return 1;
 }
 
-int hdhomerun_device_get_tuner_target(struct hdhomerun_device_t *hd, char **ptarget)
+int hdhomerun_device_get_tuner_lockkey_owner(struct hdhomerun_device_t *hd, char **powner)
 {
         char name[32];
-        sprintf(name, "/tuner%u/target", hd->tuner);
-        return hdhomerun_control_get(hd->cs, name, ptarget, NULL);
+        sprintf(name, "/tuner%u/lockkey", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, powner, NULL);
 }
 
 int hdhomerun_device_get_ir_target(struct hdhomerun_device_t *hd, char **ptarget)
@@ -178 +503 @@
         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;
@@ -206 +536 @@
 {
         char name[32];
         sprintf(name, "/tuner%u/channel", hd->tuner);
-        return hdhomerun_control_set(hd->cs, name, channel, NULL, NULL);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, channel, hd->lockkey, 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(hd->cs, name, channelmap, NULL, NULL);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, channelmap, hd->lockkey, 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(hd->cs, name, filter, NULL, NULL);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, filter, hd->lockkey, NULL, NULL);
 }
 
-int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, uint16_t program_number)
+static int hdhomerun_device_set_tuner_filter_by_array_append(char **pptr, char *end, uint16_t range_begin, uint16_t range_end)
 {
-        char name[32], value[32];
+        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);
+}
+
+int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, const char *program)
+{
+        char name[32];
         sprintf(name, "/tuner%u/program", hd->tuner);
-        sprintf(value, "%u", program_number);
-        return hdhomerun_control_set(hd->cs, name, value, NULL, NULL);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, program, hd->lockkey, NULL, NULL);
 }
 
-int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, char *target)
+int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, const char *target)
 {
         char name[32];
         sprintf(name, "/tuner%u/target", hd->tuner);
-        return hdhomerun_control_set(hd->cs, name, target, NULL, NULL);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, target, hd->lockkey, NULL, NULL);
 }
 
-static int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd)
+int hdhomerun_device_set_tuner_target_to_local_protocol(struct hdhomerun_device_t *hd, const char *protocol)
 {
+        /* 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, "%u.%u.%u.%u:%u",
+        sprintf(target, "%s://%u.%u.%u.%u:%u",
+                protocol,
                 (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
@@ -252 +657 @@
         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);
@@ -264 +679 @@
 
 int hdhomerun_device_set_var(struct hdhomerun_device_t *hd, const char *name, const char *value, char **pvalue, char **perror)
 {
-        return hdhomerun_control_set(hd->cs, name, value, pvalue, perror);
+        return hdhomerun_control_set_with_lockkey(hd->cs, name, value, hd->lockkey, pvalue, perror);
 }
 
-int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd)
+int hdhomerun_device_tuner_lockkey_request(struct hdhomerun_device_t *hd, char **perror)
 {
-        /* Create video socket. */
-        hdhomerun_device_get_video_sock(hd);
-        if (!hd->vs) {
-                return -1;
+        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;
+}
+
+int hdhomerun_device_wait_for_lock(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status)
+{
+        /* 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);
+        }
+}
+
+int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd)
+{
         /* Set target. */
-        int ret = hdhomerun_device_set_tuner_target_to_local(hd);
+        int ret = hdhomerun_device_stream_refresh_target(hd);
         if (ret <= 0) {
                 return ret;
         }
 
         /* Flush video buffer. */
-        usleep(64000);
+        msleep(64);
         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;
@@ -306 +862 @@
                 return -1;
         }
 
-        if (version >= 20061213) {
-                return 1;
+        if (version < 20070219) {
+                return 0;
         }
 
-        return 0;
+        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;
+}
+
 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);
+}

libs/libmythtv/hdhomerun/hdhomerun_channels.h

@@ +1 @@
+/*
+ * hdhomerun_channels.h
+ *
+ * Copyright © 2007-2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct hdhomerun_channel_entry_t;
+struct hdhomerun_channel_list_t;
+
+extern LIBTYPE const char *hdhomerun_channelmap_convert_countrycode_to_channelmap_prefix(const char *countrycode);
+extern LIBTYPE const char *hdhomerun_channelmap_get_channelmap_scan_group(const char *channelmap);
+
+extern LIBTYPE uint8_t hdhomerun_channel_entry_channel_number(struct hdhomerun_channel_entry_t *entry);
+extern LIBTYPE uint32_t hdhomerun_channel_entry_frequency(struct hdhomerun_channel_entry_t *entry);
+extern LIBTYPE const char *hdhomerun_channel_entry_name(struct hdhomerun_channel_entry_t *entry);
+
+extern LIBTYPE struct hdhomerun_channel_list_t *hdhomerun_channel_list_create(const char *channelmap);
+extern LIBTYPE void hdhomerun_channel_list_destroy(struct hdhomerun_channel_list_t *channel_list);
+
+extern LIBTYPE struct hdhomerun_channel_entry_t *hdhomerun_channel_list_first(struct hdhomerun_channel_list_t *channel_list);
+extern LIBTYPE struct hdhomerun_channel_entry_t *hdhomerun_channel_list_last(struct hdhomerun_channel_list_t *channel_list);
+extern LIBTYPE struct hdhomerun_channel_entry_t *hdhomerun_channel_list_next(struct hdhomerun_channel_list_t *channel_list, struct hdhomerun_channel_entry_t *entry);
+extern LIBTYPE struct hdhomerun_channel_entry_t *hdhomerun_channel_list_prev(struct hdhomerun_channel_list_t *channel_list, struct hdhomerun_channel_entry_t *entry);
+extern LIBTYPE uint32_t hdhomerun_channel_list_total_count(struct hdhomerun_channel_list_t *channel_list);
+extern LIBTYPE uint32_t hdhomerun_channel_list_frequency_count(struct hdhomerun_channel_list_t *channel_list);
+
+extern LIBTYPE uint32_t hdhomerun_channel_frequency_truncate(uint32_t frequency);
+extern LIBTYPE uint32_t hdhomerun_channel_number_to_frequency(struct hdhomerun_channel_list_t *channel_list, uint8_t channel_number);
+extern LIBTYPE uint8_t hdhomerun_channel_frequency_to_number(struct hdhomerun_channel_list_t *channel_list, uint32_t frequency);
+
+#ifdef __cplusplus
+}
+#endif

libs/libmythtv/hdhomerun/hdhomerun_os_windows.h

@@ +1 @@
+/*
+ * hdhomerun_os_windows.h
+ *
+ * Copyright © 2006-2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+#define _WINSOCKAPI_
+#include <windows.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <wspiapi.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <signal.h>
+#include <time.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+
+#if defined(DLL_IMPORT)
+#define LIBTYPE __declspec( dllexport )
+#elif  defined(DLL_EXPORT)
+#define LIBTYPE __declspec( dllimport )
+#else
+#define LIBTYPE
+#endif
+
+typedef int bool_t;
+typedef signed __int8 int8_t;
+typedef signed __int16 int16_t;
+typedef signed __int32 int32_t;
+typedef signed __int64 int64_t;
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+typedef HANDLE pthread_t;
+typedef HANDLE pthread_mutex_t;
+
+#define socklen_t int
+#define close closesocket
+#define sock_getlasterror WSAGetLastError()
+#define sock_getlasterror_socktimeout (WSAGetLastError() == WSAETIMEDOUT)
+#define va_copy(x, y) x = y
+#define atoll _atoi64
+#define strdup _strdup
+#define strcasecmp _stricmp
+#define snprintf _snprintf
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#define THREAD_FUNC_PREFIX DWORD WINAPI
+#define SIGPIPE SIGABRT
+
+static inline int msleep(unsigned int ms)
+{
+        Sleep(ms);
+        return 0;
+}
+
+static inline int sleep(unsigned int sec)
+{
+        Sleep(sec * 1000);
+        return 0;
+}
+
+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));
+}
+
+static inline int pthread_create(pthread_t *tid, void *attr, LPTHREAD_START_ROUTINE start, void *arg)
+{
+        *tid = CreateThread(NULL, 0, start, arg, 0, NULL);
+        if (!*tid) {
+                return (int)GetLastError();
+        }
+        return 0;
+}
+
+static inline int pthread_join(pthread_t tid, void **value_ptr)
+{
+        while (1) {
+                DWORD ExitCode = 0;
+                if (!GetExitCodeThread(tid, &ExitCode)) {
+                        return (int)GetLastError();
+                }
+                if (ExitCode != STILL_ACTIVE) {
+                        return 0;
+                }
+        }
+}
+
+static inline void pthread_mutex_init(pthread_mutex_t *mutex, void *attr)
+{
+        *mutex = CreateMutex(NULL, FALSE, NULL);
+}
+
+static inline void pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+        WaitForSingleObject(*mutex, INFINITE);
+}
+
+static inline void pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+        ReleaseMutex(*mutex);
+}
+
+/*
+ * 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.
+ */
+static inline void console_vprintf(const char *fmt, va_list ap)
+{
+        UINT cp = GetConsoleOutputCP();
+        SetConsoleOutputCP(CP_UTF8);
+        vprintf(fmt, ap);
+        SetConsoleOutputCP(cp);
+}
+
+static inline void console_printf(const char *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        console_vprintf(fmt, ap);
+        va_end(ap);
+}

libs/libmythtv/hdhomerun/hdhomerun_pkt.h

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 #ifdef __cplusplus
 extern "C" {
@@ -110 +122 @@
 #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
@@ -121 +136 @@
 #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
@@ -129 +145 @@
 
 #define HDHOMERUN_MIN_PEEK_LENGTH 4
 
-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);
+struct hdhomerun_pkt_t {
+        uint8_t *pos;
+        uint8_t *start;
+        uint8_t *end;
+        uint8_t *limit;
+        uint8_t buffer[3074];
+};
 
-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 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 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);
+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);
+
 #ifdef __cplusplus
 }
 #endif
-

libs/libmythtv/hdhomerun/hdhomerun_device.h

@@ -1 +1 @@
 /*
  * hdhomerun_device.h
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2008 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
 #ifdef __cplusplus
@@ -26 +38 @@
 #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)
 
-struct hdhomerun_device_t;
+#define HDHOMERUN_STATUS_COLOR_NEUTRAL  0xFFFFFFFF
+#define HDHOMERUN_STATUS_COLOR_RED              0xFFFF0000
+#define HDHOMERUN_STATUS_COLOR_YELLOW   0xFFFFFF00
+#define HDHOMERUN_STATUS_COLOR_GREEN    0xFF00C000
 
-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;
-};
+#define HDHOMERUN_TARGET_PROTOCOL_UDP "udp"
+#define HDHOMERUN_TARGET_PROTOCOL_RTP "rtp"
 
 /*
  * Create a device object.
@@ -53 +62 @@
  * 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 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);
+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 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);
+
+/*
  * Get the local machine IP address used when communicating with the device.
  *
  * This function is useful for determining the IP address to use with set target commands.
  *
  * Returns 32-bit IP address with native endianness, or 0 on error.
  */
-extern uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd);
+extern LIBTYPE uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd);
 
 /*
  * Get operations.
@@ -82 +118 @@
  * Returns 0 if the operation was rejected.
  * Returns -1 if a communication error occurred.
  */
-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);
+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);
+
 /*
  * Set operations.
  *
@@ -101 +146 @@
  * Returns 0 if the operation was rejected.
  * Returns -1 if a communication error occurred.
  */
-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);
+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);
 
 /*
  * Get/set a named control variable on the device.
@@ -125 +174 @@
  * Returns 0 if the operation was rejected (pvalue NULL, perror set).
  * Returns -1 if a communication error occurs.
  */
-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);
+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);
+
+/*
  * Stream a filtered program or the unfiltered stream.
  *
  * The hdhomerun_device_stream_start function initializes the process and tells the device to start streamin data.
@@ -144 +227 @@
  *
  * The hdhomerun_device_stream_stop function tells the device to stop streaming data.
  */
-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);
+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);
+
+/*
  * Check that the device is running the recommended firmware.
  *
  * uint32_t features: Reserved for future use. Set to zero.
@@ -157 +250 @@
  * Returns 0 if th firmware does not meet the minimum requriements for all operations.
  * Returns -1 if an error occurs.
  */
-extern int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features);
+extern LIBTYPE int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features);
 
 /*
  * Upload new firmware to the device.
@@ -168 +261 @@
  * Returns 0 if the upload was rejected.
  * Returns -1 if an error occurs.
  */
-extern int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file);
+extern LIBTYPE int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file);
 
 /*
  * Low level accessor functions. 
  */
-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);
+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);
+
 #ifdef __cplusplus
 }
 #endif

libs/libmythtv/hdhomerun/hdhomerun_config.c

@@ -1 +1 @@
 /*
  * hdhomerun_config.c
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2008 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
 #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;
@@ -31 +53 @@
         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> <starting channel>\n", appname);
+        printf("\t%s <id> scan <tuner> [<filename>]\n", appname);
+        printf("\t%s <id> save <tuner> <filename>\n", appname);
         printf("\t%s <id> upgrade <filename>\n", appname);
         return -1;
 }
@@ -68 +91 @@
         return FALSE;
 }
 
-static int discover_print(void)
+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)
+{
+        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(HDHOMERUN_DEVICE_TYPE_TUNER, result_list, 64);
+        int count = hdhomerun_discover_find_devices_custom(target_ip, HDHOMERUN_DEVICE_TYPE_TUNER, HDHOMERUN_DEVICE_ID_WILDCARD, result_list, 64);
         if (count < 0) {
                 fprintf(stderr, "error sending discover request\n");
                 return -1;
@@ -94 +136 @@
         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;
@@ -138 +154 @@
         return 1;
 }
 
-static int cmd_set(const char *item, const char *value)
+static int cmd_set_internal(const char *item, const char *value)
 {
         char *ret_error;
         if (hdhomerun_device_set_var(hd, item, value, NULL, &ret_error) < 0) {
@@ -154 +170 @@
         return 1;
 }
 
-static int cmd_streaminfo(const char *tuner_str)
+static int cmd_set(const char *item, const char *value)
 {
-        fprintf(stderr, "streaminfo: use \"get /tuner<n>/streaminfo\"\n");
-        return -1;
+        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 int cmd_scan(const char *tuner_str, const char *start_value)
+static void cmd_scan_printf(FILE *fp, const char *fmt, ...)
 {
-        unsigned int tuner;
-        if (sscanf(tuner_str, "%u", &tuner) != 1) {
-                fprintf(stderr, "invalid tuner number\n");
-                return -1;
+        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);
         }
 
-        hdhomerun_device_set_tuner(hd, tuner);
+        vprintf(fmt, ap);
+        fflush(stdout);
 
-        char channel_str[64];
-        strncpy(channel_str, start_value, sizeof(channel_str));
-        channel_str[sizeof(channel_str) - 8] = 0;
+        va_end(ap);
+}
 
-        char *channel_number_ptr = strrchr(channel_str, ':');
-        if (!channel_number_ptr) {
-                channel_number_ptr = channel_str;
-        } else {
-                channel_number_ptr++;
+static int cmd_scan(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;
         }
 
-        unsigned int channel_number = atol(channel_number_ptr);
-        if (channel_number == 0) {
-                fprintf(stderr, "invalid starting channel\n");
+        char *channelmap;
+        if (hdhomerun_device_get_tuner_channelmap(hd, &channelmap) <= 0) {
+                fprintf(stderr, "failed to query channelmap from device\n");
                 return -1;
         }
 
-        /* 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");
+        const char *channelmap_scan_group = hdhomerun_channelmap_get_channelmap_scan_group(channelmap);
+        if (!channelmap_scan_group) {
+                fprintf(stderr, "unknown channelmap '%s'\n", channelmap);
                 return -1;
         }
-        if (ret == 0) {
-                fprintf(stderr, "invalid starting channel\n");
+
+        if (hdhomerun_device_channelscan_init(hd, channelmap_scan_group) <= 0) {
+                fprintf(stderr, "failed to initialize channel scan\n");
                 return -1;
         }
 
-        while (1) {
-                /* Update channel value */
-                sprintf(channel_number_ptr, "%u", channel_number);
-
-                /* Set channel. */
-                ret = hdhomerun_device_set_tuner_channel(hd, channel_str);
-                if (ret < 0) {
-                        fprintf(stderr, "communication error sending request to hdhomerun device\n");
+        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) {
-                        return 0;
+        }
+
+        int ret;
+        while (1) {
+                struct hdhomerun_channelscan_result_t result;
+                ret = hdhomerun_device_channelscan_advance(hd, &result);
+                if (ret <= 0) {
+                        break;
                 }
 
-                /* Wait 1.5s for lock (qam auto is the slowest to lock). */
-                usleep(HDHOMERUN_DEVICE_MAX_TUNE_TO_LOCK_TIME * 1000);
+                cmd_scan_printf(fp, "SCANNING: %lu (%s)\n",
+                        result.frequency, result.channel_str
+                );
 
-                /* 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;
+                ret = hdhomerun_device_channelscan_detect(hd, &result);
+                if (ret <= 0) {
+                        break;
                 }
 
-                /* If no signal then advance to next channel. */
-                if (status.signal_strength == 0) {
-                        printf("%s: no signal\n", channel_str);
-                        channel_number++;
-                        continue;
+                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
+                );
+
+                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);
                 }
+        }
 
-                /* Wait for 2s. */
-                usleep(HDHOMERUN_DEVICE_MAX_LOCK_TO_DATA_TIME * 1000);
+        if (fp) {
+                fclose(fp);
+        }
+        if (ret < 0) {
+                fprintf(stderr, "communication error sending request to hdhomerun device\n");
+        }
+        return ret;
+}
 
-                /* 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");
+static bool_t cmd_saving = FALSE;
+
+static void cmd_save_abort(int arg)
+{
+        cmd_saving = FALSE;
+}
+
+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;
+        }
+
+        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);
                         return -1;
                 }
-                if (status.signal_strength == 0) {
-                        printf("%s: no signal\n", channel_str);
-                        channel_number++;
+        }
+
+        int ret = hdhomerun_device_stream_start(hd);
+        if (ret <= 0) {
+                fprintf(stderr, "unable to start stream\n");
+                return ret;
+        }
+
+        signal(SIGINT, cmd_save_abort);
+        signal(SIGPIPE, cmd_save_abort);
+
+        struct hdhomerun_video_stats_t stats_old, stats_cur;
+        hdhomerun_device_get_video_stats(hd, &stats_old);
+
+        uint64_t next_progress = getcurrenttime() + 1000;
+
+        cmd_saving = TRUE;
+        while (cmd_saving) {
+                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);
                         continue;
                 }
-                printf("%s: ss=%u snq=%u seq=%u\n", channel_str, status.signal_strength, status.signal_to_noise_quality, status.symbol_error_quality);
 
-                /* Detect sub channels. */
-                usleep(4 * 1000000);
-                char *streaminfo;
-                if (hdhomerun_device_get_tuner_streaminfo(hd, &streaminfo) <= 0) {
-                        channel_number++;
-                        continue;
+                if (fp) {
+                        if (fwrite(ptr, 1, actual_size, fp) != actual_size) {
+                                fprintf(stderr, "error writing output\n");
+                                return -1;
+                        }
                 }
-                while (1) {
-                        char *end = strchr(streaminfo, '\n');
-                        if (!end) {
-                                break;
+
+                if (loop_start_time >= next_progress) {
+                        next_progress += 1000;
+                        if (loop_start_time >= next_progress) {
+                                next_progress = loop_start_time + 1000;
                         }
 
-                        *end++ = 0;
-                        printf("program %s\n", streaminfo);
+                        hdhomerun_device_get_video_stats(hd, &stats_cur);
 
-                        streaminfo = end;
+                        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, ".");
+                        }
+
+                        stats_old = stats_cur;
+                        fflush(stderr);
                 }
 
-                /* Advance to next channel. */
-                channel_number++;
+                int32_t delay = 64 - (int32_t)(getcurrenttime() - loop_start_time);
+                if (delay <= 0) {
+                        continue;
+                }
+
+                msleep(delay);
         }
+
+        if (fp) {
+                fclose(fp);
+        }
+
+        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)
@@ -276 +412 @@
                 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("upgrade complete\n");
+        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);
         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 = min(eol_r, 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) {
@@ -294 +509 @@
 
         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();
@@ -308 +534 @@
                 return cmd_set(argv[0], argv[1]);
         }
 
-        if (contains(cmd, "streaminfo")) {
+        if (contains(cmd, "scan")) {
                 if (argc < 1) {
                         return help();
                 }
-                return cmd_streaminfo(argv[0]);
+                if (argc < 2) {
+                        return cmd_scan(argv[0], NULL);
+                } else {
+                        return cmd_scan(argv[0], argv[1]);
+                }
         }
 
-        if (contains(cmd, "scan")) {
+        if (contains(cmd, "save")) {
                 if (argc < 2) {
                         return help();
                 }
-                return cmd_scan(argv[0], argv[1]);
+                return cmd_save(argv[0], argv[1]);
         }
 
         if (contains(cmd, "upgrade")) {
@@ -329 +559 @@
                 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__)
-        //Start pthreads
-        pthread_win32_process_attach_np();
-
-        // Start WinSock
+        /* Initialize network socket support. */
         WORD wVersionRequested = MAKEWORD(2, 0);
         WSADATA wsaData;
         WSAStartup(wVersionRequested, &wsaData);
@@ -357 +588 @@
                 return help();
         }
         if (contains(id_str, "discover")) {
-                return discover_print();
+                if (argc < 1) {
+                        return discover_print(NULL);
+                } else {
+                        return discover_print(argv[0]);
+                }
         }
 
-        /* Device ID. */
-        uint32_t device_id, device_ip;
-        if (!parse_device_id_str(id_str, &device_id, &device_ip)) {
-                return -1;
-        }
-
         /* Device object. */
-        hd = hdhomerun_device_create(device_id, device_ip, 0);
+        hd = hdhomerun_device_create_from_str(id_str, NULL);
         if (!hd) {
-                fprintf(stderr, "unable to create device\n");
+                fprintf(stderr, "invalid device id: %s\n", id_str);
                 return -1;
         }
 
-        /* Connect to device and check firmware version. */
-        int ret = hdhomerun_device_firmware_version_check(hd, 0);
-        if (ret < 0) {
+        /* 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);
+        }
+
+        /* Connect to device and check model. */
+        const char *model = hdhomerun_device_get_model_str(hd);
+        if (!model) {
                 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. */
-        ret = main_cmd(argc, argv);
+        int ret = main_cmd(argc, argv);
 
         /* Cleanup. */
         hdhomerun_device_destroy(hd);

libs/libmythtv/hdhomerun/hdhomerun_video.c

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
-#include "hdhomerun_video.h"
+#include "hdhomerun.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 void *hdhomerun_video_thread(void *arg);
+static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg);
 
-static bool_t hdhomerun_video_bind_sock_internal(struct hdhomerun_video_sock_t *vs, uint16_t listen_port)
+struct hdhomerun_video_sock_t *hdhomerun_video_create(uint16_t listen_port, size_t buffer_size, struct hdhomerun_debug_t *dbg)
 {
-        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) {
-                free(vs);
-                return NULL;
+                hdhomerun_debug_printf(dbg, "hdhomerun_video_create: invalid buffer size (%lu bytes)\n", (unsigned long)buffer_size);
+                goto error;
         }
         vs->buffer_size += VIDEO_DATA_PACKET_SIZE;
 
         /* Create buffer. */
         vs->buffer = (uint8_t *)malloc(vs->buffer_size);
         if (!vs->buffer) {
-                free(vs);
-                return NULL;
+                hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate buffer (%lu bytes)\n", (unsigned long)vs->buffer_size);
+                goto error;
         }
         
         /* Create socket. */
         vs->sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
         if (vs->sock == -1) {
-                free(vs->buffer);
-                free(vs);
-                return NULL;
+                hdhomerun_debug_printf(dbg, "hdhomerun_video_create: failed to allocate socket\n");
+                goto error;
         }
 
         /* Expand socket buffer size. */
@@ -112 +101 @@
         setsocktimeout(vs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
 
         /* Bind socket. */
-        if (!hdhomerun_video_bind_sock(vs, listen_port)) {
-                hdhomerun_video_destroy(vs);
-                return NULL;
+        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;
         }
 
         /* Start thread. */
-        if (pthread_create(&vs->thread, NULL, &hdhomerun_video_thread, vs) != 0) {
-                hdhomerun_video_destroy(vs);
-                return NULL;
+        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;
         }
-        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)
 {
-        if (vs->running) {
-                vs->terminate = 1;
-                pthread_join(vs->thread, NULL);
-        }
+        vs->terminate = TRUE;
+        pthread_join(vs->thread, NULL);
+
         close(vs->sock);
         free(vs->buffer);
+
         free(vs);
 }
 
@@ -144 +147 @@
         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);
 }
 
-int hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs)
+static void hdhomerun_video_stats_ts_pkt(struct hdhomerun_video_sock_t *vs, uint8_t *ptr)
 {
-        return vs->sock;
+        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_thread(void *arg)
+static void hdhomerun_video_parse_rtp(struct hdhomerun_video_sock_t *vs, struct hdhomerun_pkt_t *pkt)
 {
+        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;
+}
+
+static THREAD_FUNC_PREFIX hdhomerun_video_thread_execute(void *arg)
+{
         struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)arg;
+        struct hdhomerun_pkt_t pkt_inst;
 
         while (!vs->terminate) {
-                size_t head = vs->head;
+                struct hdhomerun_pkt_t *pkt = &pkt_inst;
+                hdhomerun_pkt_reset(pkt);
 
                 /* Receive. */
-                int length = recv(vs->sock, (char *)vs->buffer + head, VIDEO_DATA_PACKET_SIZE, 0);
+                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);
+                }
+
                 if (length != VIDEO_DATA_PACKET_SIZE) {
                         if (length > 0) {
                                 /* Data received but not valid - ignore. */
@@ -172 +235 @@
                                 /* Wait for more data. */
                                 continue;
                         }
-                        vs->terminate = 1;
+                        vs->terminate = TRUE;
                         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) {
@@ -184 +264 @@
 
                 /* 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;
@@ -196 +280 @@
 
 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;
 
@@ -212 +298 @@
         if (head == tail) {
                 vs->advance = 0;
                 *pactual_size = 0;
+                pthread_mutex_unlock(&vs->lock);
                 return NULL;
         }
 
@@ -219 +306 @@
         if (size == 0) {
                 vs->advance = 0;
                 *pactual_size = 0;
+                pthread_mutex_unlock(&vs->lock);
                 return NULL;
         }
 
@@ -233 +321 @@
         }
         vs->advance = size;
         *pactual_size = size;
-        return vs->buffer + tail;
+        uint8_t *result = vs->buffer + tail;
+
+        pthread_mutex_unlock(&vs->lock);
+        return result;
 }
 
 void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs)
 {
-        /* Atomic update of tail. */
+        pthread_mutex_lock(&vs->lock);
+
         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);
+}

libs/libmythtv/hdhomerun/hdhomerun_os_posix.h

@@ +1 @@
+/*
+ * hdhomerun_os_posix.h
+ *
+ * Copyright © 2006-2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+#define _FILE_OFFSET_BITS 64
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <pthread.h>
+
+typedef int bool_t;
+
+#define LIBTYPE
+#define sock_getlasterror errno
+#define sock_getlasterror_socktimeout (errno == EAGAIN)
+#define console_vprintf vprintf
+#define console_printf printf
+#define THREAD_FUNC_PREFIX void *
+
+static inline int msleep(unsigned int ms)
+{
+        usleep(ms * 1000);
+        return 0;
+}
+
+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));
+}
+
+#define min(a,b) (((a)<(b))?(a):(b))
+#define max(a,b) (((a)>(b))?(a):(b))
+

libs/libmythtv/hdhomerun/hdhomerun_types.h

@@ +1 @@
+/*
+ * hdhomerun_types.h
+ *
+ * Copyright © 2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+struct hdhomerun_device_t;
+
+struct hdhomerun_tuner_status_t {
+        char channel[32];
+        char lock_str[32];
+        bool_t signal_present;
+        bool_t lock_supported;
+        bool_t lock_unsupported;
+        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;
+};
+
+struct hdhomerun_channelscan_program_t {
+        char program_str[64];
+        uint16_t program_number;
+        uint16_t virtual_major;
+        uint16_t virtual_minor;
+        uint16_t type;
+        char name[32];
+};
+
+#define HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT 64
+
+struct hdhomerun_channelscan_result_t {
+        char channel_str[64];
+        uint32_t channelmap;
+        uint32_t frequency;
+        struct hdhomerun_tuner_status_t status;
+        int program_count;
+        struct hdhomerun_channelscan_program_t programs[HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT];
+        uint32_t pat_crc;
+};
+
+struct hdhomerun_plotsample_t {
+        int16_t real;
+        int16_t imag;
+};

libs/libmythtv/hdhomerun/hdhomerun_video.h

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 #ifdef __cplusplus
 extern "C" {
@@ -23 +35 @@
 
 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 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);
+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);
 
 /*
  * Get the port the socket is listening on.
  *
  * Returns 16-bit port with native endianness, or 0 on error.
  */
-extern uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs);
+extern LIBTYPE 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.
  *
  * size_t max_size: The maximum amount of data to be returned.
@@ -69 +87 @@
  * 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 uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size);
+extern LIBTYPE uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size);
 
 /*
  * Flush the buffer.
  */
-extern void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs);
+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);
+
 #ifdef __cplusplus
 }
 #endif

libs/libmythtv/hdhomerun/hdhomerun_channelscan.c

@@ +1 @@
+/*
+ * hdhomerun_channelscan.c
+ *
+ * Copyright © 2007-2008 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, 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.
+ */
+
+#include "hdhomerun.h"
+
+struct hdhomerun_channelscan_t {
+        struct hdhomerun_device_t *hd;
+        uint32_t scanned_channels;
+        struct hdhomerun_channel_list_t *channel_list;  
+        struct hdhomerun_channel_entry_t *next_channel;
+};
+
+struct hdhomerun_channelscan_t *channelscan_create(struct hdhomerun_device_t *hd, const char *channelmap)
+{
+        struct hdhomerun_channelscan_t *scan = (struct hdhomerun_channelscan_t *)calloc(1, sizeof(struct hdhomerun_channelscan_t));
+        if (!scan) {
+                return NULL;
+        }
+
+        scan->hd = hd;
+
+        scan->channel_list = hdhomerun_channel_list_create(channelmap);
+        if (!scan->channel_list) {
+                free(scan);
+                return NULL;
+        }
+
+        scan->next_channel = hdhomerun_channel_list_last(scan->channel_list);
+        return scan;
+}
+
+void channelscan_destroy(struct hdhomerun_channelscan_t *scan)
+{
+        free(scan);
+}
+
+static int channelscan_find_lock(struct hdhomerun_channelscan_t *scan, uint32_t frequency, struct hdhomerun_channelscan_result_t *result)
+{
+        /* Set channel. */
+        char channel_str[64];
+        sprintf(channel_str, "auto:%ld", (unsigned long)frequency);
+
+        int ret = hdhomerun_device_set_tuner_channel(scan->hd, channel_str);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        /* Wait for lock. */
+        ret = hdhomerun_device_wait_for_lock(scan->hd, &result->status);
+        if (ret <= 0) {
+                return ret;
+        }
+        if (!result->status.lock_supported) {
+                return 1;
+        }
+
+        /* Wait for symbol quality = 100%. */
+        uint64_t timeout = getcurrenttime() + 5000;
+        while (1) {
+                ret = hdhomerun_device_get_tuner_status(scan->hd, NULL, &result->status);
+                if (ret <= 0) {
+                        return ret;
+                }
+
+                if (result->status.symbol_error_quality == 100) {
+                        return 1;
+                }
+
+                if (getcurrenttime() >= timeout) {
+                        return 1;
+                }
+
+                msleep(250);
+        }
+}
+
+static void channelscan_extract_name(struct hdhomerun_channelscan_program_t *program, const char *line)
+{
+        /* Find start of name. */
+        const char *start = strchr(line, ' ');
+        if (!start) {
+                return;
+        }
+        start++;
+
+        start = strchr(start, ' ');
+        if (!start) {
+                return;
+        }
+        start++;
+
+        /* Find end of name. */
+        const char *end = strstr(start, " (");
+        if (!end) {
+                end = strchr(line, 0);
+        }
+
+        if (end <= start) {
+                return;
+        }
+
+        /* Extract name. */
+        size_t length = (size_t)(end - start);
+        if (length > sizeof(program->name) - 1) {
+                length = sizeof(program->name) - 1;
+        }
+
+        strncpy(program->name, start, length);
+        program->name[length] = 0;
+}
+
+static int channelscan_detect_programs(struct hdhomerun_channelscan_t *scan, struct hdhomerun_channelscan_result_t *result, bool_t *pchanged, bool_t *pincomplete)
+{
+        *pchanged = FALSE;
+        *pincomplete = FALSE;
+
+        char *streaminfo;
+        int ret = hdhomerun_device_get_tuner_streaminfo(scan->hd, &streaminfo);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        char *line = streaminfo;
+        int program_count = 0;
+
+        while (1) {
+                char *end = strchr(line, '\n');
+                if (!end) {
+                        break;
+                }
+
+                *end = 0;
+
+                unsigned long pat_crc;
+                if (sscanf(line, "crc=0x%lx", &pat_crc) == 1) {
+                        result->pat_crc = pat_crc;
+                        continue;
+                }
+
+                struct hdhomerun_channelscan_program_t program;
+                memset(&program, 0, sizeof(program));
+
+                strncpy(program.program_str, line, sizeof(program.program_str));
+                program.program_str[sizeof(program.program_str) - 1] = 0;
+
+                unsigned int program_number;
+                unsigned int virtual_major, virtual_minor;
+                if (sscanf(line, "%u: %u.%u", &program_number, &virtual_major, &virtual_minor) != 3) {
+                        if (sscanf(line, "%u: %u", &program_number, &virtual_major) != 2) {
+                                continue;
+                        }
+                        virtual_minor = 0;
+                }
+
+                program.program_number = program_number;
+                program.virtual_major = virtual_major;
+                program.virtual_minor = virtual_minor;
+
+                channelscan_extract_name(&program, line);
+
+                if (strstr(line, "(control)")) {
+                        program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_CONTROL;
+                } else if (strstr(line, "(encrypted)")) {
+                        program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_ENCRYPTED;
+                } else if (strstr(line, "(no data)")) {
+                        program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NODATA;
+                        *pincomplete = TRUE;
+                } else {
+                        program.type = HDHOMERUN_CHANNELSCAN_PROGRAM_NORMAL;
+                        if ((program.virtual_major == 0) || (program.name[0] == 0)) {
+                                *pincomplete = TRUE;
+                        }
+                }
+
+                if (memcmp(&result->programs[program_count], &program, sizeof(program)) != 0) {
+                        memcpy(&result->programs[program_count], &program, sizeof(program));
+                        *pchanged = TRUE;
+                }
+
+                program_count++;
+                if (program_count >= HDHOMERUN_CHANNELSCAN_MAX_PROGRAM_COUNT) {
+                        break;
+                }
+
+                line = end + 1;
+        }
+
+        if (program_count == 0) {
+                *pincomplete = TRUE;
+        }
+        if (result->program_count != program_count) {
+                result->program_count = program_count;
+                *pchanged = TRUE;
+        }
+
+        return 1;
+}
+
+int channelscan_advance(struct hdhomerun_channelscan_t *scan, struct hdhomerun_channelscan_result_t *result)
+{
+        memset(result, 0, sizeof(struct hdhomerun_channelscan_result_t));
+
+        struct hdhomerun_channel_entry_t *entry = scan->next_channel;
+        if (!entry) {
+                return 0;
+        }
+
+        /* Combine channels with same frequency. */
+        result->frequency = hdhomerun_channel_entry_frequency(entry);
+        strncpy(result->channel_str, hdhomerun_channel_entry_name(entry), sizeof(result->channel_str) - 1);
+        result->channel_str[sizeof(result->channel_str) - 1] = 0;
+
+        while (1) {
+                entry = hdhomerun_channel_list_prev(scan->channel_list, entry);
+                if (!entry) {
+                        scan->next_channel = NULL;
+                        break;
+                }
+
+                if (hdhomerun_channel_entry_frequency(entry) != result->frequency) {
+                        scan->next_channel = entry;
+                        break;
+                }
+
+                char *ptr = strchr(result->channel_str, 0);
+                sprintf(ptr, ", %s", hdhomerun_channel_entry_name(entry));
+        }
+
+        return 1;
+}
+
+int channelscan_detect(struct hdhomerun_channelscan_t *scan, struct hdhomerun_channelscan_result_t *result)
+{
+        scan->scanned_channels++;
+
+        /* Find lock. */
+        int ret = channelscan_find_lock(scan, result->frequency, result);
+        if (ret <= 0) {
+                return ret;
+        }
+        if (!result->status.lock_supported) {
+                return 1;
+        }
+
+        /* Detect programs. */
+        result->program_count = 0;
+
+        uint64_t timeout = getcurrenttime() + 10000;
+        uint64_t complete_time = getcurrenttime() + 2000;
+        while (1) {
+                bool_t changed, incomplete;
+                ret = channelscan_detect_programs(scan, result, &changed, &incomplete);
+                if (ret <= 0) {
+                        return ret;
+                }
+
+                if (changed) {
+                        complete_time = getcurrenttime() + 2000;
+                }
+
+                if (!incomplete && (getcurrenttime() >= complete_time)) {
+                        return 1;
+                }
+
+                if (getcurrenttime() >= timeout) {
+                        return 1;
+                }
+
+                msleep(250);
+        }
+}
+
+uint8_t channelscan_get_progress(struct hdhomerun_channelscan_t *scan)
+{
+        struct hdhomerun_channel_entry_t *entry = scan->next_channel;
+        if (!entry) {
+                return 100;
+        }
+
+        uint32_t channels_remaining = 1;
+        uint32_t frequency = hdhomerun_channel_entry_frequency(entry);
+
+        while (1) {
+                entry = hdhomerun_channel_list_prev(scan->channel_list, entry);
+                if (!entry) {
+                        break;
+                }
+
+                if (hdhomerun_channel_entry_frequency(entry) != frequency) {
+                        channels_remaining++;
+                        frequency = hdhomerun_channel_entry_frequency(entry);
+                }
+        }
+
+        return scan->scanned_channels * 100 / (scan->scanned_channels + channels_remaining);
+}

libs/libmythtv/hdhomerun/hdhomerun_discover.c

@@ -1 +1 @@
 /*
  * hdhomerun_discover.c
  *
- * Copyright © 2006 Silicondust Engineering Ltd. <www.silicondust.com>.
+ * Copyright © 2006-2007 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
-#include "hdhomerun_discover.h"
+#include "hdhomerun.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
 
-// for OSX
-#include <unistd.h>    // execl, pipe, sysconf
-#include <sys/types.h> // waitpid
-#include <sys/wait.h>  // waitpid
+#include <sys/param.h>  // Defines BSD on FreeBSD and Mac OS X
+#if defined(__linux__) || defined(__APPLE__) || defined(BSD)
+#  include <ifaddrs.h>
+#  define USE_IFADDRS 1
+#  include <sys/select.h>
+#endif
 
+#define HDHOMERUN_DISOCVER_MAX_SOCK_COUNT 16
+
 struct hdhomerun_discover_sock_t {
         int sock;
+        uint32_t local_ip;
+        uint32_t subnet_mask;
 };
 
-static struct hdhomerun_discover_sock_t *hdhomerun_discover_create(void)
+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)
 {
-        struct hdhomerun_discover_sock_t *ds = (struct hdhomerun_discover_sock_t *)malloc(sizeof(struct hdhomerun_discover_sock_t));
-        if (!ds) {
-                return NULL;
+        if (ds->sock_count >= HDHOMERUN_DISOCVER_MAX_SOCK_COUNT) {
+                return FALSE;
         }
-        
+
         /* Create socket. */
-        ds->sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
-        if (ds->sock == -1) {
-                free(ds);
-                return NULL;
+        int sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
+        if (sock == -1) {
+                return FALSE;
         }
 
         /* Set timeouts. */
-        setsocktimeout(ds->sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
-        setsocktimeout(ds->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
+        setsocktimeout(sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
+        setsocktimeout(sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
 
         /* Allow broadcast. */
         int sock_opt = 1;
-        setsockopt(ds->sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt));
+        setsockopt(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(INADDR_ANY);
+        sock_addr.sin_addr.s_addr = htonl(local_ip);
         sock_addr.sin_port = htons(0);
-        if (bind(ds->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                close(ds->sock);
-                free(ds);
-                return NULL;
+        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+                close(sock);
+                return FALSE;
         }
 
-        /* Success. */
-        return ds;
-}
+        /* 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;
 
-static void hdhomerun_discover_destroy(struct hdhomerun_discover_sock_t *ds)
-{
-        close(ds->sock);
-        free(ds);
+        return TRUE;
 }
 
-static int hdhomerun_discover_send_packet(struct hdhomerun_discover_sock_t *ds, uint32_t ip_addr, uint32_t device_type, uint32_t device_id)
+#if defined(USE_IPHLPAPI)
+static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
 {
-        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);
 
@@ -222 +116 @@
         if (Ret != NO_ERROR) {
                 free(pAdapterInfo);
                 if (Ret != ERROR_BUFFER_OVERFLOW) {
-                        return -1;
+                        return;
                 }
                 pAdapterInfo = (IP_ADAPTER_INFO *)malloc(ulOutBufLen); 
                 Ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
                 if (Ret != NO_ERROR) {
                         free(pAdapterInfo);
-                        return -1;
+                        return;
                 }
         }
 
-        unsigned int send_count = 0;
         PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
         while (pAdapter) {
                 IP_ADDR_STRING *pIPAddr = &pAdapter->IpAddressList;
                 while (pIPAddr) {
-                        uint32_t addr = ntohl(inet_addr(pIPAddr->IpAddress.String));
+                        uint32_t local_ip = 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 (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) {
+                        if (local_ip == 0) {
                                 pIPAddr = pIPAddr->Next;
                                 continue;
                         }
 
-                        send_count++;
-
+                        hdhomerun_discover_sock_create(ds, local_ip, mask);
                         pIPAddr = pIPAddr->Next;
                 }
 
@@ -260 +146 @@
         }
 
         free(pAdapterInfo);
-
-        if (send_count == 0) {
-                return -1;
-        }
-        return 0;
 }
 
-#elif defined(__linux__)
+#else
 
-static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id)
+static void hdhomerun_discover_sock_detect(struct hdhomerun_discover_t *ds)
 {
-        FILE *fp = fopen("/proc/net/route", "r");
-        if (!fp) {
-                return -1;
+        int fd = socket(AF_INET, SOCK_DGRAM, 0);
+        if (fd == -1) {
+                return;
         }
 
-        unsigned int send_count = 0;
-        while (1) {
-                char line[256];
-                if (!fgets(line, sizeof(line), fp)) {
-                        break;
-                }
-                line[255] = 0;
+        struct ifconf ifc;
+        uint8_t buf[8192];
+        ifc.ifc_len = sizeof(buf);
+        ifc.ifc_buf = (char *)buf;
 
-                uint32_t dest;
-                uint32_t mask;
-                if (sscanf(line, "%*s %x %*x %*x %*d %*d %*d %x", &dest, &mask) != 2) {
+        memset(buf, 0, sizeof(buf));
+
+        if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
+                close(fd);
+                return;
+        }
+
+        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);
+
+                if (ioctl(fd, SIOCGIFADDR, ifr) != 0) {
                         continue;
                 }
-                dest = ntohl(dest);
-                mask = ntohl(mask);
-                
-                uint32_t broadcast = dest | ~mask;
-
-                if ((broadcast == 0x00000000) || (broadcast == 0xFFFFFFFF)) {
+                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) {
                         continue;
                 }
 
-                if (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) {
+                if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) {
                         continue;
                 }
+                struct sockaddr_in *mask_in = (struct sockaddr_in *)&(ifr->ifr_addr);
+                uint32_t mask = ntohl(mask_in->sin_addr.s_addr);
 
-                send_count++;
+                hdhomerun_discover_sock_create(ds, local_ip, mask);
         }
+}
+#endif
 
-        fclose(fp);
-        if (send_count == 0) {
-                return -1;
+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;
         }
-        return 0;
+
+        /* Create a routable socket. */
+        if (!hdhomerun_discover_sock_create(ds, 0, 0)) {
+                free(ds);
+                return NULL;
+        }
+
+        /* Detect & create local sockets. */
+        hdhomerun_discover_sock_detect(ds);
+
+        /* Success. */
+        return ds;
 }
 
-#else
+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);
+        }
 
-static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id)
+        free(ds);
+}
+
+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)
 {
-        return -1;
+        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;
 }
-#endif
 
-static int hdhomerun_discover_send(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id)
+static bool_t hdhomerun_discover_send_wildcard_ip(struct hdhomerun_discover_t *ds, uint32_t device_type, uint32_t device_id)
 {
-        if (hdhomerun_discover_send_internal(ds, device_type, device_id) < 0) {
-                return hdhomerun_discover_send_packet(ds, 0xFFFFFFFF, device_type, 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);
         }
-        return 0;
+
+        /*
+         * 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);
+        }
+
+        return result;
 }
 
-static int hdhomerun_discover_recv(struct hdhomerun_discover_sock_t *ds, struct hdhomerun_discover_device_t *result)
+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)
 {
-        struct timeval t;
-        t.tv_sec = 0;
-        t.tv_usec = 250000;
+        bool_t result = FALSE;
 
-        fd_set readfds;
-        FD_ZERO(&readfds);
-        FD_SET(ds->sock, &readfds);
+        /*
+         * 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;
+                }
 
-        if (select(ds->sock+1, &readfds, NULL, NULL, &t) < 0) {
-                return -1;
+                result |= hdhomerun_discover_send_internal(ds, dss, target_ip, device_type, device_id);
         }
-        if (!FD_ISSET(ds->sock, &readfds)) {
-                return 0;
+
+        /*
+         * 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);
         }
 
-        uint8_t buffer[1024];
+        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);
+        }
+
+        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);
+
         struct sockaddr_in sock_addr;
+        memset(&sock_addr, 0, sizeof(sock_addr));
         socklen_t sockaddr_size = sizeof(sock_addr);
-        int rx_length = recvfrom(ds->sock, (char *)buffer, sizeof(buffer), 0, (struct sockaddr *)&sock_addr, &sockaddr_size);
+
+        int rx_length = recvfrom(dss->sock, (char *)rx_pkt->end, (int)(rx_pkt->limit - rx_pkt->end), 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;
         }
-        if (rx_length < HDHOMERUN_MIN_PEEK_LENGTH) {
-                return 0;
-        }
+        rx_pkt->end += rx_length;
 
-        size_t length = hdhomerun_peek_packet_length(buffer);
-        if (length > (size_t)rx_length) {
+        uint16_t type;
+        if (hdhomerun_pkt_open_frame(rx_pkt, &type) <= 0) {
                 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;
         }
@@ -372 +345 @@
         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 *value;
-                if (hdhomerun_read_tlv(&ptr, end, &tag, &len, &value) < 0) {
+                uint8_t *next = hdhomerun_pkt_read_tlv(rx_pkt, &tag, &len);
+                if (!next) {
                         break;
                 }
 
@@ -385 +359 @@
                         if (len != 4) {
                                 break;
                         }
-                        result->device_type = hdhomerun_read_u32(&value);
+                        result->device_type = hdhomerun_pkt_read_u32(rx_pkt);
                         break;
+
                 case HDHOMERUN_TAG_DEVICE_ID:
                         if (len != 4) {
                                 break;
                         }
-                        result->device_id = hdhomerun_read_u32(&value);
+                        result->device_id = hdhomerun_pkt_read_u32(rx_pkt);
                         break;
+
                 default:
                         break;
                 }
+
+                rx_pkt->pos = next;
         }
 
         return 1;
 }
 
-static struct hdhomerun_discover_device_t *hdhomerun_discover_find_in_list(struct hdhomerun_discover_device_t result_list[], int count, uint32_t device_id)
+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)
+{
         int index;
         for (index = 0; index < count; index++) {
                 struct hdhomerun_discover_device_t *result = &result_list[index];
-                if (result->device_id == device_id) {
+                if (result->ip_addr == ip_addr) {
                         return result;
                 }
         }
@@ -414 +431 @@
         return NULL;
 }
 
-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)
+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)
 {
         int count = 0;
-
         int attempt;
         for (attempt = 0; attempt < 4; attempt++) {
-                if (hdhomerun_discover_send(ds, device_type, device_id) < 0) {
+                if (!hdhomerun_discover_send(ds, target_ip, device_type, device_id)) {
                         return -1;
                 }
 
@@ -433 +449 @@
                                 return -1;
                         }
                         if (ret == 0) {
-                                break;
+                                continue;
                         }
 
                         /* Filter. */
@@ -449 +465 @@
                         }
 
                         /* Ensure not already in list. */
-                        if (hdhomerun_discover_find_in_list(result_list, count, result->device_id)) {
+                        if (hdhomerun_discover_find_in_list(result_list, count, result->ip_addr)) {
                                 continue;
                         }
 
@@ -464 +480 @@
         return count;
 }
 
-int hdhomerun_discover_find_device(uint32_t device_id, struct hdhomerun_discover_device_t *result)
+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)
 {
-        struct hdhomerun_discover_sock_t *ds = hdhomerun_discover_create();
+        struct hdhomerun_discover_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);
+        int ret = hdhomerun_discover_find_devices_internal(ds, target_ip, device_type, device_id, result_list, max_count);
 
         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_sock_t *ds = hdhomerun_discover_create();
-        if (!ds) {
-                return -1;
-        }
-
-        int ret = hdhomerun_discover_find_devices_internal(ds, device_type, HDHOMERUN_DEVICE_ID_WILDCARD, result_list, max_count);
-
-        hdhomerun_discover_destroy(ds);
-        return ret;
-}
-
 bool_t hdhomerun_discover_validate_device_id(uint32_t device_id)
 {
         static uint32_t lookup_table[16] = {0xA, 0x5, 0xF, 0x6, 0x7, 0xC, 0x1, 0xB, 0x9, 0x2, 0x8, 0xD, 0x4, 0x3, 0xE, 0x0};

libs/libmythtv/hdhomerun/hdhomerun_dhcp.c

@@ +1 @@
+/*
+ * hdhomerun_dhcp.c
+ *
+ * Copyright © 2006-2007 Silicondust Engineering Ltd. <www.silicondust.com>.
+ *
+ * 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.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "hdhomerun.h"
+#include "hdhomerun_dhcp.h"
+
+struct dhcp_hdr_t {
+        uint8_t bootp_message_type;
+        uint8_t hardware_type;
+        uint8_t hardware_address_length;
+        uint8_t hops;
+        uint32_t transaction_id;
+        uint16_t seconds_elapsed;
+        uint16_t bootp_flags;
+        uint32_t client_ip;
+        uint32_t your_ip;
+        uint32_t next_server_ip;
+        uint32_t relay_agent_ip;
+        uint8_t client_mac[16];
+        uint8_t server_host_name[64];
+        uint8_t boot_file_name[128];
+        uint32_t magic_cookie;
+};
+
+struct hdhomerun_dhcp_t {
+        int sock;
+        uint32_t local_address;
+        pthread_t thread;
+        volatile bool_t terminate;
+};
+
+static THREAD_FUNC_PREFIX hdhomerun_dhcp_thread_execute(void *arg);
+
+struct hdhomerun_dhcp_t *hdhomerun_dhcp_create(uint32_t bind_address)
+{
+        if (bind_address != 0) {
+                if ((bind_address & 0xFFFF0000) != 0xA9FE0000) {
+                        return NULL;
+                }
+        }
+
+        /* Create socket. */
+        int sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
+        if (sock == -1) {
+                return NULL;
+        }
+
+        /* Set timeout. */
+        setsocktimeout(sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
+
+        /* Allow broadcast. */
+        int sock_opt = 1;
+        setsockopt(sock, SOL_SOCKET, SO_BROADCAST, (char *)&sock_opt, sizeof(sock_opt));
+
+        /* Allow reuse. */
+        sock_opt = 1;
+        setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (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(bind_address);
+        sock_addr.sin_port = htons(67);
+        if (bind(sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+                close(sock);
+                return NULL;
+        }
+
+        /* Allocate object. */
+        struct hdhomerun_dhcp_t *dhcp = (struct hdhomerun_dhcp_t *)calloc(1, sizeof(struct hdhomerun_dhcp_t));
+        if (!dhcp) {
+                close(sock);
+                return NULL;
+        }
+
+        dhcp->sock = sock;
+
+        if (bind_address != 0) {
+                dhcp->local_address = bind_address;
+        } else {
+                dhcp->local_address = 0xA9FEFFFF;
+        }
+
+        /* Spawn thread. */
+        if (pthread_create(&dhcp->thread, NULL, &hdhomerun_dhcp_thread_execute, dhcp) != 0) {
+                close(sock);
+                free(dhcp);
+                return NULL;
+        }
+
+        /* Success. */
+        return dhcp;
+}
+
+void hdhomerun_dhcp_destroy(struct hdhomerun_dhcp_t *dhcp)
+{
+        dhcp->terminate = TRUE;
+        pthread_join(dhcp->thread, NULL);
+
+        close(dhcp->sock);
+        free(dhcp);
+}
+
+static void hdhomerun_dhcp_send(struct hdhomerun_dhcp_t *dhcp, uint8_t message_type, struct hdhomerun_pkt_t *pkt)
+{
+        pkt->pos = pkt->start;
+        struct dhcp_hdr_t *hdr = (struct dhcp_hdr_t *)pkt->pos;
+        pkt->pos += sizeof(struct dhcp_hdr_t);
+        pkt->end = pkt->pos;
+
+        uint32_t remote_addr = 0xA9FE0000;
+        remote_addr |= (uint32_t)hdr->client_mac[4] << 8;
+        remote_addr |= (uint32_t)hdr->client_mac[5] << 0;
+        if ((remote_addr == 0xA9FE0000) || (remote_addr == 0xA9FEFFFF)) {
+                remote_addr = 0xA9FE8080;
+        }
+
+        hdr->bootp_message_type = 0x02;
+        hdr->your_ip = htonl(remote_addr);
+        hdr->next_server_ip = htonl(0x00000000);
+
+        hdhomerun_pkt_write_u8(pkt, 53);
+        hdhomerun_pkt_write_u8(pkt, 1);
+        hdhomerun_pkt_write_u8(pkt, message_type);
+
+        hdhomerun_pkt_write_u8(pkt, 54);
+        hdhomerun_pkt_write_u8(pkt, 4);
+        hdhomerun_pkt_write_u32(pkt, dhcp->local_address);
+
+        hdhomerun_pkt_write_u8(pkt, 51);
+        hdhomerun_pkt_write_u8(pkt, 4);
+        hdhomerun_pkt_write_u32(pkt, 7*24*60*60);
+
+        hdhomerun_pkt_write_u8(pkt, 1);
+        hdhomerun_pkt_write_u8(pkt, 4);
+        hdhomerun_pkt_write_u32(pkt, 0xFFFF0000);
+
+        hdhomerun_pkt_write_u8(pkt, 0xFF);
+
+        while (pkt->pos < pkt->start + 300) {
+                hdhomerun_pkt_write_u8(pkt, 0x00);
+        }
+
+        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(0xFFFFFFFF);
+        sock_addr.sin_port = htons(68);
+
+        sendto(dhcp->sock, (char *)pkt->start, (int)(pkt->end - pkt->start), 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr));
+}
+
+static void hdhomerun_dhcp_recv(struct hdhomerun_dhcp_t *dhcp, struct hdhomerun_pkt_t *pkt)
+{
+        pkt->pos = pkt->start;
+        struct dhcp_hdr_t *hdr = (struct dhcp_hdr_t *)pkt->pos;
+        pkt->pos += sizeof(struct dhcp_hdr_t);
+        if (pkt->pos > pkt->end) {
+                return;
+        }
+
+        if (ntohl(hdr->magic_cookie) != 0x63825363) {
+                return;
+        }
+
+        static uint8_t vendor[3] = {0x00, 0x18, 0xDD};
+        if (memcmp(hdr->client_mac, vendor, 3) != 0) {
+                return;
+        }
+
+        if (pkt->pos + 3 > pkt->end) {
+                return;
+        }
+        if (hdhomerun_pkt_read_u8(pkt) != 53) {
+                return;
+        }
+        if (hdhomerun_pkt_read_u8(pkt) != 1) {
+                return;
+        }
+        uint8_t message_type_val = hdhomerun_pkt_read_u8(pkt);
+
+        switch (message_type_val) {
+        case 0x01:
+                hdhomerun_dhcp_send(dhcp, 0x02, pkt);
+                break;
+        case 0x03:
+                hdhomerun_dhcp_send(dhcp, 0x05, pkt);
+                break;
+        default:
+                return;
+        }
+}
+
+static THREAD_FUNC_PREFIX hdhomerun_dhcp_thread_execute(void *arg)
+{
+        struct hdhomerun_dhcp_t *dhcp = (struct hdhomerun_dhcp_t *)arg;
+        struct hdhomerun_pkt_t pkt_inst;
+
+        while (1) {
+                if (dhcp->terminate) {
+                        return NULL;
+                }
+
+                struct hdhomerun_pkt_t *pkt = &pkt_inst;
+                hdhomerun_pkt_reset(pkt);
+
+                int rx_length = recv(dhcp->sock, (char *)pkt->end, (int)(pkt->limit - pkt->end), 0);
+                if (rx_length <= 0) {
+                        if (!sock_getlasterror_socktimeout) {
+                                sleep(1);
+                        }
+                        continue;
+                }
+                pkt->end += rx_length;
+
+                hdhomerun_dhcp_recv(dhcp, pkt);
+        }
+}

libs/libmythtv/hdhomerun/hdhomerun_control.c

@@ -3 +3 @@
  *
  * 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 2.1 of the License, or (at your option) any later version.
+ * version 3 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 +14 @@
  * 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ * 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.
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
-#include "hdhomerun_discover.h"
-#include "hdhomerun_control.h"
+#include "hdhomerun.h"
 
+#define HDHOMERUN_CONTROL_SEND_TIMEOUT 5000
+#define HDHOMERUN_CONTROL_RECV_TIMEOUT 5000
+#define HDHOMERUN_CONTROL_UPGRADE_TIMEOUT 20000
+
 struct hdhomerun_control_sock_t {
-        uint32_t device_id;
-        uint32_t device_ip;
+        uint32_t desired_device_id;
+        uint32_t desired_device_ip;
+        uint32_t actual_device_id;
+        uint32_t actual_device_ip;
         int sock;
-        uint8_t buffer[16384];
+        struct hdhomerun_debug_t *dbg;
+        struct hdhomerun_pkt_t tx_pkt;
+        struct hdhomerun_pkt_t rx_pkt;
 };
 
-struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip)
+static void hdhomerun_control_close_sock(struct hdhomerun_control_sock_t *cs)
 {
-        struct hdhomerun_control_sock_t *cs = (struct hdhomerun_control_sock_t *)malloc(sizeof(struct hdhomerun_control_sock_t));
+        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 *cs = (struct hdhomerun_control_sock_t *)calloc(1, sizeof(struct hdhomerun_control_sock_t));
         if (!cs) {
+                hdhomerun_debug_printf(dbg, "hdhomerun_control_create: failed to allocate control object\n");
                 return NULL;
         }
-        
-        cs->device_id = device_id;
-        cs->device_ip = device_ip;
+
+        cs->dbg = dbg;
         cs->sock = -1;
+        hdhomerun_control_set_device(cs, device_id, device_ip);
 
         return cs;
 }
 
 void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs)
 {
-        if (cs->sock != -1) {
-                close(cs->sock);
-        }
+        hdhomerun_control_close_sock(cs);
         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;
         }