Ticket #2807: mythtv_libhdhomerun_update_20061214.patch

libs/libmythtv/hdhomerun/hdhomerun.h

@@ +1 @@
+/*
+ * hdhomerun_device.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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "hdhomerun_os.h"
+#include "hdhomerun_pkt.h"
+#include "hdhomerun_discover.h"
+#include "hdhomerun_control.h"
+#include "hdhomerun_video.h"
+#include "hdhomerun_device.h"

libs/libmythtv/hdhomerun/hdhomerun_control.h

@@ -23 +23 @@
 
 struct hdhomerun_control_sock_t;
 
-struct hdhomerun_control_data_t {
-        int type;
-        unsigned char buffer[1024];
-        unsigned char *ptr;
-        unsigned char *end;
-};
-
-extern struct hdhomerun_control_sock_t *hdhomerun_control_create(unsigned long ip_addr, unsigned long timeout);
+/*
+ * Create a control socket.
+ *
+ * This function will not attempt to connect to the device.
+ * The connection will be established when first used.
+ *
+ * uint32_t device_id = 32-bit device id of device. Set to HDHOMERUN_DEVICE_ID_WILDCARD to match any device ID.
+ * uint32_t device_ip = IP address of device. Set to 0 to auto-detect.
+ *
+ * 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 unsigned long hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs);
 
-extern int hdhomerun_control_send(struct hdhomerun_control_sock_t *cs, unsigned char *start, unsigned char *end);
-extern int hdhomerun_control_send_get_request(struct hdhomerun_control_sock_t *cs, const char *name);
-extern int hdhomerun_control_send_set_request(struct hdhomerun_control_sock_t *cs, const char *name, const char *value);
-extern int hdhomerun_control_send_upgrade_request(struct hdhomerun_control_sock_t *cs, unsigned long sequence, void *data, int length);
+/*
+ * 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 int hdhomerun_control_recv(struct hdhomerun_control_sock_t *cs, struct hdhomerun_control_data_t *result, unsigned long timeout);
+/*
+ * 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.
+ * const char *value: The value to set (c-string). The format is device/firmware dependant.
 
+ * char **pvalue: If provided, the caller-supplied char pointer will be populated with a pointer to the value
+ *              string returned by the device, or NULL if the device returned an error string. The string will remain
+ *              valid until the next call to a control sock function.
+ * char **perror: If provided, the caller-supplied char pointer will be populated with a pointer to the error
+ *              string returned by the device, or NULL if the device returned an value string. The string will remain
+ *              valid until the next call to a control sock function.
+ *
+ * Returns 1 if the operation was successful (pvalue set, perror NULL).
+ * 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);
+
+/*
+ * Upload new firmware to the device.
+ *
+ * FILE *upgrade_file: File pointer to read from. The file must have been opened in binary mode for reading.
+ *
+ * Returns 1 if the upload succeeded.
+ * 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);
+
 #ifdef __cplusplus
 }
 #endif

libs/libmythtv/hdhomerun/hdhomerun_os.h

@@ -21 +21 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+
+#if defined(WIN32)
+#define __WINDOWS__
+#endif
+
+#if defined(__WINDOWS__)
+#include <windows.h>
+#include <sys/types.h>
+#include <sys/timeb.h>
+#else
 #include <unistd.h>
 #include <errno.h>
 #include <sys/types.h>
@@ -29 +39 @@
 #include <arpa/inet.h>
 #include <netdb.h>
 #include <sys/time.h>
+#include <sys/timeb.h>
 #include <fcntl.h>
+#endif
 
+#include <pthread.h>
+
 #if !defined(TRUE)
 #define TRUE 1
 #endif
 #if !defined(FALSE)
 #define FALSE 0
 #endif
+
+#if defined(__WINDOWS__)
+
+typedef int bool_t;
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+
+#define socklen_t int
+#define close closesocket
+#define sock_getlasterror WSAGetLastError()
+#define sock_getlasterror_socktimeout (WSAGetLastError() == WSAETIMEDOUT)
+#define atoll _atoi64
+#define strcasecmp _stricmp
+#define fseeko _fseeki64
+#define ftello _ftelli64
+#define usleep(us) Sleep((us)/1000)
+#define sleep(sec) Sleep((sec)*1000)
+
+static inline uint64_t getcurrenttime(void)
+{
+        struct timeb tb;
+        ftime(&tb);
+        return ((uint64_t)tb.time * 1000) + tb.millitm;
+}
+
+static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout)
+{
+        int t = (int)timeout;
+        return setsockopt(s, level, optname, (char *)&t, sizeof(t));
+}
+
+#else
+
+typedef int bool_t;
+
+#define sock_getlasterror errno
+#define sock_getlasterror_socktimeout (errno == EAGAIN)
+
+static inline uint64_t getcurrenttime(void)
+{
+        struct timeval t;
+        gettimeofday(&t, NULL);
+        return ((uint64_t)t.tv_sec * 1000) + (t.tv_usec / 1000);
+}
+
+static inline int setsocktimeout(int s, int level, int optname, uint64_t timeout)
+{
+        struct timeval t;
+        t.tv_sec = timeout / 1000;
+        t.tv_usec = (timeout % 1000) * 1000;
+        return setsockopt(s, level, optname, (char *)&t, sizeof(t));
+}
+
+#endif
+

libs/libmythtv/hdhomerun/hdhomerun_pkt.c

@@ -18 +18 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include <string.h>
+#include "hdhomerun_os.h"
 #include "hdhomerun_pkt.h"
 
-unsigned char hdhomerun_read_u8(unsigned char **pptr)
+uint8_t hdhomerun_read_u8(uint8_t **pptr)
 {
-        unsigned char *ptr = *pptr;
-        unsigned char v = *ptr++;
+        uint8_t *ptr = *pptr;
+        uint8_t v = *ptr++;
         *pptr = ptr;
         return v;
 }
 
-unsigned short hdhomerun_read_u16(unsigned char **pptr)
+uint16_t hdhomerun_read_u16(uint8_t **pptr)
 {
-        unsigned char *ptr = *pptr;
-        unsigned short v;
-        v =  (unsigned short)*ptr++ << 8;
-        v |= (unsigned short)*ptr++ << 0;
+        uint8_t *ptr = *pptr;
+        uint16_t v;
+        v =  (uint16_t)*ptr++ << 8;
+        v |= (uint16_t)*ptr++ << 0;
         *pptr = ptr;
         return v;
 }
 
-unsigned long hdhomerun_read_u32(unsigned char **pptr)
+uint32_t hdhomerun_read_u32(uint8_t **pptr)
 {
-        unsigned char *ptr = *pptr;
-        unsigned long v;
-        v =  (unsigned long)*ptr++ << 24;
-        v |= (unsigned long)*ptr++ << 16;
-        v |= (unsigned long)*ptr++ << 8;
-        v |= (unsigned long)*ptr++ << 0;
+        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;
         return v;
 }
 
-static int hdhomerun_read_var_length(unsigned char **pptr, unsigned char *end)
+size_t hdhomerun_read_var_length(uint8_t **pptr, uint8_t *end)
 {
-        unsigned char *ptr = *pptr;
-        unsigned int length;
+        uint8_t *ptr = *pptr;
+        size_t length;
         
         if (ptr + 1 > end) {
                 return -1;
         }
 
-        length = (unsigned int)*ptr++;
+        length = (size_t)*ptr++;
         if (length & 0x0080) {
                 if (ptr + 1 > end) {
                         return -1;
                 }
 
                 length &= 0x007F;
-                length |= (unsigned int)*ptr++ << 7;
+                length |= (size_t)*ptr++ << 7;
         }
         
         *pptr = ptr;
-        return (int)length; 
+        return length; 
 }
 
-int hdhomerun_read_tlv(unsigned char **pptr, unsigned char *end, unsigned char *ptag, int *plength, unsigned char **pvalue)
+int hdhomerun_read_tlv(uint8_t **pptr, uint8_t *end, uint8_t *ptag, size_t *plength, uint8_t **pvalue)
 {
         if (end - *pptr < 2) {
                 return -1;
@@ -84 +84 @@
         *plength = hdhomerun_read_var_length(pptr, end);
         *pvalue = *pptr;
         
-        if (*plength < 0) {
+        if ((size_t)(end - *pptr) < *plength) {
                 return -1;
         }
-        if (end - *pptr < *plength) {
-                return -1;
-        }
         
         *pptr += *plength;
         return 0;
 }
 
-void hdhomerun_write_u8(unsigned char **pptr, unsigned char v)
+void hdhomerun_write_u8(uint8_t **pptr, uint8_t v)
 {
-        unsigned char *ptr = *pptr;
+        uint8_t *ptr = *pptr;
         *ptr++ = v;
         *pptr = ptr;
 }
 
-void hdhomerun_write_u16(unsigned char **pptr, unsigned short v)
+void hdhomerun_write_u16(uint8_t **pptr, uint16_t v)
 {
-        unsigned char *ptr = *pptr;
-        *ptr++ = (v >> 8) & 0xFF;
-        *ptr++ = (v >> 0) & 0xFF;
+        uint8_t *ptr = *pptr;
+        *ptr++ = (uint8_t)(v >> 8);
+        *ptr++ = (uint8_t)(v >> 0);
         *pptr = ptr;
 }
 
-void hdhomerun_write_u32(unsigned char **pptr, unsigned long v)
+void hdhomerun_write_u32(uint8_t **pptr, uint32_t v)
 {
-        unsigned char *ptr = *pptr;
-        *ptr++ = (v >> 24) & 0xFF;
-        *ptr++ = (v >> 16) & 0xFF;
-        *ptr++ = (v >> 8) & 0xFF;
-        *ptr++ = (v >> 0) & 0xFF;
+        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;
 }
 
-void hdhomerun_write_var_length(unsigned char **pptr, int v)
+void hdhomerun_write_var_length(uint8_t **pptr, size_t v)
 {
-        unsigned char *ptr = *pptr;
+        uint8_t *ptr = *pptr;
         if (v <= 127) {
-                *ptr++ = v;
+                *ptr++ = (uint8_t)v;
         } else {
-                *ptr++ = v | 0x80;
-                *ptr++ = v >> 7;
+                *ptr++ = (uint8_t)(v | 0x80);
+                *ptr++ = (uint8_t)(v >> 7);
         }
         *pptr = ptr;
 }
 
-static void hdhomerun_write_mem(unsigned char **pptr, void *mem, int length)
+static void hdhomerun_write_mem(uint8_t **pptr, void *mem, size_t length)
 {
-        unsigned char *ptr = *pptr;
+        uint8_t *ptr = *pptr;
         memcpy(ptr, mem, length);
         ptr += length;
         *pptr = ptr;
 }
 
-static unsigned long hdhomerun_calc_crc(unsigned char *start, unsigned char *end)
+static uint32_t hdhomerun_calc_crc(uint8_t *start, uint8_t *end)
 {
-        unsigned char *ptr = start;
-        unsigned long crc = 0xFFFFFFFF;
+        uint8_t *ptr = start;
+        uint32_t crc = 0xFFFFFFFF;
         while (ptr < end) {
-        unsigned char x = (crc & 0x000000FF) ^ *ptr++;
-        crc >>= 8;
+                uint8_t x = (uint8_t)(crc) ^ *ptr++;
+                crc >>= 8;
                 if (x & 0x01) crc ^= 0x77073096;
                 if (x & 0x02) crc ^= 0xEE0E612C;
                 if (x & 0x04) crc ^= 0x076DC419;
@@ -159 +156 @@
         return crc ^ 0xFFFFFFFF;
 }
 
-static int hdhomerun_check_crc(unsigned char *start, unsigned char *end)
+static int hdhomerun_check_crc(uint8_t *start, uint8_t *end)
 {
         if (end - start < 8) {
                 return -1;
         }
-        unsigned char *ptr = end -= 4;
-        unsigned long actual_crc = hdhomerun_calc_crc(start, ptr);
-        unsigned long packet_crc;
-        packet_crc =  (unsigned long)*ptr++ << 0;
-        packet_crc |= (unsigned long)*ptr++ << 8;
-        packet_crc |= (unsigned long)*ptr++ << 16;
-        packet_crc |= (unsigned long)*ptr++ << 24;
+        uint8_t *ptr = end -= 4;
+        uint32_t actual_crc = hdhomerun_calc_crc(start, ptr);
+        uint32_t packet_crc;
+        packet_crc =  (uint32_t)*ptr++ << 0;
+        packet_crc |= (uint32_t)*ptr++ << 8;
+        packet_crc |= (uint32_t)*ptr++ << 16;
+        packet_crc |= (uint32_t)*ptr++ << 24;
         if (actual_crc != packet_crc) {
                 return -1;
         }
         return 0;
 }
 
-static void hdhomerun_write_header_length(unsigned char *ptr, unsigned long length)
+static void hdhomerun_write_header_length(uint8_t *ptr, size_t length)
 {
-        hdhomerun_write_u16(&ptr, length);
+        hdhomerun_write_u16(&ptr, (uint16_t)length);
 }
 
-void hdhomerun_write_crc(unsigned char **pptr, unsigned char *start)
+void hdhomerun_write_crc(uint8_t **pptr, uint8_t *start)
 {
-        unsigned char *ptr = *pptr;
-        unsigned long crc = hdhomerun_calc_crc(start, ptr);
-        *ptr++ = (crc >> 0) & 0xFF;
-        *ptr++ = (crc >> 8) & 0xFF;
-        *ptr++ = (crc >> 16) & 0xFF;
-        *ptr++ = (crc >> 24) & 0xFF;
+        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;
 }
 
-void hdhomerun_write_discover_request(unsigned char **pptr, unsigned long device_type, unsigned long device_id)
+void hdhomerun_write_discover_request(uint8_t **pptr, uint32_t device_type, uint32_t device_id)
 {
-        unsigned char *start = *pptr;
+        uint8_t *start = *pptr;
         hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_DISCOVER_REQ);
         hdhomerun_write_u16(pptr, 0);
 
@@ -206 +203 @@
         hdhomerun_write_var_length(pptr, 4);
         hdhomerun_write_u32(pptr, device_id);
 
-        hdhomerun_write_header_length(start + 2, *pptr - start - 4);
+        hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4));
         hdhomerun_write_crc(pptr, start);
 }
 
-void hdhomerun_write_get_request(unsigned char **pptr, const char *name)
+void hdhomerun_write_get_set_request(uint8_t **pptr, const char *name, const char *value)
 {
-        unsigned char *start = *pptr;
+        uint8_t *start = *pptr;
         hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_GETSET_REQ);
         hdhomerun_write_u16(pptr, 0);
 
-        int name_len = strlen(name) + 1;
+        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);
 
-        hdhomerun_write_header_length(start + 2, *pptr - start - 4);
-        hdhomerun_write_crc(pptr, start);
-}
+        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);
+        }
 
-void hdhomerun_write_set_request(unsigned char **pptr, const char *name, const char *value)
-{
-        unsigned char *start = *pptr;
-        hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_GETSET_REQ);
-        hdhomerun_write_u16(pptr, 0);
-
-        int name_len = strlen(name) + 1;
-        int value_len = strlen(value) + 1;
-        hdhomerun_write_u8(pptr, HDHOMERUN_TAG_GETSET_NAME);
-        hdhomerun_write_var_length(pptr, name_len);
-        hdhomerun_write_mem(pptr, (void *)name, name_len);
-        hdhomerun_write_u8(pptr, HDHOMERUN_TAG_GETSET_VALUE);
-        hdhomerun_write_var_length(pptr, value_len);
-        hdhomerun_write_mem(pptr, (void *)value, value_len);
-
-        hdhomerun_write_header_length(start + 2, *pptr - start - 4);
+        hdhomerun_write_header_length(start + 2, (int)(*pptr - start - 4));
         hdhomerun_write_crc(pptr, start);
 }
 
-void hdhomerun_write_upgrade_request(unsigned char **pptr, unsigned long sequence, void *data, int length)
+void hdhomerun_write_upgrade_request(uint8_t **pptr, uint32_t sequence, void *data, size_t length)
 {
-        unsigned char *start = *pptr;
+        uint8_t *start = *pptr;
         hdhomerun_write_u16(pptr, HDHOMERUN_TYPE_UPGRADE_REQ);
         hdhomerun_write_u16(pptr, 0);
 
@@ -259 +244 @@
         hdhomerun_write_crc(pptr, start);
 }
 
-int hdhomerun_peek_packet_length(unsigned char *ptr)
+size_t hdhomerun_peek_packet_length(uint8_t *ptr)
 {
         ptr += 2;
-        return hdhomerun_read_u16(&ptr) + 8;
+        return (size_t)hdhomerun_read_u16(&ptr) + 8;
 }
 
-int hdhomerun_process_packet(unsigned char **pptr, unsigned char **pend)
+int hdhomerun_process_packet(uint8_t **pptr, uint8_t **pend)
 {
         if (hdhomerun_check_crc(*pptr, *pend) < 0) {
                 return -1;
         }
         *pend -= 4;
         
-        unsigned short type = hdhomerun_read_u16(pptr);
-        unsigned short length = hdhomerun_read_u16(pptr);
+        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 @@
+/*
+ * hdhomerun_record.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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include "hdhomerun_os.h"
+#include "hdhomerun_pkt.h"
+#include "hdhomerun_control.h"
+#include "hdhomerun_video.h"
+#include "hdhomerun_device.h"
+
+struct hdhomerun_device_t {
+        struct hdhomerun_control_sock_t *cs;
+        struct hdhomerun_video_sock_t *vs;
+        unsigned int tuner;
+        char result_buffer[1024];
+};
+
+struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner)
+{
+        struct hdhomerun_device_t *hd = (struct hdhomerun_device_t *)calloc(1, sizeof(struct hdhomerun_device_t));
+        if (!hd) {
+                return NULL;
+        }
+
+        hd->tuner = tuner;
+
+        hd->cs = hdhomerun_control_create(device_id, device_ip);
+        if (!hd->cs) {
+                free(hd);
+                return NULL;
+        }
+
+        return hd;
+}
+
+void hdhomerun_device_destroy(struct hdhomerun_device_t *hd)
+{
+        if (hd->vs) {
+                hdhomerun_video_destroy(hd->vs);
+        }
+
+        hdhomerun_control_destroy(hd->cs);
+
+        free(hd);
+}
+
+void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner)
+{
+        hd->tuner = tuner;
+}
+
+struct hdhomerun_control_sock_t *hdhomerun_device_get_control_sock(struct hdhomerun_device_t *hd)
+{
+        return hd->cs;
+}
+
+struct hdhomerun_video_sock_t *hdhomerun_device_get_video_sock(struct hdhomerun_device_t *hd)
+{
+        if (!hd->vs) {
+                hd->vs = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S);
+        }
+        return hd->vs;
+}
+
+uint32_t hdhomerun_device_get_local_machine_addr(struct hdhomerun_device_t *hd)
+{
+        return hdhomerun_control_get_local_addr(hd->cs);
+}
+
+static uint32_t hdhomerun_device_get_status_parse(const char *status_str, const char *tag)
+{
+        const char *ptr = strstr(status_str, tag);
+        if (!ptr) {
+                return 0;
+        }
+
+        unsigned long value = 0;
+        sscanf(ptr + strlen(tag), "%lu", &value);
+
+        return (uint32_t)value;
+}
+
+int hdhomerun_device_get_tuner_status(struct hdhomerun_device_t *hd, struct hdhomerun_tuner_status_t *status)
+{
+        memset(status, 0, sizeof(struct hdhomerun_tuner_status_t));
+
+        char name[32];
+        sprintf(name, "/tuner%u/status", hd->tuner);
+
+        char *status_str;
+        int ret = hdhomerun_control_get(hd->cs, name, &status_str, NULL);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        char *channel = strstr(status_str, "ch=");
+        if (channel) {
+                sscanf(channel + 3, "%s", status->channel);
+        }
+
+        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=");
+
+        return 1;
+}
+
+int hdhomerun_device_get_tuner_streaminfo(struct hdhomerun_device_t *hd, char **pstreaminfo)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/streaminfo", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, pstreaminfo, NULL);
+}
+
+int hdhomerun_device_get_tuner_channel(struct hdhomerun_device_t *hd, char **pchannel)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/channel", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, pchannel, NULL);
+}
+
+int hdhomerun_device_get_tuner_channelmap(struct hdhomerun_device_t *hd, char **pchannelmap)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/channelmap", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, pchannelmap, NULL);
+}
+
+int hdhomerun_device_get_tuner_filter(struct hdhomerun_device_t *hd, char **pfilter)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/filter", hd->tuner);
+        return hdhomerun_control_get(hd->cs, name, pfilter, NULL);
+}
+
+int hdhomerun_device_get_tuner_program(struct hdhomerun_device_t *hd, uint16_t *pprogram_number)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/program", hd->tuner);
+
+        char *program_str;
+        int ret = hdhomerun_control_get(hd->cs, name, &program_str, NULL);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        *pprogram_number = (uint16_t)atol(program_str);
+        return 1;
+}
+
+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_ir_target(struct hdhomerun_device_t *hd, char **ptarget)
+{
+        return hdhomerun_control_get(hd->cs, "/ir/target", ptarget, NULL);
+}
+
+int hdhomerun_device_get_version(struct hdhomerun_device_t *hd, char **pversion_str, uint32_t *pversion_num)
+{
+        char *version_str;
+        int ret = hdhomerun_control_get(hd->cs, "/sys/version", &version_str, NULL);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        if (pversion_str) {
+                *pversion_str = version_str;
+        }
+
+        if (pversion_num) {
+                unsigned long version_num;
+                if (sscanf(version_str, "%lu", &version_num) != 1) {
+                        *pversion_num = 0;
+                } else {
+                        *pversion_num = (uint32_t)version_num;
+                }
+        }
+
+        return 1;
+}
+
+int hdhomerun_device_set_tuner_channel(struct hdhomerun_device_t *hd, const char *channel)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/channel", hd->tuner);
+        return hdhomerun_control_set(hd->cs, name, channel, NULL, NULL);
+}
+
+int hdhomerun_device_set_tuner_channelmap(struct hdhomerun_device_t *hd, const char *channelmap)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/channelmap", hd->tuner);
+        return hdhomerun_control_set(hd->cs, name, channelmap, NULL, NULL);
+}
+
+int hdhomerun_device_set_tuner_filter(struct hdhomerun_device_t *hd, const char *filter)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/filter", hd->tuner);
+        return hdhomerun_control_set(hd->cs, name, filter, NULL, NULL);
+}
+
+int hdhomerun_device_set_tuner_program(struct hdhomerun_device_t *hd, uint16_t program_number)
+{
+        char name[32], value[32];
+        sprintf(name, "/tuner%u/program", hd->tuner);
+        sprintf(value, "%u", program_number);
+        return hdhomerun_control_set(hd->cs, name, value, NULL, NULL);
+}
+
+int hdhomerun_device_set_tuner_target(struct hdhomerun_device_t *hd, char *target)
+{
+        char name[32];
+        sprintf(name, "/tuner%u/target", hd->tuner);
+        return hdhomerun_control_set(hd->cs, name, target, NULL, NULL);
+}
+
+static int hdhomerun_device_set_tuner_target_to_local(struct hdhomerun_device_t *hd)
+{
+        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",
+                (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
+        );
+
+        return hdhomerun_device_set_tuner_target(hd, target);
+}
+
+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_get_var(struct hdhomerun_device_t *hd, const char *name, char **pvalue, char **perror)
+{
+        return hdhomerun_control_get(hd->cs, name, pvalue, perror);
+}
+
+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);
+}
+
+int hdhomerun_device_stream_start(struct hdhomerun_device_t *hd)
+{
+        /* Create video socket. */
+        hdhomerun_device_get_video_sock(hd);
+        if (!hd->vs) {
+                return -1;
+        }
+
+        /* Set target. */
+        int ret = hdhomerun_device_set_tuner_target_to_local(hd);
+        if (ret <= 0) {
+                return ret;
+        }
+
+        /* Flush video buffer. */
+        usleep(64000);
+        hdhomerun_video_flush(hd->vs);
+
+        /* Success. */
+        return 1;
+}
+
+uint8_t *hdhomerun_device_stream_recv(struct hdhomerun_device_t *hd, size_t max_size, size_t *pactual_size)
+{
+        return hdhomerun_video_recv(hd->vs, max_size, pactual_size);
+}
+
+void hdhomerun_device_stream_stop(struct hdhomerun_device_t *hd)
+{
+        hdhomerun_device_set_tuner_target(hd, "none");
+}
+
+int hdhomerun_device_firmware_version_check(struct hdhomerun_device_t *hd, uint32_t features)
+{
+        uint32_t version;
+        if (hdhomerun_device_get_version(hd, NULL, &version) <= 0) {
+                return -1;
+        }
+
+        if (version >= 20061213) {
+                return 1;
+        }
+
+        return 0;
+}
+
+int hdhomerun_device_upgrade(struct hdhomerun_device_t *hd, FILE *upgrade_file)
+{
+        hdhomerun_control_set(hd->cs, "/tuner0/channel", "none", NULL, NULL);
+        hdhomerun_control_set(hd->cs, "/tuner1/channel", "none", NULL, NULL);
+        return hdhomerun_control_upgrade(hd->cs, upgrade_file);
+}

libs/libmythtv/hdhomerun/hdhomerun_pkt.h

@@ -21 +21 @@
 extern "C" {
 #endif
 
+/*
+ * The discover protocol (UDP port 65001) and control protocol (TCP port 65001)
+ * both use the same packet based format:
+ *      uint16_t        Packet type
+ *      uint16_t        Payload length (bytes)
+ *      uint8_t[]       Payload data (0-n bytes).
+ *      uint32_t        CRC (Ethernet style 32-bit CRC)
+ *
+ * All variables are big-endian except for the crc which is little-endian.
+ *
+ * Valid values for the packet type are listed below as defines prefixed
+ * with "HDHOMERUN_TYPE_"
+ *
+ * Discovery:
+ *
+ * The payload for a discovery request or reply is a simple sequence of
+ * tag-length-value data:
+ *      uint8_t         Tag
+ *      varlen          Length
+ *      uint8_t[]       Value (0-n bytes)
+ *
+ * The length field can be one or two bytes long.
+ * For a length <= 127 bytes the length is expressed as a single byte. The
+ * most-significant-bit is clear indicating a single-byte length.
+ * For a length >= 128 bytes the length is expressed as a sequence of two bytes as follows:
+ * The first byte is contains the least-significant 7-bits of the length. The
+ * most-significant bit is then set (add 0x80) to indicate that it is a two byte length.
+ * The second byte contains the length shifted down 7 bits.
+ *
+ * A discovery request packet has a packet type of HDHOMERUN_TYPE_DISCOVER_REQ and should
+ * contain two tags: HDHOMERUN_TAG_DEVICE_TYPE and HDHOMERUN_TAG_DEVICE_ID.
+ * The HDHOMERUN_TAG_DEVICE_TYPE value should be set to HDHOMERUN_DEVICE_TYPE_TUNER.
+ * The HDHOMERUN_TAG_DEVICE_ID value should be set to HDHOMERUN_DEVICE_ID_WILDCARD to match
+ * all devices, or to the 32-bit device id number to match a single device.
+ *
+ * The discovery response packet has a packet type of HDHOMERUN_TYPE_DISCOVER_RPY and has the
+ * same format as the discovery request packet with the two tags: HDHOMERUN_TAG_DEVICE_TYPE and
+ * HDHOMERUN_TAG_DEVICE_ID. In the future additional tags may also be returned - unknown tags
+ * should be skipped and not treated as an error.
+ *
+ * Control get/set:
+ *
+ * The payload for a control get/set request is a simple sequence of tag-length-value data
+ * following the same format as for discover packets.
+ *
+ * A get request packet has a packet type of HDHOMERUN_TYPE_GETSET_REQ and should contain
+ * the tag: HDHOMERUN_TAG_GETSET_NAME. The HDHOMERUN_TAG_GETSET_NAME value should be a sequence
+ * of bytes forming a null-terminated string, including the NULL. The TLV length must include
+ * the NULL character so the length field should be set to strlen(str) + 1.
+ *
+ * A set request packet has a packet type of HDHOMERUN_TYPE_GETSET_REQ (same as a get request)
+ * and should contain two tags: HDHOMERUN_TAG_GETSET_NAME and HDHOMERUN_TAG_GETSET_VALUE.
+ * The HDHOMERUN_TAG_GETSET_NAME value should be a sequence of bytes forming a null-terminated
+ * string, including the NULL.
+ * The HDHOMERUN_TAG_GETSET_VALUE value  should be a sequence of bytes forming a null-terminated
+ * string, including the NULL.
+ *
+ * The get and set reply packets have the packet type HDHOMERUN_TYPE_GETSET_RPY and have the same
+ * format as the set request packet with the two tags: HDHOMERUN_TAG_GETSET_NAME and
+ * HDHOMERUN_TAG_GETSET_VALUE. A set request is also implicit get request so the updated value is
+ * returned.
+ *
+ * If the device encounters an error handling the get or set request then the get/set reply packet
+ * will contain the tag HDHOMERUN_TAG_ERROR_MESSAGE. The format of the value is a sequence of
+ * bytes forming a null-terminated string, including the NULL.
+ *
+ * In the future additional tags may also be returned - unknown tags should be skipped and not
+ * treated as an error.
+ *
+ * Security note: The application should not rely on the NULL character being present. The
+ * application should write a NULL character based on the TLV length to protect the application
+ * from a potential attack.
+ *
+ * Firmware Upgrade:
+ *
+ * A firmware upgrade packet has a packet type of HDHOMERUN_TYPE_UPGRADE_REQ and has a fixed format:
+ *      uint32_t        Position in bytes from start of file.
+ *      uint8_t[256]    Firmware data (256 bytes)
+ *
+ * The data must be uploaded in 256 byte chunks and must be uploaded in order.
+ * The position number is in bytes so will increment by 256 each time.
+ *
+ * When all data is uploaded it should be signaled complete by sending another packet of type
+ * HDHOMERUN_TYPE_UPGRADE_REQ with payload of a single uint32_t with the value 0xFFFFFFFF.
+ */
+
 #define HDHOMERUN_DISCOVER_UDP_PORT 65001
 #define HDHOMERUN_CONTROL_TCP_PORT 65001
 
@@ -43 +129 @@
 
 #define HDHOMERUN_MIN_PEEK_LENGTH 4
 
-extern unsigned char hdhomerun_read_u8(unsigned char **pptr);
-extern unsigned short hdhomerun_read_u16(unsigned char **pptr);
-extern unsigned long hdhomerun_read_u32(unsigned char **pptr);
-extern void hdhomerun_write_u8(unsigned char **pptr, unsigned char v);
-extern void hdhomerun_write_u16(unsigned char **pptr, unsigned short v);
-extern void hdhomerun_write_u32(unsigned char **pptr, unsigned long v);
-extern void hdhomerun_write_crc(unsigned char **pptr, unsigned char *start);
+extern uint8_t hdhomerun_read_u8(uint8_t **pptr);
+extern uint16_t hdhomerun_read_u16(uint8_t **pptr);
+extern uint32_t hdhomerun_read_u32(uint8_t **pptr);
+extern size_t hdhomerun_read_var_length(uint8_t **pptr, uint8_t *end);
+extern void hdhomerun_write_u8(uint8_t **pptr, uint8_t v);
+extern void hdhomerun_write_u16(uint8_t **pptr, uint16_t v);
+extern void hdhomerun_write_u32(uint8_t **pptr, uint32_t v);
+extern void hdhomerun_write_var_length(uint8_t **pptr, size_t v);
+extern void hdhomerun_write_crc(uint8_t **pptr, uint8_t *start);
 
-extern int hdhomerun_peek_packet_length(unsigned char *ptr);
-extern int hdhomerun_process_packet(unsigned char **pptr, unsigned char **pend);
-extern int hdhomerun_read_tlv(unsigned char **pptr, unsigned char *end, unsigned char *ptag, int *plength, unsigned char **pvalue);
+extern size_t hdhomerun_peek_packet_length(uint8_t *ptr);
+extern int hdhomerun_process_packet(uint8_t **pptr, uint8_t **pend);
+extern int hdhomerun_read_tlv(uint8_t **pptr, uint8_t *end, uint8_t *ptag, size_t *plength, uint8_t **pvalue);
 
-extern void hdhomerun_write_discover_request(unsigned char **pptr, unsigned long device_type, unsigned long device_id);
-extern void hdhomerun_write_get_request(unsigned char **pptr, const char *name);
-extern void hdhomerun_write_set_request(unsigned char **pptr, const char *name, const char *value);
-extern void hdhomerun_write_upgrade_request(unsigned char **pptr, unsigned long sequence, void *data, int length);
+extern void hdhomerun_write_discover_request(uint8_t **pptr, uint32_t device_type, uint32_t device_id);
+extern void hdhomerun_write_get_set_request(uint8_t **pptr, const char *name, const char *value);
+extern void hdhomerun_write_upgrade_request(uint8_t **pptr, uint32_t sequence, void *data, size_t length);
 
 #ifdef __cplusplus
 }
 #endif
+

libs/libmythtv/hdhomerun/hdhomerun_device.h

@@ +1 @@
+/*
+ * hdhomerun_device.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 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define HDHOMERUN_DEVICE_MAX_TUNE_TO_LOCK_TIME 1500
+#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;
+
+struct hdhomerun_tuner_status_t {
+        char channel[32];
+        unsigned int signal_strength;
+        unsigned int signal_to_noise_quality;
+        unsigned int symbol_error_quality;
+        uint32_t raw_bits_per_second;
+        uint32_t packets_per_second;
+};
+
+/*
+ * Create a device object.
+ *
+ * Typically a device object will be created for each tuner.
+ * It is valid to have multiple device objects communicating with a single HDHomeRun.
+ *
+ * For example, a threaded application that streams video from 4 tuners (2 HDHomeRun devices) and has
+ * GUI feedback to the user of the selected tuner might use 5 device objects: 4 for streaming video
+ * (one per thread) and one for the GUI display that can just between tuners.
+ *
+ * This function will not attempt to connect to the device.
+ * The connection will be established when first used.
+ *
+ * uint32_t device_id = 32-bit device id of device. Set to HDHOMERUN_DEVICE_ID_WILDCARD to match any device ID.
+ * uint32_t device_ip = IP address of device. Set to 0 to auto-detect.
+ * unsigned int tuner = tuner index (0 or 1). Can be changed later by calling hdhomerun_device_set_tuner.
+ *
+ * Returns a pointer to the newly created device object.
+ *
+ * When no longer needed, the socket should be destroyed by calling hdhomerun_device_destroy.
+ */
+extern struct hdhomerun_device_t *hdhomerun_device_create(uint32_t device_id, uint32_t device_ip, unsigned int tuner);
+extern void hdhomerun_device_destroy(struct hdhomerun_device_t *hd);
+extern void hdhomerun_device_set_tuner(struct hdhomerun_device_t *hd, unsigned int tuner);
+
+/*
+ * Get the local machine IP address used when communicating with the device.
+ *
+ * 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);
+
+/*
+ * Get operations.
+ *
+ * struct hdhomerun_tuner_status_t *status = Pointer to caller supplied status struct to be populated with result.
+ * const char **p<name> = Caller supplied char * to be updated to point to the result string. The string will remain
+ *              valid until another call to a device function.
+ *
+ * Returns 1 if the operation was successful.
+ * 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);
+
+/*
+ * Set operations.
+ *
+ * const char *<name> = String to send to device.
+ *
+ * Returns 1 if the operation was successful.
+ * 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);
+
+/*
+ * Get/set a named control variable on the device.
+ *
+ * const char *name: The name of var to get/set (c-string). The supported vars is device/firmware dependant.
+ * const char *value: The value to set (c-string). The format is device/firmware dependant.
+
+ * char **pvalue: If provided, the caller-supplied char pointer will be populated with a pointer to the value
+ *              string returned by the device, or NULL if the device returned an error string. The string will remain
+ *              valid until the next call to a control sock function.
+ * char **perror: If provided, the caller-supplied char pointer will be populated with a pointer to the error
+ *              string returned by the device, or NULL if the device returned an value string. The string will remain
+ *              valid until the next call to a control sock function.
+ *
+ * Returns 1 if the operation was successful (pvalue set, perror NULL).
+ * 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);
+
+/*
+ * 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.
+ *
+ * uint16_t program_number = The program number to filer, or 0 for unfiltered.
+ *
+ * Returns 1 if the oprtation started successfully.
+ * Returns 0 if the operation was rejected.
+ * Returns -1 if a communication error occurs.
+ *
+ * The hdhomerun_device_stream_recv function should be called periodically to receive the stream data.
+ * The buffer can losslessly store 1 second of data, however a more typical call rate would be every 64ms.
+ *
+ * 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);
+
+/*
+ * Check that the device is running the recommended firmware.
+ *
+ * uint32_t features: Reserved for future use. Set to zero.
+ *
+ * Returns 1 if the firmware meets the minimum requriements for all operations.
+ * 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);
+
+/*
+ * Upload new firmware to the device.
+ *
+ * FILE *upgrade_file: File pointer to read from. The file must have been opened in binary mode for reading.
+ *
+ * Returns 1 if the upload succeeded.
+ * 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);
+
+/*
+ * 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);
+
+#ifdef __cplusplus
+}
+#endif

libs/libmythtv/hdhomerun/hdhomerun_config.c

@@ -18 +18 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-#include "hdhomerun_os.h"
-#include "hdhomerun_pkt.h"
-#include "hdhomerun_discover.h"
-#include "hdhomerun_control.h"
+#include "hdhomerun.h"
 
-const char *appname;
+static const char *appname;
 
+struct hdhomerun_device_t *hd;
+
 static int help(void)
 {
         printf("Usage:\n");
         printf("\t%s discover\n", appname);
-        printf("\t%s <id|ip> get help\n", appname);
-        printf("\t%s <id|ip> get <item>\n", appname);
-        printf("\t%s <id|ip> set <item> <value>\n", appname);
-        printf("\t%s <id|ip> scan <tuner> <starting channel>\n", appname);
-        printf("\t%s <id|ip> upgrade <filename>\n", appname);
-        return 1;
+        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> upgrade <filename>\n", appname);
+        return -1;
 }
 
 static void extract_appname(const char *argv0)
 {
-        char *ptr = strrchr(argv0, '/');
+        const char *ptr = strrchr(argv0, '/');
         if (ptr) {
                 argv0 = ptr + 1;
         }
@@ -50 +49 @@
         appname = argv0;
 }
 
-static int contains(const char *arg, const char *cmpstr)
+static bool_t contains(const char *arg, const char *cmpstr)
 {
         if (strcmp(arg, cmpstr) == 0) {
-                return 1;
+                return TRUE;
         }
 
         if (*arg++ != '-') {
-                return 0;
+                return FALSE;
         }
         if (*arg++ != '-') {
-                return 0;
+                return FALSE;
         }
         if (strcmp(arg, cmpstr) == 0) {
-                return 1;
+                return TRUE;
         }
 
-        return 0;
+        return FALSE;
 }
 
-static int discover_print_internal(struct hdhomerun_discover_sock_t *discover_sock)
-{
-        if (hdhomerun_discover_send(discover_sock, HDHOMERUN_DEVICE_TYPE_TUNER, HDHOMERUN_DEVICE_ID_WILDCARD) < 0) {
-                fprintf(stderr, "unable to send discover request\n");
-                return 1;
-        }
-
-        while (1) {
-                struct hdhomerun_discover_device_t result;
-                int ret = hdhomerun_discover_recv(discover_sock, &result, 1000);
-                if (ret < 0) {
-                        fprintf(stderr, "error listening for discover response\n");
-                        return 1;
-                }
-                if (ret == 0) {
-                        return 0;
-                }
-
-                printf("hdhomerun device %08lX found at %ld.%ld.%ld.%ld\n",
-                        result.device_id,
-                        (result.ip_addr >> 24) & 0x0FF, (result.ip_addr >> 16) & 0x0FF,
-                        (result.ip_addr >> 8) & 0x0FF, (result.ip_addr >> 0) & 0x0FF
-                );
-        }
-}
-
 static int discover_print(void)
 {
-        struct hdhomerun_discover_sock_t *discover_sock = hdhomerun_discover_create(1000);
-        if (!discover_sock) {
-                fprintf(stderr, "unable to create discover socket\n");
-                return 1;
+        struct hdhomerun_discover_device_t result_list[64];
+        int count = hdhomerun_discover_find_devices(HDHOMERUN_DEVICE_TYPE_TUNER, result_list, 64);
+        if (count < 0) {
+                fprintf(stderr, "error sending discover request\n");
+                return -1;
         }
-
-        int ret = discover_print_internal(discover_sock);
-
-        hdhomerun_discover_destroy(discover_sock);
-        return ret;
-}
-
-static unsigned long get_ip_addr(struct hdhomerun_discover_sock_t *discover_sock, const char *id_str)
-{
-        int a[4];
-        if (sscanf(id_str, "%u.%u.%u.%u", &a[0], &a[1], &a[2], &a[3]) == 4) {
-                return (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | (a[3] << 0);
-        }
-
-        unsigned long id = (unsigned long)strtoll(id_str, NULL, 16);
-        if (!hdhomerun_discover_validate_device_id(id)) {
-                fprintf(stderr, "invalid device id: %s\n", id_str);
+        if (count == 0) {
+                printf("no devices found\n");
                 return 0;
         }
 
-        if (hdhomerun_discover_send(discover_sock, HDHOMERUN_DEVICE_TYPE_TUNER, id) < 0) {
-                fprintf(stderr, "unable to send discover request\n");
-                return 0;
+        int index;
+        for (index = 0; index < count; index++) {
+                struct hdhomerun_discover_device_t *result = &result_list[index];
+                printf("hdhomerun device %08lX found at %u.%u.%u.%u\n",
+                        (unsigned long)result->device_id,
+                        (unsigned int)(result->ip_addr >> 24) & 0x0FF, (unsigned int)(result->ip_addr >> 16) & 0x0FF,
+                        (unsigned int)(result->ip_addr >> 8) & 0x0FF, (unsigned int)(result->ip_addr >> 0) & 0x0FF
+                );
         }
 
-        struct hdhomerun_discover_device_t result;
-        int ret = hdhomerun_discover_recv(discover_sock, &result, 1000);
-        if (ret < 0) {
-                fprintf(stderr, "error listening for discover response\n");
-                return 0;
-        }
-        if (ret == 0) {
-                fprintf(stderr, "unable to find hdhomerun device %08lX\n", id);
-                return 0;
-        }
-
-        return result.ip_addr;
+        return count;
 }
 
-static struct hdhomerun_control_sock_t *create_control_sock(const char *id_str)
+static bool_t parse_device_id_str(const char *s, uint32_t *pdevice_id, uint32_t *pdevice_ip)
 {
-        struct hdhomerun_discover_sock_t *discover_sock = hdhomerun_discover_create(1000);
-        if (!discover_sock) {
-                fprintf(stderr, "unable to create discover socket\n");
-                return NULL;
+        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 ip_addr = get_ip_addr(discover_sock, id_str);
-
-        hdhomerun_discover_destroy(discover_sock);
-        if (ip_addr == 0) {
-                return NULL;
+        unsigned long device_id_raw;
+        if (sscanf(s, "%lx", &device_id_raw) != 1) {
+                fprintf(stderr, "invalid device id: %s\n", s);
+                return FALSE;
         }
 
-        struct hdhomerun_control_sock_t *control_sock = hdhomerun_control_create(ip_addr, 1000);
-        if (!control_sock) {
-                fprintf(stderr, "unable to connect to hdhomerun device\n");
-                return NULL;
+        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;
         }
 
-        return control_sock;
+        *pdevice_id = device_id;
+        *pdevice_ip = 0;
+        return TRUE;
 }
 
-int cmd_get(struct hdhomerun_control_sock_t *control_sock, const char *item)
+static int cmd_get(const char *item)
 {
-        if (hdhomerun_control_send_get_request(control_sock, item) < 0) {
+        char *ret_value;
+        char *ret_error;
+        if (hdhomerun_device_get_var(hd, item, &ret_value, &ret_error) < 0) {
                 fprintf(stderr, "communication error sending request to hdhomerun device\n");
-                return 1;
+                return -1;
         }
 
-        struct hdhomerun_control_data_t result;
-        if (hdhomerun_control_recv(control_sock, &result, 1000) <= 0) {
-                fprintf(stderr, "communication error receiving response from hdhomerun device\n");
-                return 1;
+        if (ret_error) {
+                printf("%s\n", ret_error);
+                return 0;
         }
-        if (result.type != HDHOMERUN_TYPE_GETSET_RPY) {
-                fprintf(stderr, "unexpected reply type from hdhomerun device\n");
-                return 1;
-        }
 
-        while (result.ptr < result.end) {
-                unsigned char tag;
-                int length;
-                unsigned char *value;
-                if (hdhomerun_read_tlv(&result.ptr, result.end, &tag, &length, &value) < 0) {
-                        break;
-                }
-                switch (tag) {
-                case HDHOMERUN_TAG_ERROR_MESSAGE:
-                case HDHOMERUN_TAG_GETSET_VALUE:
-                        printf("%s\n", (char *)value);
-                        break;
-                }
-        }
-
-        return 0;
+        printf("%s\n", ret_value);
+        return 1;
 }
 
-int cmd_set(struct hdhomerun_control_sock_t *control_sock, const char *item, const char *value)
+static int cmd_set(const char *item, const char *value)
 {
-        if (hdhomerun_control_send_set_request(control_sock, item, value) < 0) {
+        char *ret_error;
+        if (hdhomerun_device_set_var(hd, item, value, NULL, &ret_error) < 0) {
                 fprintf(stderr, "communication error sending request to hdhomerun device\n");
-                return 1;
+                return -1;
         }
 
-        struct hdhomerun_control_data_t result;
-        if (hdhomerun_control_recv(control_sock, &result, 1000) <= 0) {
-                fprintf(stderr, "communication error receiving response from hdhomerun device\n");
-                return 1;
+        if (ret_error) {
+                printf("%s\n", ret_error);
+                return 0;
         }
-        if (result.type != HDHOMERUN_TYPE_GETSET_RPY) {
-                fprintf(stderr, "unexpected reply type from hdhomerun device\n");
-                return 1;
-        }
 
-        while (result.ptr < result.end) {
-                unsigned char tag;
-                int length;
-                unsigned char *value;
-                if (hdhomerun_read_tlv(&result.ptr, result.end, &tag, &length, &value) < 0) {
-                        break;
-                }
-                switch (tag) {
-                case HDHOMERUN_TAG_ERROR_MESSAGE:
-                        printf("%s\n", (char *)value);
-                        break;
-                }
-        }
-
-        return 0;
+        return 1;
 }
 
-int cmd_scan(struct hdhomerun_control_sock_t *control_sock, const char *tuner_str, const char *start_value)
+static int cmd_streaminfo(const char *tuner_str)
 {
-        int tuner = atoi(tuner_str);
+        fprintf(stderr, "streaminfo: use \"get /tuner<n>/streaminfo\"\n");
+        return -1;
+}
 
-        /* Test starting channel. */
-        char item[64];
-        sprintf(item, "/tuner%d/channel", tuner);
-        int ret = cmd_set(control_sock, item, start_value);
-        if (ret != 0) {
-                return ret;
+static int cmd_scan(const char *tuner_str, const char *start_value)
+{
+        unsigned int tuner;
+        if (sscanf(tuner_str, "%u", &tuner) != 1) {
+                fprintf(stderr, "invalid tuner number\n");
+                return -1;
         }
 
-        char channel_value[64];
-        strncpy(channel_value, start_value, sizeof(channel_value));
-        channel_value[sizeof(channel_value) - 8] = 0;
+        hdhomerun_device_set_tuner(hd, tuner);
 
-        char *ptr = strrchr(channel_value, ':');
-        if (!ptr) {
-                ptr = channel_value;
+        char channel_str[64];
+        strncpy(channel_str, start_value, sizeof(channel_str));
+        channel_str[sizeof(channel_str) - 8] = 0;
+
+        char *channel_number_ptr = strrchr(channel_str, ':');
+        if (!channel_number_ptr) {
+                channel_number_ptr = channel_str;
         } else {
-                ptr++;
+                channel_number_ptr++;
         }
 
-        int channel = atol(ptr);
-        if (channel == 0) {
+        unsigned int channel_number = atol(channel_number_ptr);
+        if (channel_number == 0) {
                 fprintf(stderr, "invalid starting channel\n");
-                return 1;
+                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");
+                return -1;
+        }
+        if (ret == 0) {
+                fprintf(stderr, "invalid starting channel\n");
+                return -1;
+        }
+
         while (1) {
                 /* Update channel value */
-                sprintf(ptr, "%d", channel);
+                sprintf(channel_number_ptr, "%u", channel_number);
 
                 /* Set channel. */
-                sprintf(item, "/tuner%d/channel", tuner);
-                if (hdhomerun_control_send_set_request(control_sock, item, channel_value) < 0) {
+                ret = hdhomerun_device_set_tuner_channel(hd, channel_str);
+                if (ret < 0) {
                         fprintf(stderr, "communication error sending request to hdhomerun device\n");
-                        return 1;
+                        return -1;
                 }
-        
-                /* Verify set succeeded. */
-                struct hdhomerun_control_data_t result;
-                if (hdhomerun_control_recv(control_sock, &result, 1000) <= 0) {
-                        fprintf(stderr, "communication error receiving response from hdhomerun device\n");
-                        return 1;
+                if (ret == 0) {
+                        return 0;
                 }
-                if (result.type != HDHOMERUN_TYPE_GETSET_RPY) {
-                        fprintf(stderr, "unexpected reply type from hdhomerun device\n");
-                        return 1;
-                }
-                while (result.ptr < result.end) {
-                        unsigned char tag;
-                        int length;
-                        unsigned char *value;
-                        if (hdhomerun_read_tlv(&result.ptr, result.end, &tag, &length, &value) < 0) {
-                                break;
-                        }
-                        if (tag == HDHOMERUN_TAG_ERROR_MESSAGE) {
-                                return 0;
-                        }
-                }
 
-                /* Wait for 1s. */
-                sleep(1);
+                /* Wait 1.5s for lock (qam auto is the slowest to lock). */
+                usleep(HDHOMERUN_DEVICE_MAX_TUNE_TO_LOCK_TIME * 1000);
 
-                /* Get status. */
-                sprintf(item, "/tuner%d/status", tuner);
-                if (hdhomerun_control_send_get_request(control_sock, item) < 0) {
+                /* 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;
+                        return -1;
                 }
 
-                /* Status result. */
-                if (hdhomerun_control_recv(control_sock, &result, 1000) <= 0) {
-                        fprintf(stderr, "communication error receiving response from hdhomerun device\n");
-                        return 1;
+                /* If no signal then advance to next channel. */
+                if (status.signal_strength == 0) {
+                        printf("%s: no signal\n", channel_str);
+                        channel_number++;
+                        continue;
                 }
-                if (result.type != HDHOMERUN_TYPE_GETSET_RPY) {
-                        fprintf(stderr, "unexpected reply type from hdhomerun device\n");
-                        return 1;
+
+                /* Wait for 2s. */
+                usleep(HDHOMERUN_DEVICE_MAX_LOCK_TO_DATA_TIME * 1000);
+
+                /* Get status to check quality numbers. */
+                if (hdhomerun_device_get_tuner_status(hd, &status) < 0) {
+                        fprintf(stderr, "communication error sending request to hdhomerun device\n");
+                        return -1;
                 }
-                char *status = NULL;
-                while (result.ptr < result.end) {
-                        unsigned char tag;
-                        int length;
-                        unsigned char *value;
-                        if (hdhomerun_read_tlv(&result.ptr, result.end, &tag, &length, &value) < 0) {
-                                break;
-                        }
-                        if (tag == HDHOMERUN_TAG_ERROR_MESSAGE) {
-                                return 0;
-                        }
-                        if (tag == HDHOMERUN_TAG_GETSET_VALUE) {
-                                status = (char *)value;
-                        }
+                if (status.signal_strength == 0) {
+                        printf("%s: no signal\n", channel_str);
+                        channel_number++;
+                        continue;
                 }
-                if (!status) {
-                        fprintf(stderr, "unexpected reply type from hdhomerun device\n");
-                        return 1;
-                }
+                printf("%s: ss=%u snq=%u seq=%u\n", channel_str, status.signal_strength, status.signal_to_noise_quality, status.symbol_error_quality);
 
-                /* If no signal then advance to next channel. */
-                char *ss_str = strstr(status, "ss=");
-                if (!ss_str) {
-                        printf("%s\n", status);
-                        channel++;
+                /* Detect sub channels. */
+                usleep(4 * 1000000);
+                char *streaminfo;
+                if (hdhomerun_device_get_tuner_streaminfo(hd, &streaminfo) <= 0) {
+                        channel_number++;
                         continue;
                 }
-                int ss = atoi(ss_str + strlen("ss="));
-                if (ss == 0) {
-                        printf("%s\n", status);
-                        channel++;
-                        continue;
-                }
+                while (1) {
+                        char *end = strchr(streaminfo, '\n');
+                        if (!end) {
+                                break;
+                        }
 
-                /* Wait for 2s. */
-                sleep(2);
+                        *end++ = 0;
+                        printf("program %s\n", streaminfo);
 
-                /* Display channel status. */
-                cmd_get(control_sock, item);
+                        streaminfo = end;
+                }
 
                 /* Advance to next channel. */
-                channel++;
+                channel_number++;
         }
 }
 
-int cmd_upgrade(struct hdhomerun_control_sock_t *control_sock, const char *filename)
+static int cmd_upgrade(const char *filename)
 {
         FILE *fp = fopen(filename, "rb");
         if (!fp) {
                 fprintf(stderr, "unable to open file %s\n", filename);
-                return 1;
+                return -1;
         }
 
-        unsigned long sequence = 0;
-        while (1) {
-                unsigned char data[256];
-                int length = fread(data, 1, 256, fp);
-                if (length == 0) {
-                        break;
-                }
-
-                int ret = hdhomerun_control_send_upgrade_request(control_sock, sequence, data, length);
-                if (ret < 0) {
-                        fprintf(stderr, "communication error sending upgrade request to hdhomerun device\n");
-                        fclose(fp);
-                        return 1;
-                }
-
-                sequence += length;
+        if (hdhomerun_device_upgrade(hd, fp) <= 0) {
+                fprintf(stderr, "error sending upgrade file to hdhomerun device\n");
+                fclose(fp);
+                return -1;
         }
 
-        fclose(fp);
-        if (sequence == 0) {
-                fprintf(stderr, "upgrade file does not contain data\n");
-                return 1;
-        }
-
-        int ret = hdhomerun_control_send_upgrade_request(control_sock, 0xFFFFFFFF, NULL, 0);
-        if (ret < 0) {
-                fprintf(stderr, "communication error sending upgrade request to hdhomerun device\n");
-                return 1;
-        }
-
         printf("upgrade complete\n");
         return 0;
 }
 
-int main_cmd(struct hdhomerun_control_sock_t *control_sock, int argc, char *argv[])
+static int main_cmd(int argc, char *argv[])
 {
         if (argc < 1) {
                 return help();
@@ -414 +298 @@
                 if (argc < 1) {
                         return help();
                 }
-                return cmd_get(control_sock, argv[0]);
+                return cmd_get(argv[0]);
         }
 
         if (contains(cmd, "set")) {
                 if (argc < 2) {
                         return help();
                 }
-                return cmd_set(control_sock, argv[0], argv[1]);
+                return cmd_set(argv[0], argv[1]);
         }
 
+        if (contains(cmd, "streaminfo")) {
+                if (argc < 1) {
+                        return help();
+                }
+                return cmd_streaminfo(argv[0]);
+        }
+
         if (contains(cmd, "scan")) {
                 if (argc < 2) {
                         return help();
                 }
-                return cmd_scan(control_sock, argv[0], argv[1]);
+                return cmd_scan(argv[0], argv[1]);
         }
 
         if (contains(cmd, "upgrade")) {
                 if (argc < 1) {
                         return help();
                 }
-                return cmd_upgrade(control_sock, argv[0]);
+                return cmd_upgrade(argv[0]);
         }
 
         return help();
 }
 
-int main(int argc, char *argv[])
+static int main_internal(int argc, char *argv[])
 {
-        extract_appname(argv[0]);
+#if defined(__WINDOWS__)
+        //Start pthreads
+        pthread_win32_process_attach_np();
 
+        // Start WinSock
+        WORD wVersionRequested = MAKEWORD(2, 0);
+        WSADATA wsaData;
+        WSAStartup(wVersionRequested, &wsaData);
+#endif
+
+        extract_appname(argv[0]);
         argv++;
         argc--;
 
@@ -460 +360 @@
                 return discover_print();
         }
 
-        struct hdhomerun_control_sock_t *control_sock = create_control_sock(id_str);
-        if (!control_sock) {
-                return 1;
+        /* Device ID. */
+        uint32_t device_id, device_ip;
+        if (!parse_device_id_str(id_str, &device_id, &device_ip)) {
+                return -1;
         }
 
-        int ret = main_cmd(control_sock, argc, argv);
-        hdhomerun_control_destroy(control_sock);
+        /* Device object. */
+        hd = hdhomerun_device_create(device_id, device_ip, 0);
+        if (!hd) {
+                fprintf(stderr, "unable to create device\n");
+                return -1;
+        }
+
+        /* Connect to device and check firmware version. */
+        int ret = hdhomerun_device_firmware_version_check(hd, 0);
+        if (ret < 0) {
+                fprintf(stderr, "unable to connect to device\n");
+                hdhomerun_device_destroy(hd);
+                return -1;
+        }
+        if (ret == 0) {
+                fprintf(stderr, "WARNING: firmware upgrade needed for all operations to function\n");
+        }
+
+        /* Command. */
+        ret = main_cmd(argc, argv);
+
+        /* Cleanup. */
+        hdhomerun_device_destroy(hd);
+
+        /* Complete. */
         return ret;
 }
+
+int main(int argc, char *argv[])
+{
+        int ret = main_internal(argc, argv);
+        if (ret <= 0) {
+                return 1;
+        }
+        return 0;
+}

libs/libmythtv/hdhomerun/hdhomerun_video.c

@@ -21 +21 @@
 #include "hdhomerun_os.h"
 #include "hdhomerun_pkt.h"
 #include "hdhomerun_video.h"
-#include <pthread.h>
 
 struct hdhomerun_video_sock_t {
-        unsigned char *buffer;
-        unsigned long buffer_size;
-        volatile unsigned long head;
-        volatile unsigned long tail;
-        unsigned long advance;
-        volatile int running;
-        volatile int terminate;
+        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;
 };
 
 static void *hdhomerun_video_thread(void *arg);
 
-struct hdhomerun_video_sock_t *hdhomerun_video_create(unsigned long buffer_size, unsigned long timeout)
+static bool_t hdhomerun_video_bind_sock_internal(struct hdhomerun_video_sock_t *vs, uint16_t listen_port)
 {
-        /* Buffer size. */
-        buffer_size = (buffer_size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE;
-        if (buffer_size == 0) {
-                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) {
+                return FALSE;
         }
-        buffer_size += VIDEO_DATA_PACKET_SIZE;
+        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) {
                 return NULL;
         }
 
+        /* Buffer size. */
+        vs->buffer_size = (buffer_size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE;
+        if (vs->buffer_size == 0) {
+                free(vs);
+                return NULL;
+        }
+        vs->buffer_size += VIDEO_DATA_PACKET_SIZE;
+
         /* Create buffer. */
-        vs->buffer_size = buffer_size;
-        vs->buffer = (unsigned char *)malloc(buffer_size);
+        vs->buffer = (uint8_t *)malloc(vs->buffer_size);
         if (!vs->buffer) {
                 free(vs);
                 return NULL;
         }
         
         /* Create socket. */
-        vs->sock = socket(AF_INET, SOCK_DGRAM, 0);
+        vs->sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
         if (vs->sock == -1) {
                 free(vs->buffer);
                 free(vs);
                 return NULL;
         }
 
-        /* Set buffer size. */
-        unsigned long rx_size = 1024 * 1024;
-        setsockopt(vs->sock, SOL_SOCKET, SO_RCVBUF, &rx_size, sizeof(rx_size));
+        /* Expand socket buffer size. */
+        int rx_size = 1024 * 1024;
+        setsockopt(vs->sock, SOL_SOCKET, SO_RCVBUF, (char *)&rx_size, sizeof(rx_size));
 
-        /* Set timeout. */
-        struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
-        setsockopt(vs->sock, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t));
+        /* Set timeouts. */
+        setsocktimeout(vs->sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
+        setsocktimeout(vs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
 
         /* Bind socket. */
-        struct sockaddr_in sock_addr;
-        memset(&sock_addr, 0, sizeof(sock_addr));
-        sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
-        sock_addr.sin_port = htons(0);
-        if (bind(vs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
+        if (!hdhomerun_video_bind_sock(vs, listen_port)) {
                 hdhomerun_video_destroy(vs);
                 return NULL;
         }
@@ -111 +139 @@
         free(vs);
 }
 
-unsigned short hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs)
+uint16_t hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs)
 {
         struct sockaddr_in sock_addr;
         socklen_t sockaddr_size = sizeof(sock_addr);
@@ -121 +149 @@
         return ntohs(sock_addr.sin_port);
 }
 
-int hdhomerun_video_get_state(struct hdhomerun_video_sock_t *vs)
-{
-        if (vs->terminate) {
-                return 0;
-        }
-        return 1;
-}
-
 int hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs)
 {
         return vs->sock;
@@ -139 +159 @@
         struct hdhomerun_video_sock_t *vs = (struct hdhomerun_video_sock_t *)arg;
 
         while (!vs->terminate) {
-                unsigned long head = vs->head;
+                size_t head = vs->head;
 
                 /* Receive. */
-                int length = recv(vs->sock, vs->buffer + head, VIDEO_DATA_PACKET_SIZE, 0);
+                int length = recv(vs->sock, (char *)vs->buffer + head, VIDEO_DATA_PACKET_SIZE, 0);
                 if (length != VIDEO_DATA_PACKET_SIZE) {
                         if (length > 0) {
                                 /* Data received but not valid - ignore. */
                                 continue;
                         }
-                        if (errno == EAGAIN) {
+                        if (sock_getlasterror_socktimeout) {
                                 /* Wait for more data. */
                                 continue;
                         }
@@ -174 +194 @@
         return NULL;
 }
 
-static void hdhomerun_copy_and_advance_tail(struct hdhomerun_video_sock_t *vs, unsigned char *buffer, unsigned long size)
+uint8_t *hdhomerun_video_recv(struct hdhomerun_video_sock_t *vs, size_t max_size, size_t *pactual_size)
 {
-        unsigned long tail = vs->tail;
-        memcpy(buffer, vs->buffer + tail, size);
+        size_t head = vs->head;
+        size_t tail = vs->tail;
 
-        tail += size;
-        if (tail >= vs->buffer_size) {
-                tail -= vs->buffer_size;
-        }
-
-        /* Atomic update. */
-        vs->tail = tail;
-}
-
-unsigned long hdhomerun_video_available_length(struct hdhomerun_video_sock_t *vs)
-{
-        unsigned long head = vs->head;
-        unsigned long tail = vs->tail;
-
-        if (head >= tail) {
-                return head - tail - vs->advance;
-        } else {
-                return head + vs->buffer_size - tail - vs->advance;
-        }
-}
-
-unsigned long hdhomerun_video_recv_memcpy(struct hdhomerun_video_sock_t *vs, unsigned char *buffer, unsigned long size)
-{
-        unsigned long head = vs->head;
-        unsigned long tail = vs->tail;
-
-        if (head == tail) {
-                return 0;
-        }
-
-        size = (size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE;
-
-        /* Straight memcpy case. */
-        if (head > tail) {
-                unsigned long avail = head - tail;
-                if (size > avail) {
-                        size = avail;
-                }
-                hdhomerun_copy_and_advance_tail(vs, buffer, size);
-                return size;
-        }
-
-        /* Memcpy with wrap around check. */
-        unsigned long avail = vs->buffer_size - tail;
-        if (avail >= size) {
-                hdhomerun_copy_and_advance_tail(vs, buffer, size);
-                return size;
-        }
-
-        /* Memcpy with wrap around. */
-        hdhomerun_copy_and_advance_tail(vs, buffer, avail);
-        return avail + hdhomerun_video_recv_memcpy(vs, buffer + avail, size - avail);
-}
-
-unsigned char *hdhomerun_video_recv_inplace(struct hdhomerun_video_sock_t *vs, unsigned long max_size, unsigned long *pactual_size)
-{
-        unsigned long head = vs->head;
-        unsigned long tail = vs->tail;
-
         if (vs->advance > 0) {
                 tail += vs->advance;
                 if (tail >= vs->buffer_size) {
@@ -254 +215 @@
                 return NULL;
         }
 
-        unsigned long size = (max_size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE;
+        size_t size = (max_size / VIDEO_DATA_PACKET_SIZE) * VIDEO_DATA_PACKET_SIZE;
+        if (size == 0) {
+                vs->advance = 0;
+                *pactual_size = 0;
+                return NULL;
+        }
 
-        unsigned long avail;
+        size_t avail;
         if (head > tail) {
                 avail = head - tail;
         } else {
@@ -274 +240 @@
 {
         /* Atomic update of tail. */
         vs->tail = vs->head;
+        vs->advance = 0;
 }
+

libs/libmythtv/hdhomerun/hdhomerun_video.h

@@ -23 +23 @@
 
 struct hdhomerun_video_sock_t;
 
+#define TS_PACKET_SIZE 188
 #define VIDEO_DATA_PACKET_SIZE (188 * 7)
 #define VIDEO_DATA_BUFFER_SIZE_1S (20000000 / 8)
 
-extern struct hdhomerun_video_sock_t *hdhomerun_video_create(unsigned long buffer_size, unsigned long timeout);
+/*
+ * 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. 
+ *
+ * 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 unsigned short hdhomerun_video_get_local_port(struct hdhomerun_video_sock_t *vs);
-extern int hdhomerun_video_get_state(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);
+
+/*
+ * Get the low-level socket handle.
+ */
 extern int hdhomerun_video_get_sock(struct hdhomerun_video_sock_t *vs);
-extern unsigned long hdhomerun_video_available_length(struct hdhomerun_video_sock_t *vs);
-extern unsigned long hdhomerun_video_recv_memcpy(struct hdhomerun_video_sock_t *vs, unsigned char *buffer, unsigned long size);
-extern unsigned char *hdhomerun_video_recv_inplace(struct hdhomerun_video_sock_t *vs, unsigned long max_size, unsigned long *pactual_size);
+
+/*
+ * Read data from buffer.
+ *
+ * size_t max_size: The maximum amount of data to be returned.
+ * size_t *pactual_size: The caller-supplied pactual_size value will be updated to contain the amount
+ *              of data available to the caller.
+ *
+ * Returns a pointer to the data, or NULL if no data is available.
+ * The data will remain valid until another call to hdhomerun_video_recv.
+ *
+ * The amount of data returned will always be a multiple of VIDEO_DATA_PACKET_SIZE (1316).
+ * Attempting to read a single TS frame (188 bytes) will not return data as it is less than
+ * the minimum size.
+ *
+ * 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);
+
+/*
+ * Flush the buffer.
+ */
 extern void hdhomerun_video_flush(struct hdhomerun_video_sock_t *vs);
 
 #ifdef __cplusplus

libs/libmythtv/hdhomerun/hdhomerun_discover.c

@@ -22 +22 @@
 #include "hdhomerun_pkt.h"
 #include "hdhomerun_discover.h"
 
-#if defined(__CYGWIN__)
+#if defined(__CYGWIN__) || defined(__WINDOWS__)
 #include <windows.h>
 #include <iptypes.h>
 #include <iphlpapi.h>
@@ -32 +32 @@
         int sock;
 };
 
-struct hdhomerun_discover_sock_t *hdhomerun_discover_create(unsigned long timeout)
+static struct hdhomerun_discover_sock_t *hdhomerun_discover_create(void)
 {
         struct hdhomerun_discover_sock_t *ds = (struct hdhomerun_discover_sock_t *)malloc(sizeof(struct hdhomerun_discover_sock_t));
         if (!ds) {
@@ -40 +40 @@
         }
         
         /* Create socket. */
-        ds->sock = socket(AF_INET, SOCK_DGRAM, 0);
+        ds->sock = (int)socket(AF_INET, SOCK_DGRAM, 0);
         if (ds->sock == -1) {
                 free(ds);
                 return NULL;
         }
 
-        /* Set timeout. */
-        struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
-        setsockopt(ds->sock, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t));
+        /* Set timeouts. */
+        setsocktimeout(ds->sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
+        setsocktimeout(ds->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
 
         /* Allow broadcast. */
         int sock_opt = 1;
@@ -63 +61 @@
         sock_addr.sin_addr.s_addr = htonl(INADDR_ANY);
         sock_addr.sin_port = htons(0);
         if (bind(ds->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                hdhomerun_discover_destroy(ds);
+                close(ds->sock);
+                free(ds);
                 return NULL;
         }
 
@@ -71 +70 @@
         return ds;
 }
 
-void hdhomerun_discover_destroy(struct hdhomerun_discover_sock_t *ds)
+static void hdhomerun_discover_destroy(struct hdhomerun_discover_sock_t *ds)
 {
         close(ds->sock);
         free(ds);
 }
 
-static int hdhomerun_discover_send_packet(struct hdhomerun_discover_sock_t *ds, unsigned long ip_addr, unsigned long device_type, unsigned long device_id)
+static int hdhomerun_discover_send_packet(struct hdhomerun_discover_sock_t *ds, uint32_t ip_addr, uint32_t device_type, uint32_t device_id)
 {
-        unsigned char buffer[1024];
-        unsigned char *ptr = buffer;
+        uint8_t buffer[1024];
+        uint8_t *ptr = buffer;
         hdhomerun_write_discover_request(&ptr, device_type, device_id);
 
         struct sockaddr_in sock_addr;
@@ -89 +88 @@
         sock_addr.sin_addr.s_addr = htonl(ip_addr);
         sock_addr.sin_port = htons(HDHOMERUN_DISCOVER_UDP_PORT);
 
-        int length = ptr - buffer;
-        if (sendto(ds->sock, (char *)buffer, length, 0, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != length) {
+        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(__CYGWIN__)
-static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id)
+#if 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));
-        unsigned long ulOutBufLen = sizeof(IP_ADAPTER_INFO);
+        ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
 
         DWORD Ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
         if (Ret != NO_ERROR) {
@@ -117 +116 @@
                 }
         }
 
-        int send_count = 0;
+        unsigned int send_count = 0;
         PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
         while (pAdapter) {
                 IP_ADDR_STRING *pIPAddr = &pAdapter->IpAddressList;
                 while (pIPAddr) {
-                        unsigned long addr = ntohl(inet_addr(pIPAddr->IpAddress.String));
-                        unsigned long mask = ntohl(inet_addr(pIPAddr->IpMask.String));
+                        uint32_t addr = ntohl(inet_addr(pIPAddr->IpAddress.String));
+                        uint32_t mask = ntohl(inet_addr(pIPAddr->IpMask.String));
                         
-                        unsigned long broadcast = addr | ~mask;
+                        uint32_t broadcast = addr | ~mask;
                         if ((broadcast == 0x00000000) || (broadcast == 0xFFFFFFFF)) {
                                 pIPAddr = pIPAddr->Next;
                                 continue;
                         }
 
-                        hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id);
+                        if (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) {
+                                pIPAddr = pIPAddr->Next;
+                                continue;
+                        }
+
                         send_count++;
 
                         pIPAddr = pIPAddr->Next;
@@ -150 +153 @@
 #endif
 
 #if defined(__linux__)
-static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id)
+static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id)
 {
         FILE *fp = fopen("/proc/net/route", "r");
         if (!fp) {
                 return -1;
         }
 
-        int send_count = 0;
+        unsigned int send_count = 0;
         while (1) {
                 char line[256];
                 if (!fgets(line, sizeof(line), fp)) {
@@ -165 +168 @@
                 }
                 line[255] = 0;
 
-                unsigned long dest;
-                unsigned long mask;
-                if (sscanf(line, "%*s %lx %*x %*x %*d %*d %*d %lx", &dest, &mask) != 2) {
+                uint32_t dest;
+                uint32_t mask;
+                if (sscanf(line, "%*s %x %*x %*x %*d %*d %*d %x", &dest, &mask) != 2) {
                         continue;
                 }
                 dest = ntohl(dest);
                 mask = ntohl(mask);
                 
-                unsigned long broadcast = dest | ~mask;
+                uint32_t broadcast = dest | ~mask;
 
                 if ((broadcast == 0x00000000) || (broadcast == 0xFFFFFFFF)) {
                         continue;
                 }
 
-                hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id);
+                if (hdhomerun_discover_send_packet(ds, broadcast, device_type, device_id) < 0) {
+                        continue;
+                }
+
                 send_count++;
         }
 
@@ -191 +197 @@
 }
 #endif
 
-#if !defined(__CYGWIN__) && !defined(__linux__)
-static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id)
+#if !defined(__CYGWIN__) && !defined(__WINDOWS__) && !defined(__linux__)
+static int hdhomerun_discover_send_internal(struct hdhomerun_discover_sock_t *ds, uint32_t device_type, uint32_t device_id)
 {
         return -1;
 }
 #endif
 
-int hdhomerun_discover_send(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id)
+static int hdhomerun_discover_send(struct hdhomerun_discover_sock_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);
@@ -206 +212 @@
         return 0;
 }
 
-int hdhomerun_discover_recv(struct hdhomerun_discover_sock_t *ds, struct hdhomerun_discover_device_t *result, unsigned long timeout)
+static int hdhomerun_discover_recv(struct hdhomerun_discover_sock_t *ds, struct hdhomerun_discover_device_t *result)
 {
         struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
+        t.tv_sec = 0;
+        t.tv_usec = 250000;
 
         fd_set readfds;
         FD_ZERO(&readfds);
@@ -223 +229 @@
                 return 0;
         }
 
-        unsigned char buffer[1024];
+        uint8_t buffer[1024];
         struct sockaddr_in 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);
         if (rx_length <= 0) {
-                return -1;
+                /* 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;
         }
-        int length = hdhomerun_peek_packet_length(buffer);
-        if (rx_length < length) {
+
+        size_t length = hdhomerun_peek_packet_length(buffer);
+        if (length > (size_t)rx_length) {
                 return 0;
         }
 
-        unsigned char *ptr = buffer;
-        unsigned char *end = buffer + length;
+        uint8_t *ptr = buffer;
+        uint8_t *end = buffer + length;
         int type = hdhomerun_process_packet(&ptr, &end);
         if (type != HDHOMERUN_TYPE_DISCOVER_RPY) {
                 return 0;
@@ -249 +257 @@
         result->device_type = 0;
         result->device_id = 0;
         while (1) {
-                unsigned char tag;
-                int len;
-                unsigned char *value;
+                uint8_t tag;
+                size_t len;
+                uint8_t *value;
                 if (hdhomerun_read_tlv(&ptr, end, &tag, &len, &value) < 0) {
                         break;
                 }
@@ -277 +285 @@
         return 1;
 }
 
-int hdhomerun_discover_validate_device_id(unsigned long device_id)
+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 unsigned long lookup_table[16] = {0xA, 0x5, 0xF, 0x6, 0x7, 0xC, 0x1, 0xB, 0x9, 0x2, 0x8, 0xD, 0x4, 0x3, 0xE, 0x0};
+        int index;
+        for (index = 0; index < count; index++) {
+                struct hdhomerun_discover_device_t *result = &result_list[index];
+                if (result->device_id == device_id) {
+                        return result;
+                }
+        }
 
-        unsigned long checksum = 0;
+        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)
+{
+        int count = 0;
+
+        int attempt;
+        for (attempt = 0; attempt < 4; attempt++) {
+                if (hdhomerun_discover_send(ds, device_type, device_id) < 0) {
+                        return -1;
+                }
+
+                uint64_t timeout = getcurrenttime() + 250;
+                while (getcurrenttime() < timeout) {
+                        struct hdhomerun_discover_device_t *result = &result_list[count];
+
+                        int ret = hdhomerun_discover_recv(ds, result);
+                        if (ret < 0) {
+                                return -1;
+                        }
+                        if (ret == 0) {
+                                break;
+                        }
+
+                        /* Filter. */
+                        if (device_type != HDHOMERUN_DEVICE_TYPE_WILDCARD) {
+                                if (device_type != result->device_type) {
+                                        continue;
+                                }
+                        }
+                        if (device_id != HDHOMERUN_DEVICE_ID_WILDCARD) {
+                                if (device_id != result->device_id) {
+                                        continue;
+                                }
+                        }
+
+                        /* Ensure not already in list. */
+                        if (hdhomerun_discover_find_in_list(result_list, count, result->device_id)) {
+                                continue;
+                        }
+
+                        /* Add to list. */
+                        count++;
+                        if (count >= max_count) {
+                                return count;
+                        }
+                }
+        }
+
+        return count;
+}
+
+int hdhomerun_discover_find_device(uint32_t device_id, struct hdhomerun_discover_device_t *result)
+{
+        struct hdhomerun_discover_sock_t *ds = hdhomerun_discover_create();
+        if (!ds) {
+                return -1;
+        }
+
+        int ret = hdhomerun_discover_find_devices_internal(ds, HDHOMERUN_DEVICE_TYPE_WILDCARD, device_id, result, 1);
+
+        hdhomerun_discover_destroy(ds);
+        return ret;
+}
+
+int hdhomerun_discover_find_devices(uint32_t device_type, struct hdhomerun_discover_device_t result_list[], int max_count)
+{
+        struct hdhomerun_discover_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};
+
+        uint32_t checksum = 0;
+
         checksum ^= lookup_table[(device_id >> 28) & 0x0F];
         checksum ^= (device_id >> 24) & 0x0F;
         checksum ^= lookup_table[(device_id >> 20) & 0x0F];
@@ -294 +391 @@
 
         return (checksum == 0);
 }
+

libs/libmythtv/hdhomerun/hdhomerun_control.c

@@ -20 +20 @@
 
 #include "hdhomerun_os.h"
 #include "hdhomerun_pkt.h"
+#include "hdhomerun_discover.h"
 #include "hdhomerun_control.h"
 
 struct hdhomerun_control_sock_t {
+        uint32_t device_id;
+        uint32_t device_ip;
         int sock;
-        unsigned char rx_buffer[1024];
-        unsigned char *rx_pos;
-        unsigned char *rx_end;
+        uint8_t buffer[16384];
 };
 
-struct hdhomerun_control_sock_t *hdhomerun_control_create(unsigned long ip_addr, unsigned long timeout)
+struct hdhomerun_control_sock_t *hdhomerun_control_create(uint32_t device_id, uint32_t device_ip)
 {
         struct hdhomerun_control_sock_t *cs = (struct hdhomerun_control_sock_t *)malloc(sizeof(struct hdhomerun_control_sock_t));
         if (!cs) {
                 return NULL;
         }
         
+        cs->device_id = device_id;
+        cs->device_ip = device_ip;
+        cs->sock = -1;
+
+        return cs;
+}
+
+void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs)
+{
+        if (cs->sock != -1) {
+                close(cs->sock);
+        }
+        free(cs);
+}
+
+static void hdhomerun_control_close_sock(struct hdhomerun_control_sock_t *cs)
+{
+        close(cs->sock);
+        cs->sock = -1;
+}
+
+static bool_t hdhomerun_control_connect_sock(struct hdhomerun_control_sock_t *cs)
+{
+        if (cs->sock != -1) {
+                return TRUE;
+        }
+
+        /* Find ip address. */
+        uint32_t device_ip = cs->device_ip;
+        if (device_ip == 0) {
+                struct hdhomerun_discover_device_t result;
+                if (hdhomerun_discover_find_device(cs->device_id, &result) <= 0) {
+                        return FALSE;
+                }
+                device_ip = result.ip_addr;
+        }
+
         /* Create socket. */
-        cs->sock = socket(AF_INET, SOCK_STREAM, 0);
+        cs->sock = (int)socket(AF_INET, SOCK_STREAM, 0);
         if (cs->sock == -1) {
-                free(cs);
-                return NULL;
+                return FALSE;
         }
 
-        /* Set timeout. */
-        struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
-        setsockopt(cs->sock, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t));
+        /* Set timeouts. */
+        setsocktimeout(cs->sock, SOL_SOCKET, SO_SNDTIMEO, 1000);
+        setsocktimeout(cs->sock, SOL_SOCKET, SO_RCVTIMEO, 1000);
 
         /* Initiate connection. */
         struct sockaddr_in sock_addr;
         memset(&sock_addr, 0, sizeof(sock_addr));
         sock_addr.sin_family = AF_INET;
-        sock_addr.sin_addr.s_addr = htonl(ip_addr);
+        sock_addr.sin_addr.s_addr = htonl(device_ip);
         sock_addr.sin_port = htons(HDHOMERUN_CONTROL_TCP_PORT);
         if (connect(cs->sock, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) {
-                hdhomerun_control_destroy(cs);
-                return NULL;
+                hdhomerun_control_close_sock(cs);
+                return FALSE;
         }
 
         /* Success. */
-        cs->rx_pos = cs->rx_buffer;
-        cs->rx_end = cs->rx_buffer + sizeof(cs->rx_buffer);
-        return cs;
+        return TRUE;
 }
 
-void hdhomerun_control_destroy(struct hdhomerun_control_sock_t *cs)
+uint32_t hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs)
 {
-        close(cs->sock);
-        free(cs);
-}
+        if (!hdhomerun_control_connect_sock(cs)) {
+                return 0;
+        }
 
-unsigned long hdhomerun_control_get_local_addr(struct hdhomerun_control_sock_t *cs)
-{
         struct sockaddr_in sock_addr;
         socklen_t sockaddr_size = sizeof(sock_addr);
         if (getsockname(cs->sock, (struct sockaddr*)&sock_addr, &sockaddr_size) != 0) {
                 return 0;
         }
+
         return ntohl(sock_addr.sin_addr.s_addr);
 }
 
-int hdhomerun_control_send(struct hdhomerun_control_sock_t *cs, unsigned char *start, unsigned char *end)
+static int hdhomerun_control_send(struct hdhomerun_control_sock_t *cs, uint8_t *start, uint8_t *end)
 {
-        int length = end - start;
-        if (send(cs->sock, (char *)start, length, 0) != length) {
+        int length = (int)(end - start);
+        if (send(cs->sock, (char *)start, (int)length, 0) != length) {
                 return -1;
         }
-        return 0;
-}
 
-int hdhomerun_control_send_get_request(struct hdhomerun_control_sock_t *cs, const char *name)
-{
-        unsigned char buffer[1024];
-        unsigned char *ptr = buffer;
-        hdhomerun_write_get_request(&ptr, name);
-        return hdhomerun_control_send(cs, buffer, ptr);
+        return length;
 }
 
-int hdhomerun_control_send_set_request(struct hdhomerun_control_sock_t *cs, const char *name, const char *value)
+static int hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, uint8_t *buffer, uint8_t *limit)
 {
-        unsigned char buffer[1024];
-        unsigned char *ptr = buffer;
-        hdhomerun_write_set_request(&ptr, name, value);
-        return hdhomerun_control_send(cs, buffer, ptr);
-}
+        struct timeval t;
+        t.tv_sec = 0;
+        t.tv_usec = 250000;
 
-int hdhomerun_control_send_upgrade_request(struct hdhomerun_control_sock_t *cs, unsigned long sequence, void *data, int length)
-{
-        unsigned char buffer[1024 + 64];
-        unsigned char *ptr = buffer;
+        fd_set readfds;
+        FD_ZERO(&readfds);
+        FD_SET(cs->sock, &readfds);
 
-        if (length + 64 > (int)sizeof(buffer)) {
+        if (select(cs->sock+1, &readfds, NULL, NULL, &t) < 0) {
                 return -1;
         }
 
-        hdhomerun_write_upgrade_request(&ptr, sequence, data, length);
-        return hdhomerun_control_send(cs, buffer, ptr);
+        if (!FD_ISSET(cs->sock, &readfds)) {
+                return 0;
+        }
+
+        int length = recv(cs->sock, (char *)buffer, (int)(limit - buffer), 0);
+        if (length <= 0) {
+                return -1;
+        }
+
+        return length;
 }
 
-static int hdhomerun_control_recv_sock(struct hdhomerun_control_sock_t *cs, unsigned long timeout)
+static int hdhomerun_control_recv(struct hdhomerun_control_sock_t *cs, uint8_t *buffer, uint8_t *limit)
 {
-        struct timeval t;
-        t.tv_sec = timeout / 1000;
-        t.tv_usec = (timeout % 1000) * 1000;
+        uint64_t timeout = getcurrenttime() + 1000;
+        uint8_t *ptr = buffer;
 
-        fd_set readfds;
-        FD_ZERO(&readfds);
-        FD_SET(cs->sock, &readfds);
+        while (getcurrenttime() < timeout) {
+                int length = hdhomerun_control_recv_sock(cs, ptr, limit);
+                if (length < 0) {
+                        return -1;
+                }
+                if (length == 0) {
+                        continue;
+                }
+                ptr += length;
 
-        if (select(cs->sock+1, &readfds, NULL, NULL, &t) < 0) {
+                if (buffer + HDHOMERUN_MIN_PEEK_LENGTH > limit) {
+                        continue;
+                }
+
+                length = (int)hdhomerun_peek_packet_length(buffer);
+                if (buffer + length > limit) {
+                        continue;
+                }
+
+                return length;
+        }
+
+        return -1;
+}
+
+static int hdhomerun_control_get_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror)
+{
+        /* Send request. */
+        uint8_t *ptr = cs->buffer;
+        hdhomerun_write_get_set_request(&ptr, name, value);
+        if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) {
                 return -1;
         }
-        if (!FD_ISSET(cs->sock, &readfds)) {
-                return 0;
+
+        /* Receive response. */
+        int length = hdhomerun_control_recv(cs, cs->buffer, cs->buffer + sizeof(cs->buffer));
+        if (length <= 0) {
+                return -1;
         }
 
-        int rx_length = recv(cs->sock, (char *)cs->rx_pos, cs->rx_end - cs->rx_pos, 0);
-        if (rx_length <= 0) {
+        /* Parse response. */
+        ptr = cs->buffer;
+        uint8_t *end = ptr + length;
+        int type = hdhomerun_process_packet(&ptr, &end);
+        if (type < 0) {
                 return -1;
         }
-        cs->rx_pos += rx_length;
-        return 1;
+        if (type != HDHOMERUN_TYPE_GETSET_RPY) {
+                return -1;
+        }
+
+        while (ptr < end) {
+                uint8_t tag;
+                size_t len;
+                uint8_t *val;
+                if (hdhomerun_read_tlv(&ptr, end, &tag, &len, &val) < 0) {
+                        break;
+                }
+                switch (tag) {
+                case HDHOMERUN_TAG_GETSET_VALUE:
+                        if (pvalue) {
+                                *pvalue = (char *)val;
+                                val[len] = 0;
+                        }
+                        if (perror) {
+                                *perror = NULL;
+                        }
+                        return 1;
+
+                case HDHOMERUN_TAG_ERROR_MESSAGE:
+                        if (pvalue) {
+                                *pvalue = NULL;
+                        }
+                        if (perror) {
+                                *perror = (char *)val;
+                                val[len] = 0;
+                        }
+                        return 0;
+                }
+        }
+
+        return -1;
 }
 
-static int hdhomerun_control_recv_process(struct hdhomerun_control_sock_t *cs, struct hdhomerun_control_data_t *result)
+int hdhomerun_control_get(struct hdhomerun_control_sock_t *cs, const char *name, char **pvalue, char **perror)
 {
-        int rx_length = cs->rx_pos - cs->rx_buffer;
-        if (rx_length < HDHOMERUN_MIN_PEEK_LENGTH) {
-                return 0;
+        if (!hdhomerun_control_connect_sock(cs)) {
+                return -1;
         }
-        int length = hdhomerun_peek_packet_length(cs->rx_buffer);
-        if (rx_length < length) {
-                return 0;
+
+        int ret = hdhomerun_control_get_set(cs, name, NULL, pvalue, perror);
+        if (ret < 0) {
+                hdhomerun_control_close_sock(cs);
+                return -1;
         }
 
-        memcpy(result->buffer, cs->rx_buffer, length);
-        if (rx_length > length) {
-                memcpy(cs->rx_buffer, cs->rx_buffer + length, rx_length - length);
+        return ret;
+}
+
+int hdhomerun_control_set(struct hdhomerun_control_sock_t *cs, const char *name, const char *value, char **pvalue, char **perror)
+{
+        if (!hdhomerun_control_connect_sock(cs)) {
+                return -1;
         }
-        cs->rx_pos = cs->rx_buffer + (rx_length - length);
 
-        result->ptr = result->buffer;
-        result->end = result->buffer + length;
-        result->type = hdhomerun_process_packet(&result->ptr, &result->end);
-        if (result->type < 0) {
+        int ret = hdhomerun_control_get_set(cs, name, value, pvalue, perror);
+        if (ret < 0) {
+                hdhomerun_control_close_sock(cs);
                 return -1;
         }
 
-        return 1;
+        return ret;
 }
 
-int hdhomerun_control_recv(struct hdhomerun_control_sock_t *cs, struct hdhomerun_control_data_t *result, unsigned long timeout)
+int hdhomerun_control_upgrade(struct hdhomerun_control_sock_t *cs, FILE *upgrade_file)
 {
-        int ret = hdhomerun_control_recv_process(cs, result);
-        if (ret != 0) {
-                return ret;
+        if (!hdhomerun_control_connect_sock(cs)) {
+                return -1;
         }
 
-        struct timeval t;
-        gettimeofday(&t, NULL);
-        unsigned long long stop_time = ((unsigned long long)t.tv_sec * 1000) + (t.tv_usec / 1000) + timeout;
+        uint32_t sequence = 0;
+        uint8_t *ptr;
 
         while (1) {
-                ret = hdhomerun_control_recv_sock(cs, timeout);
-                if (ret < 0) {
-                        return ret;
+                uint8_t data[256];
+                size_t length = fread(data, 1, 256, upgrade_file);
+                if (length == 0) {
+                        break;
                 }
-                if (ret == 1) {
-                        ret = hdhomerun_control_recv_process(cs, result);
-                        if (ret != 0) {
-                                return ret;
-                        }
+
+                ptr = cs->buffer;
+                hdhomerun_write_upgrade_request(&ptr, sequence, data, length);
+                if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) {
+                        hdhomerun_control_close_sock(cs);
+                        return -1;
                 }
 
-                gettimeofday(&t, NULL);
-                unsigned long long current_time = ((unsigned long long)t.tv_sec * 1000) + (t.tv_usec / 1000);
-                if (current_time >= stop_time) {
-                        return 0;
-                }
+                sequence += (uint32_t)length;
         }
+
+        if (sequence == 0) {
+                /* No data in file. Error, but no need to close connection. */
+                return 0;
+        }
+
+        ptr = cs->buffer;
+        hdhomerun_write_upgrade_request(&ptr, 0xFFFFFFFF, NULL, 0);
+        if (hdhomerun_control_send(cs, cs->buffer, ptr) < 0) {
+                hdhomerun_control_close_sock(cs);
+                return -1;
+        }
+
+        return 1;
 }

libs/libmythtv/hdhomerun/Makefile

@@ -2 +2 @@
 SRCS += hdhomerun_pkt.c
 SRCS += hdhomerun_discover.c
 SRCS += hdhomerun_control.c
+SRCS += hdhomerun_video.c
+SRCS += hdhomerun_device.c
 SRCS += hdhomerun_config.c
 
-CFLAGS += -Wall -O2
+CFLAGS += -Wall -O2 -Wmissing-declarations -Wmissing-prototypes -Wstrict-prototypes -Wpointer-arith
 
 hdhomerun_config : $(SRCS)
-        gcc $(CFLAGS) $(SRCS) -o $@
+        gcc $(CFLAGS) $(SRCS) -lpthread -o $@
         strip $@
 
 hdhomerun_config.exe : $(SRCS)
-        gcc $(CFLAGS) $(SRCS) -liphlpapi -o $@
+        gcc $(CFLAGS) $(SRCS) -lpthread -liphlpapi -o $@
         strip $@
 
 clean :

libs/libmythtv/hdhomerun/hdhomerun_discover.h

@@ -21 +21 @@
 extern "C" {
 #endif
 
-struct hdhomerun_discover_sock_t;
-
 struct hdhomerun_discover_device_t {
-        unsigned long ip_addr;
-        unsigned long device_type;
-        unsigned long device_id;
+        uint32_t ip_addr;
+        uint32_t device_type;
+        uint32_t device_id;
 };
 
-extern struct hdhomerun_discover_sock_t *hdhomerun_discover_create(unsigned long timeout);
-extern void hdhomerun_discover_destroy(struct hdhomerun_discover_sock_t *ds);
-extern int hdhomerun_discover_send(struct hdhomerun_discover_sock_t *ds, unsigned long device_type, unsigned long device_id);
-extern int hdhomerun_discover_recv(struct hdhomerun_discover_sock_t *ds, struct hdhomerun_discover_device_t *result, unsigned long timeout);
+/*
+ * Find a device by device ID.
+ *
+ * The device information is stored in caller-supplied hdhomerun_discover_device_t var.
+ * Multiple attempts are made to find the device.
+ * Worst-case execution time is 1 second.
+ *
+ * Returns 1 on success.
+ * Returns 0 if not found.
+ * Retruns -1 on error.
+ */
+extern int hdhomerun_discover_find_device(uint32_t device_id, struct hdhomerun_discover_device_t *result);
 
-extern int hdhomerun_discover_validate_device_id(unsigned long device_id);
+/*
+ * Find all devices of a given type.
+ *
+ * The device information is stored in caller-supplied array of hdhomerun_discover_device_t vars.
+ * Multiple attempts are made to find devices.
+ * Execution time is 1 second.
+ *
+ * Returns the number of devices found.
+ * Retruns -1 on error.
+ */
+extern int hdhomerun_discover_find_devices(uint32_t device_type, struct hdhomerun_discover_device_t result_list[], int max_count);
 
+/*
+ * Verify that the device ID given is valid.
+ *
+ * The device ID contains a self-check sequence that detects common user input errors including
+ * single-digit errors and two digit transposition errors.
+ *
+ * Returns TRUE if valid.
+ * Returns FALSE if not valid.
+ */
+extern bool_t hdhomerun_discover_validate_device_id(uint32_t device_id);
+
 #ifdef __cplusplus
 }
 #endif

libs/libmythtv/hdhrsignalmonitor.cpp

@@ -138 +138 @@
     dtvMonitorRunning = true;
 
     struct hdhomerun_video_sock_t *_video_socket;
-    _video_socket = hdhomerun_video_create(VIDEO_DATA_BUFFER_SIZE_1S, 50);
+    _video_socket = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S);
     if (!_video_socket)
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to get video socket");
@@ -164 +164 @@
 
         unsigned long data_length;
         unsigned char *data_buffer =
-            hdhomerun_video_recv_inplace(_video_socket,
+            hdhomerun_video_recv(_video_socket,
                                          VIDEO_DATA_BUFFER_SIZE_1S / 5,
                                          &data_length);
 
@@ -174 +174 @@
             continue;
         }
 
-        if (!hdhomerun_video_get_state(_video_socket))
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR + "Recv error" + ENO);
-            break;
-        }
         usleep(2500);
     }
 

libs/libmythtv/hdhrrecorder.cpp

@@ -100 +100 @@
     }
 
     /* Create TS socket. */
-    _video_socket = hdhomerun_video_create(VIDEO_DATA_BUFFER_SIZE_1S, 50);
+    _video_socket = hdhomerun_video_create(0, VIDEO_DATA_BUFFER_SIZE_1S);
     if (!_video_socket)
     {
         VERBOSE(VB_IMPORTANT, LOC + "Open() failed to open socket");
@@ -357 +357 @@
 
         unsigned long data_length;
         unsigned char *data_buffer =
-            hdhomerun_video_recv_inplace(_video_socket,
-                                         VIDEO_DATA_BUFFER_SIZE_1S / 5,
-                                         &data_length);
+            hdhomerun_video_recv(_video_socket,
+                                 VIDEO_DATA_BUFFER_SIZE_1S / 5,
+                                 &data_length);
         if (!data_buffer)
         {
-            if (hdhomerun_video_get_state(_video_socket) == 0)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR + "Recv error" + ENO);
-                break;
-            }
             usleep(5000);
             continue;
         }

libs/libmythtv/hdhrchannel.cpp

@@ -90 +90 @@
 
     _device_ip = 0;
 
-    /* Create socket. */
-    struct hdhomerun_discover_sock_t *discoverSock = NULL;
-    discoverSock = hdhomerun_discover_create(500);
-
-    if (!discoverSock)
+    /* Discover. */
+    struct hdhomerun_discover_device_t result;
+    int ret = hdhomerun_discover_find_device(_device_id, &result);
+    if (ret < 0)
     {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to create discovery socket");
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to send discovery request" + ENO);
         return false;
     }
-
-    /* Discover. */
-    for (int retry = 0; retry < 6; retry++)
+    if (ret == 0)
     {
-        /* Send discovery request. */
-        int ret = hdhomerun_discover_send(discoverSock,
-                                          HDHOMERUN_DEVICE_TYPE_TUNER,
-                                          _device_id);
-        if (ret < 0)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Unable to send discovery request" + ENO);
-            break;
-        }
-
-        /* Wait for response. */
-        struct hdhomerun_discover_device_t device;
-        ret = hdhomerun_discover_recv(discoverSock, &device, 500);
-        if (ret < 0)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Unable to listen for discovery response" + ENO);
-            break;
-        }
-        if (ret == 0)
-        {
-            continue;
-        }
-
-        /* Found. */
-        _device_ip = device.ip_addr;
-
-        VERBOSE(VB_IMPORTANT, LOC +
-                QString("device found at address %1.%2.%3.%4")
-                .arg((_device_ip>>24) & 0xFF).arg((_device_ip>>16) & 0xFF)
-                .arg((_device_ip>> 8) & 0xFF).arg((_device_ip>> 0) & 0xFF));
-
-        hdhomerun_discover_destroy(discoverSock);
-        return true;
+        VERBOSE(VB_IMPORTANT, LOC_ERR + QString("device not found"));
+        return false;
     }
 
-    VERBOSE(VB_IMPORTANT, LOC_ERR + QString("device not found"));
-    hdhomerun_discover_destroy(discoverSock);
+    /* Found. */
+    _device_ip = result.ip_addr;
 
-    return false;
+    VERBOSE(VB_IMPORTANT, LOC +
+            QString("device found at address %1.%2.%3.%4")
+            .arg((_device_ip>>24) & 0xFF).arg((_device_ip>>16) & 0xFF)
+            .arg((_device_ip>> 8) & 0xFF).arg((_device_ip>> 0) & 0xFF));
+
+    return true;
 }
 
 bool HDHRChannel::Connect(void)
 {
-    _control_socket = hdhomerun_control_create(_device_ip, 2000);
+    _control_socket = hdhomerun_control_create(_device_id, _device_ip);
     if (!_control_socket)
     {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to create control socket");
+        return false;
+    }
+
+    if (hdhomerun_control_get_local_addr(_control_socket) == 0)
+    {
         VERBOSE(VB_IMPORTANT, LOC_ERR + "Unable to connect to device");
         return false;
     }
@@ -162 +137 @@
 QString HDHRChannel::DeviceGet(const QString &name)
 {
     QMutexLocker locker(&_lock);
-    //VERBOSE(VB_CHANNEL, LOC + QString("DeviceGet(%1)").arg(name));
 
     if (!_control_socket)
     {
@@ -170 +144 @@
         return QString::null;
     }
 
-    /* Send request. */
-    if (hdhomerun_control_send_get_request(_control_socket, name) < 0)
+    char *value = NULL;
+    char *error = NULL;
+    if (hdhomerun_control_get(_control_socket, name, &value, &error) < 0)
     {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Get request failed (send)" + ENO);
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Get request failed" + ENO);
         return QString::null;
     }
 
-    /* Wait for response. */
-    struct hdhomerun_control_data_t response;
-    if (hdhomerun_control_recv(_control_socket, &response, 2000) <= 0)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Get request failed (timeout)");
+    if (error) {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + QString("DeviceGet(%1): %2").arg(name).arg(error));
         return QString::null;
     }
-    if (response.type != HDHOMERUN_TYPE_GETSET_RPY)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR +
-                "Get request failed (unexpected response)");
-        return QString::null;
-    }
 
-    QString ret = QString::null;
-    unsigned char *ptr = response.ptr, *data = NULL;
-    unsigned char tag;
-    int dlen;
-    while (hdhomerun_read_tlv(&ptr, response.end, &tag, &dlen, &data) >= 0)
-    {
-        char buf[1024+64];
-        if (HDHOMERUN_TAG_GETSET_VALUE == tag)
-        {
-            memcpy(buf, (char*)data, dlen);
-            buf[dlen - 1] = 0x0;
-            ret = QString(buf);
-        }
-        else if (HDHOMERUN_TAG_ERROR_MESSAGE == tag)
-        {
-            memcpy(buf, (char*)data, dlen);
-            buf[dlen - 1] = 0x0;
-            VERBOSE(VB_IMPORTANT, LOC_ERR + QString("DeviceGet(%1): %2")
-                    .arg(name).arg(buf));
-        }
-    }
-
-    //VERBOSE(VB_CHANNEL, LOC + QString("DeviceGet(%1) -> '%2' len(%3)")
-    //        .arg(name).arg(ret).arg(len));
-
-    return ret;
+    return QString(value);
 }
 
 QString HDHRChannel::DeviceSet(const QString &name, const QString &val)
@@ -229 +170 @@
         return QString::null;
     }
 
-    /* Send request. */
-    if (hdhomerun_control_send_set_request(_control_socket, name, val) < 0)
+    char *value = NULL;
+    char *error = NULL;
+    if (hdhomerun_control_set(_control_socket, name, val, &value, &error) < 0)
     {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Set request failed (send)" + ENO);
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Set request failed" + ENO);
         return QString::null;
     }
 
-    /* Wait for response. */
-    struct hdhomerun_control_data_t response;
-    bzero(&response, sizeof(response));
-    if (hdhomerun_control_recv(_control_socket, &response, 2000) <= 0)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Set request failed (timeout)");
+    if (error) {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + QString("DeviceSet(%1 %2): %3").arg(name).arg(val).arg(error));
         return QString::null;
     }
-    if (response.type != HDHOMERUN_TYPE_GETSET_RPY)
-    {
-        VERBOSE(VB_IMPORTANT, LOC_ERR +
-                "Set request failed (unexpected response)");
-        return QString::null;
-    }
 
-    QStringList list;
-    QString tmp = "";
-    unsigned char *ptr = response.ptr;
-    for (;ptr < response.end; ptr++)
-    {
-        if (*ptr)
-        {
-            tmp += QChar(*((char*)ptr));
-            continue;
-        }
-        list.push_back(tmp);
-        tmp = "";
-        ptr++;
-        ptr++;
-    }
-
-    if (list.size() >= 2)
-        return list[1];
-    return "";
+    return QString(value);
 }
 
 QString HDHRChannel::TunerGet(const QString &name)

libs/libmythtv/hdhrchannel.h

@@ -14 +14 @@
 #include "dtvchannel.h"
 
 // HDHomeRun headers
-#include "hdhomerun/hdhomerun_pkt.h"
-#include "hdhomerun/hdhomerun_discover.h"
-#include "hdhomerun/hdhomerun_control.h"
-#include "hdhomerun/hdhomerun_video.h"
+#include "hdhomerun/hdhomerun.h"
 
 typedef struct hdhomerun_control_sock_t hdhr_socket_t;