I suspect that while dleyna/renderer builds on amd64, it may not actually *run*.
This diff incorporates a pull request someone proposed for upstream to make it work with gupnp>=1.2.0 This gets it to build on sparc64, and presumably other ld.bfd arches. I'm guessing it might also run now on ld.lld arches. I've bumped REVISION accordingly. ok? --Kurt Index: Makefile =================================================================== RCS file: /cvs/ports/net/dleyna/renderer/Makefile,v retrieving revision 1.5 diff -u -p -r1.5 Makefile --- Makefile 10 Feb 2019 12:57:12 -0000 1.5 +++ Makefile 27 Mar 2020 18:43:37 -0000 @@ -3,7 +3,7 @@ COMMENT= service for interacting with DMRs GH_PROJECT= dleyna-renderer -REVISION= 0 +REVISION= 1 SHARED_LIBS += dleyna-renderer-1.0 0.0 # 1.3 Index: patches/patch-configure_ac =================================================================== RCS file: /cvs/ports/net/dleyna/renderer/patches/patch-configure_ac,v retrieving revision 1.1 diff -u -p -r1.1 patch-configure_ac --- patches/patch-configure_ac 10 Feb 2019 12:57:13 -0000 1.1 +++ patches/patch-configure_ac 27 Mar 2020 18:43:37 -0000 @@ -1,4 +1,8 @@ -$OpenBSD: patch-configure_ac,v 1.1 2019/02/10 12:57:13 jasper Exp $ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 Index: configure.ac --- configure.ac.orig @@ -9,8 +13,8 @@ Index: configure.ac PKG_CHECK_MODULES([GIO], [gio-2.0 >= 2.28]) -PKG_CHECK_MODULES([GSSDP], [gssdp-1.0 >= 0.13.2]) -PKG_CHECK_MODULES([GUPNP], [gupnp-1.0 >= 0.20.5]) -+PKG_CHECK_MODULES([GSSDP], [gssdp-1.2 >= 1.1.0]) -+PKG_CHECK_MODULES([GUPNP], [gupnp-1.2 >= 1.1.0]) ++PKG_CHECK_MODULES([GSSDP], [gssdp-1.2 >= 1.2.0]) ++PKG_CHECK_MODULES([GUPNP], [gupnp-1.2 >= 1.2.0]) PKG_CHECK_MODULES([GUPNPAV], [gupnp-av-1.0 >= 0.11.5]) PKG_CHECK_MODULES([GUPNPDLNA], [gupnp-dlna-2.0 >= 0.9.4]) PKG_CHECK_MODULES([SOUP], [libsoup-2.4 >= 2.28.2]) Index: patches/patch-libdleyna_renderer_Makefile_am =================================================================== RCS file: patches/patch-libdleyna_renderer_Makefile_am diff -N patches/patch-libdleyna_renderer_Makefile_am --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_Makefile_am 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,25 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/Makefile.am +--- libdleyna/renderer/Makefile.am.orig ++++ libdleyna/renderer/Makefile.am +@@ -22,6 +22,7 @@ libdleyna_renderer_1_0_la_LDFLAGS = -version-info $(DL + libdleyna_renderer_1_0_la_SOURCES = $(libdleyna_rendererinc_HEADERS) \ + async.c \ + device.c \ ++ gasync-task.c \ + host-service.c \ + manager.c \ + server.c \ +@@ -53,6 +54,7 @@ sysconf_DATA = dleyna-renderer-service.conf + EXTRA_DIST = $(sysconf_DATA) \ + async.h \ + device.h \ ++ gasync-task.h \ + host-service.h \ + prop-defs.h \ + manager.h \ Index: patches/patch-libdleyna_renderer_device_c =================================================================== RCS file: patches/patch-libdleyna_renderer_device_c diff -N patches/patch-libdleyna_renderer_device_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_device_c 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,558 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/device.c +--- libdleyna/renderer/device.c.orig ++++ libdleyna/renderer/device.c +@@ -26,15 +26,16 @@ + + #include <libsoup/soup.h> + #include <libgupnp/gupnp-control-point.h> ++#include <libgupnp/gupnp-service-proxy.h> + #include <libgupnp-av/gupnp-av.h> + + #include <libdleyna/core/core.h> + #include <libdleyna/core/error.h> + #include <libdleyna/core/log.h> +-#include <libdleyna/core/service-task.h> + + #include "async.h" + #include "device.h" ++#include "gasync-task.h" + #include "prop-defs.h" + #include "server.h" + +@@ -675,21 +676,30 @@ static void prv_process_protocol_info(dlr_device_t *de + DLEYNA_LOG_DEBUG("Exit"); + } + +-static void prv_get_protocol_info_cb(GUPnPServiceProxy *proxy, +- GUPnPServiceProxyAction *action, ++static void prv_get_protocol_info_cb(GObject *target, ++ GAsyncResult *res, + gpointer user_data) + { + gchar *result = NULL; + gboolean end; + GError *error = NULL; + prv_new_device_ct_t *priv_t = (prv_new_device_ct_t *)user_data; ++ GUPnPServiceProxyAction *action; + + DLEYNA_LOG_DEBUG("Enter"); + + priv_t->dev->construct_step++; + +- end = gupnp_service_proxy_end_action(proxy, action, &error, "Sink", +- G_TYPE_STRING, &result, NULL); ++ action = gupnp_service_proxy_call_action_finish(GUPNP_SERVICE_PROXY(target), res, &error); ++ ++ if (action == NULL || (error != NULL)) { ++ DLEYNA_LOG_WARNING("GetProtocolInfo operation failed: %s", ++ ((error != NULL) ? error->message ++ : "Invalid result")); ++ goto on_error; ++ } ++ ++ end = gupnp_service_proxy_action_get_result (action, &error, "Sink", G_TYPE_STRING, &result, NULL); + if (!end || (result == NULL)) { + DLEYNA_LOG_WARNING("GetProtocolInfo operation failed: %s", + ((error != NULL) ? error->message +@@ -701,6 +711,10 @@ static void prv_get_protocol_info_cb(GUPnPServiceProxy + + on_error: + ++ if (action) { ++ gupnp_service_proxy_action_unref(action); ++ } ++ + if (error) + g_error_free(error); + +@@ -709,53 +723,193 @@ on_error: + DLEYNA_LOG_DEBUG("Exit"); + } + +-static GUPnPServiceProxyAction *prv_get_protocol_info( +- dleyna_service_task_t *task, +- GUPnPServiceProxy *proxy, +- gboolean *failed) ++static void prv_introspection_wrap_cb (GUPnPServiceInfo *info, ++ GUPnPServiceIntrospection *introspection, ++ const GError *error, ++ gpointer user_data) + { +- *failed = FALSE; ++ if (error != NULL) { ++ g_task_return_error (G_TASK (user_data), ++ g_error_copy (error)); ++ } else { ++ g_task_return_pointer (G_TASK (user_data), ++ introspection, ++ g_object_unref); ++ } + +- return gupnp_service_proxy_begin_action( +- proxy, "GetProtocolInfo", +- dleyna_service_task_begin_action_cb, +- task, NULL); ++ g_object_unref (G_OBJECT (user_data)); + } + +-static GUPnPServiceProxyAction *prv_subscribe(dleyna_service_task_t *task, +- GUPnPServiceProxy *proxy, +- gboolean *failed) ++void prv_introspect_async (GUPnPServiceInfo *info, ++ GCancellable *cancellable, ++ GAsyncReadyCallback callback, ++ gpointer user_data) + { ++ GTask *task = g_task_new (info, cancellable, callback, user_data); ++ ++ gupnp_service_info_get_introspection_async_full (info, ++ prv_introspection_wrap_cb, ++ cancellable, ++ task); ++} ++ ++static GUPnPServiceIntrospection *prv_introspect_finish ++ (GUPnPServiceInfo *info, ++ GAsyncResult *res, ++ GError **error) ++{ ++ g_return_val_if_fail (g_task_is_valid (res, info), NULL); ++ ++ return g_task_propagate_pointer (G_TASK (res), error); ++} ++ ++static gint compare_speeds(gconstpointer a, gconstpointer b); ++ ++static void prv_introspect_av_cb (GObject *target, ++ GAsyncResult *res, ++ gpointer user_data) ++{ ++ prv_new_device_ct_t *priv_t = (prv_new_device_ct_t *)user_data; ++ GError *error = NULL; ++ GUPnPServiceIntrospection *introspection; ++ const GUPnPServiceStateVariableInfo *svi; ++ GList *allowed_values; ++ GVariant *speeds = NULL; ++ const GUPnPServiceActionInfo *sai; ++ ++ DLEYNA_LOG_DEBUG("Enter"); ++ ++ priv_t->dev->construct_step++; ++ ++ introspection = prv_introspect_finish (GUPNP_SERVICE_INFO (target), res, &error); ++ ++ if (introspection == NULL || (error != NULL)) { ++ DLEYNA_LOG_WARNING("GetProtocolInfo operation failed: %s", ++ ((error != NULL) ? error->message ++ : "Invalid result")); ++ goto on_error; ++ } ++ ++ svi = gupnp_service_introspection_get_state_variable( ++ introspection, ++ "TransportPlaySpeed"); ++ ++ if (svi && svi->allowed_values) { ++ allowed_values = svi->allowed_values; ++ ++ allowed_values = g_list_sort(allowed_values, compare_speeds); ++ ++ prv_get_rates_values(allowed_values, &speeds, ++ &priv_t->dev->transport_play_speeds, ++ &priv_t->dev->min_rate, ++ &priv_t->dev->max_rate); ++ ++ priv_t->dev->mpris_transport_play_speeds = g_variant_ref_sink(speeds); ++ } ++ ++ sai = gupnp_service_introspection_get_action( ++ introspection, ++ "X_DLNA_GetBytePositionInfo"); ++ ++ priv_t->dev->can_get_byte_position = (sai != NULL); ++ ++on_error: ++ g_clear_object(&introspection); ++ ++ g_clear_error(&error); ++ ++ DLEYNA_LOG_DEBUG("Exit"); ++} ++ ++static void prv_introspect_rc_cb (GObject *target, ++ GAsyncResult *res, ++ gpointer user_data) ++{ ++ prv_new_device_ct_t *priv_t = (prv_new_device_ct_t *)user_data; ++ GError *error = NULL; ++ GUPnPServiceIntrospection *introspection; ++ const GUPnPServiceStateVariableInfo *svi; ++ ++ DLEYNA_LOG_DEBUG("Enter"); ++ ++ priv_t->dev->construct_step++; ++ ++ introspection = prv_introspect_finish (GUPNP_SERVICE_INFO (target), res, &error); ++ ++ if (introspection == NULL || (error != NULL)) { ++ DLEYNA_LOG_WARNING("GetProtocolInfo operation failed: %s", ++ ((error != NULL) ? error->message ++ : "Invalid result")); ++ goto on_error; ++ } ++ ++ svi = gupnp_service_introspection_get_state_variable(introspection, ++ "Volume"); ++ if (svi != NULL) ++ priv_t->dev->max_volume = g_value_get_uint(&svi->maximum); ++ ++on_error: ++ g_clear_object(&introspection); ++ ++ g_clear_error(&error); ++ ++ DLEYNA_LOG_DEBUG("Exit"); ++} ++ ++static gboolean prv_get_protocol_info( ++ dleyna_gasync_task_t *task, ++ GObject *target) ++{ ++ GUPnPServiceProxyAction *action; ++ ++ action = gupnp_service_proxy_action_new("GetProtocolInfo", NULL); ++ ++ gupnp_service_proxy_call_action_async(GUPNP_SERVICE_PROXY (target), action, ++ dleyna_gasync_task_get_cancellable (task), ++ dleyna_gasync_task_ready_cb, ++ task); ++ ++ return FALSE; ++} ++ ++static gboolean prv_introspect(dleyna_gasync_task_t *task, GObject *target) ++{ ++ prv_introspect_async (GUPNP_SERVICE_INFO (target), ++ dleyna_gasync_task_get_cancellable (task), ++ dleyna_gasync_task_ready_cb, ++ task); ++ ++ return FALSE; ++} ++ ++static gboolean prv_subscribe(dleyna_gasync_task_t *task, GObject *target) ++{ + dlr_device_t *device; + + DLEYNA_LOG_DEBUG("Enter"); + +- device = (dlr_device_t *)dleyna_service_task_get_user_data(task); ++ device = (dlr_device_t *)dleyna_gasync_task_get_user_data(task); + + device->construct_step++; + prv_device_subscribe_context(device); + +- *failed = FALSE; +- + DLEYNA_LOG_DEBUG("Exit"); + +- return NULL; ++ return FALSE; + } + +-static GUPnPServiceProxyAction *prv_declare(dleyna_service_task_t *task, +- GUPnPServiceProxy *proxy, +- gboolean *failed) ++static gboolean prv_declare(dleyna_gasync_task_t *task, ++ GObject *target) + { + unsigned int i; + dlr_device_t *device; + prv_new_device_ct_t *priv_t; + const dleyna_connector_dispatch_cb_t *table; ++ gboolean result = FALSE; + + DLEYNA_LOG_DEBUG("Enter"); + +- *failed = FALSE; +- +- priv_t = (prv_new_device_ct_t *)dleyna_service_task_get_user_data(task); ++ priv_t = (prv_new_device_ct_t *)dleyna_gasync_task_get_user_data(task); + device = priv_t->dev; + device->construct_step++; + +@@ -770,16 +924,16 @@ static GUPnPServiceProxyAction *prv_declare(dleyna_ser + table + i); + + if (!device->ids[i]) { +- *failed = TRUE; ++ result = TRUE; + goto on_error; + } + } + + on_error: + +-DLEYNA_LOG_DEBUG("Exit"); ++ DLEYNA_LOG_DEBUG("Exit"); + +- return NULL; ++ return result; + } + + static void prv_free_rc_event(gpointer user_data) +@@ -800,6 +954,9 @@ void dlr_device_construct( + { + prv_new_device_ct_t *priv_t; + GUPnPServiceProxy *s_proxy; ++ GUPnPServiceProxy *av_proxy; ++ GUPnPServiceProxy *rc_proxy; ++ GCancellable *cancellable; + + DLEYNA_LOG_DEBUG("Current step: %d", dev->construct_step); + +@@ -809,19 +966,52 @@ void dlr_device_construct( + priv_t->dispatch_table = dispatch_table; + + s_proxy = context->service_proxies.cm_proxy; ++ cancellable = g_cancellable_new (); + + if (dev->construct_step < 1) +- dleyna_service_task_add(queue_id, prv_get_protocol_info, +- s_proxy, prv_get_protocol_info_cb, +- NULL, priv_t); ++ dleyna_gasync_task_add(queue_id, ++ prv_get_protocol_info, ++ G_OBJECT(s_proxy), ++ prv_get_protocol_info_cb, ++ cancellable, ++ NULL, priv_t); + ++ av_proxy = context->service_proxies.av_proxy; ++ if (dev->construct_step < 2) { ++ if (av_proxy == NULL) { ++ dev->construct_step++; ++ } else { ++ dleyna_gasync_task_add(queue_id, ++ prv_introspect, ++ G_OBJECT(av_proxy), ++ prv_introspect_av_cb, ++ cancellable, ++ NULL, priv_t); ++ } ++ } ++ ++ rc_proxy = context->service_proxies.rc_proxy; ++ if (dev->construct_step < 3) { ++ if (rc_proxy == NULL) { ++ dev->construct_step++; ++ } else { ++ dleyna_gasync_task_add(queue_id, ++ prv_introspect, ++ G_OBJECT(rc_proxy), ++ prv_introspect_rc_cb, ++ cancellable, ++ NULL, priv_t); ++ } ++ } ++ ++ + /* The following task should always be completed */ +- dleyna_service_task_add(queue_id, prv_subscribe, s_proxy, +- NULL, NULL, dev); ++ dleyna_gasync_task_add(queue_id, prv_subscribe, G_OBJECT(s_proxy), ++ NULL, NULL, NULL, dev); + +- if (dev->construct_step < 3) +- dleyna_service_task_add(queue_id, prv_declare, s_proxy, +- NULL, g_free, priv_t); ++ if (dev->construct_step < 5) ++ dleyna_gasync_task_add(queue_id, prv_declare, G_OBJECT(s_proxy), ++ NULL, NULL, g_free, priv_t); + + dleyna_task_queue_start(queue_id); + +@@ -1201,7 +1391,7 @@ static void prv_add_actions(dlr_device_t *device, + continue; + } + +- DLEYNA_LOG_DEBUG("DLNA version ≥ 1.50 pour %s", ++ DLEYNA_LOG_DEBUG("DLNA version ≥ 1.50 for %s", + device->path); + timeseek_missing = TRUE; + g_free(dlna_device_class); +@@ -2121,133 +2311,6 @@ exit: + return; + } + +-static gboolean prv_get_av_service_states_values(GUPnPServiceProxy *av_proxy, +- GVariant **mpris_tp_speeds, +- GPtrArray **upnp_tp_speeds, +- double *min_rate, +- double *max_rate, +- gboolean *can_get_byte_pos) +-{ +- const GUPnPServiceStateVariableInfo *svi; +- const GUPnPServiceActionInfo *sai; +- GUPnPServiceIntrospection *introspection; +- GError *error = NULL; +- GVariant *speeds = NULL; +- GList *allowed_values; +- gpointer weak_ref = NULL; +- gboolean device_alive = TRUE; +- +- /* TODO: this weak_ref hack is needed as +- gupnp_service_info_get_introspection iterates the main loop. +- This can result in our device getting deleted before this +- function returns. Ultimately, this code needs to be re-written +- to use gupnp_service_info_get_introspection_async but this cannot +- really be done until GUPnP provides a way to cancel this function. */ +- +- weak_ref = av_proxy; +- g_object_add_weak_pointer(G_OBJECT(av_proxy), &weak_ref); +- +- introspection = gupnp_service_info_get_introspection( +- GUPNP_SERVICE_INFO(av_proxy), +- &error); +- +- if (!weak_ref) { +- DLEYNA_LOG_WARNING("Lost device during introspection call"); +- device_alive = FALSE; +- goto exit; +- } +- +- g_object_remove_weak_pointer(G_OBJECT(av_proxy), &weak_ref); +- +- if (error != NULL) { +- DLEYNA_LOG_DEBUG( +- "failed to fetch AV service introspection file"); +- +- g_error_free(error); +- +- goto exit; +- } +- +- svi = gupnp_service_introspection_get_state_variable( +- introspection, +- "TransportPlaySpeed"); +- +- if (svi && svi->allowed_values) { +- allowed_values = svi->allowed_values; +- +- allowed_values = g_list_sort(allowed_values, compare_speeds); +- +- prv_get_rates_values(allowed_values, &speeds, upnp_tp_speeds, +- min_rate, max_rate); +- +- *mpris_tp_speeds = g_variant_ref_sink(speeds); +- } +- +- sai = gupnp_service_introspection_get_action( +- introspection, +- "X_DLNA_GetBytePositionInfo"); +- +- *can_get_byte_pos = (sai != NULL); +- +- g_object_unref(introspection); +- +-exit: +- +- return device_alive; +-} +- +-static gboolean prv_get_rc_service_states_values(GUPnPServiceProxy *rc_proxy, +- guint *max_volume) +-{ +- const GUPnPServiceStateVariableInfo *svi; +- GUPnPServiceIntrospection *introspection; +- GError *error = NULL; +- gpointer weak_ref = NULL; +- gboolean device_alive = TRUE; +- +- /* TODO: this weak_ref hack is needed as +- gupnp_service_info_get_introspection iterates the main loop. +- This can result in our device getting deleted before this +- function returns. Ultimately, this code needs to be re-written +- to use gupnp_service_info_get_introspection_async but this cannot +- really be done until GUPnP provides a way to cancel this function. */ +- +- weak_ref = rc_proxy; +- g_object_add_weak_pointer(G_OBJECT(rc_proxy), &weak_ref); +- +- introspection = gupnp_service_info_get_introspection( +- GUPNP_SERVICE_INFO(rc_proxy), +- &error); +- +- if (!weak_ref) { +- DLEYNA_LOG_WARNING("Lost device during introspection call"); +- device_alive = FALSE; +- goto exit; +- } +- +- g_object_remove_weak_pointer(G_OBJECT(rc_proxy), &weak_ref); +- +- if (error != NULL) { +- DLEYNA_LOG_DEBUG( +- "failed to fetch RC service introspection file"); +- +- g_error_free(error); +- +- goto exit; +- } +- +- svi = gupnp_service_introspection_get_state_variable(introspection, +- "Volume"); +- if (svi != NULL) +- *max_volume = g_value_get_uint(&svi->maximum); +- +- g_object_unref(introspection); +- +-exit: +- +- return device_alive; +-} +- + static void prv_update_device_props(GUPnPDeviceInfo *proxy, GHashTable *props) + { + GVariant *val; +@@ -2377,34 +2440,6 @@ static gboolean prv_props_update(dlr_device_t *device, + g_variant_ref(val)); + + service_proxies = &context->service_proxies; +- +- /* TODO: We should not retrieve these values here. They should be +- retrieved during device construction. */ +- +- if (service_proxies->av_proxy) +- if (!prv_get_av_service_states_values( +- service_proxies->av_proxy, +- &device->mpris_transport_play_speeds, +- &device->transport_play_speeds, +- &device->min_rate, +- &device->max_rate, +- &device->can_get_byte_position)) { +- DLEYNA_LOG_DEBUG("Lost Device AV"); +- +- device_alive = FALSE; +- goto on_lost_device; +- } +- +- /* TODO: We should not retrieve these values here. They should be +- retrieved during device construction. */ +- +- if (service_proxies->rc_proxy) +- if (!prv_get_rc_service_states_values(service_proxies->rc_proxy, +- &device->max_volume)) { +- DLEYNA_LOG_DEBUG("Lost Device RC"); +- device_alive = FALSE; +- goto on_lost_device; +- } + + changed_props_vb = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + Index: patches/patch-libdleyna_renderer_gasync-task_c =================================================================== RCS file: patches/patch-libdleyna_renderer_gasync-task_c diff -N patches/patch-libdleyna_renderer_gasync-task_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_gasync-task_c 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,145 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/gasync-task.c +--- libdleyna/renderer/gasync-task.c.orig ++++ libdleyna/renderer/gasync-task.c +@@ -0,0 +1,135 @@ ++/* ++ * dLeyna ++ * ++ * Copyright (c) 2019 Jens Georg <m...@jensge.org> ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU Lesser General Public License, ++ * version 2.1, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc., ++ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ */ ++ ++#include "gasync-task.h" ++#include <libdleyna/core/task-processor.h> ++ ++struct dleyna_gasync_task_t_ { ++ dleyna_task_atom_t base; ++ dleyna_gasync_task_action action; ++ GObject *target; ++ GAsyncReadyCallback callback; ++ GCancellable *cancellable; ++ GDestroyNotify free_func; ++ gpointer cb_user_data; ++}; ++ ++const char *dleyna_gasync_task_create_source(void) ++{ ++ static unsigned int cpt = 1; ++ static char source[27]; ++ ++ g_snprintf(source, 27, "gasync-source-%d", cpt); ++ cpt++; ++ ++ return source; ++} ++ ++void dleyna_gasync_task_add(const dleyna_task_queue_key_t *queue_id, ++ dleyna_gasync_task_action action, ++ GObject *target, ++ GAsyncReadyCallback callback, ++ GCancellable *cancellable, ++ GDestroyNotify free_func, ++ gpointer cb_user_data) ++{ ++ dleyna_gasync_task_t *task; ++ ++ task = g_new0(dleyna_gasync_task_t, 1); ++ ++ task->action = action; ++ task->callback = callback; ++ task->cancellable = cancellable; ++ task->free_func = free_func; ++ task->cb_user_data = cb_user_data; ++ task->target = target; ++ ++ if (target != NULL) { ++ g_object_add_weak_pointer (target, (gpointer *)(&task->target)); ++ } ++ ++ dleyna_task_queue_add_task(queue_id, &task->base); ++} ++ ++void dleyna_gasync_task_ready_cb(GObject *source, GAsyncResult *res, gpointer user_data) ++{ ++ dleyna_gasync_task_t *task = (dleyna_gasync_task_t *)user_data; ++ ++ task->callback(source, res, task->cb_user_data); ++ ++ dleyna_task_queue_task_completed(task->base.queue_id); ++} ++ ++void dleyna_gasync_task_process_cb(dleyna_task_atom_t *atom, ++ gpointer user_data) ++{ ++ gboolean failed = FALSE; ++ ++ dleyna_gasync_task_t *task = (dleyna_gasync_task_t *)atom; ++ ++ failed = task->action(task, task->target); ++ ++ if (failed) { ++ dleyna_task_processor_cancel_queue(task->base.queue_id); ++ dleyna_task_queue_task_completed(task->base.queue_id); ++ } ++ ++ if (task->callback == NULL) { ++ dleyna_task_queue_task_completed(task->base.queue_id); ++ } ++} ++ ++void dleyna_gasync_task_cancel_cb(dleyna_task_atom_t *atom, ++ gpointer user_data) ++{ ++ dleyna_gasync_task_t *task = (dleyna_gasync_task_t *)atom; ++ ++ if (task->cancellable) { ++ g_cancellable_cancel (task->cancellable); ++ task->cancellable = NULL; ++ ++ dleyna_task_queue_task_completed(task->base.queue_id); ++ } ++} ++ ++void dleyna_gasync_task_delete_cb(dleyna_task_atom_t *atom, ++ gpointer user_data) ++{ ++ dleyna_gasync_task_t *task = (dleyna_gasync_task_t *)atom; ++ ++ if (task->free_func != NULL) ++ task->free_func(task->cb_user_data); ++ ++ if (task->target != NULL) { ++ g_object_remove_weak_pointer(task->target, (gpointer *)&task->target); ++ } ++ ++ g_free(task); ++} ++ ++gpointer dleyna_gasync_task_get_user_data(dleyna_gasync_task_t *task) ++{ ++ return task->cb_user_data; ++} ++ ++GCancellable *dleyna_gasync_task_get_cancellable(dleyna_gasync_task_t *task) ++{ ++ return task->cancellable; ++} Index: patches/patch-libdleyna_renderer_gasync-task_h =================================================================== RCS file: patches/patch-libdleyna_renderer_gasync-task_h diff -N patches/patch-libdleyna_renderer_gasync-task_h --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_gasync-task_h 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,67 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/gasync-task.h +--- libdleyna/renderer/gasync-task.h.orig ++++ libdleyna/renderer/gasync-task.h +@@ -0,0 +1,57 @@ ++/* ++ * dLeyna ++ * ++ * Copyright (c) 2019 Jens Georg <m...@jensge.org> ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU Lesser General Public License, ++ * version 2.1, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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 program; if not, write to the Free Software Foundation, Inc., ++ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ */ ++ ++#pragma once ++ ++#include <libdleyna/core/task-atom.h> ++ ++#include <glib.h> ++#include <gio/gio.h> ++ ++typedef struct dleyna_gasync_task_t_ dleyna_gasync_task_t; ++ ++typedef gboolean (*dleyna_gasync_task_action) ++ (dleyna_gasync_task_t *task, ++ GObject *target); ++ ++const char *dleyna_gasync_task_create_source(void); ++ ++void dleyna_gasync_task_add(const dleyna_task_queue_key_t *queue_id, ++ dleyna_gasync_task_action action, ++ GObject *target, ++ GAsyncReadyCallback callback, ++ GCancellable *cancellable, ++ GDestroyNotify free_func, ++ gpointer cb_user_data); ++ ++void dleyna_gasync_task_ready_cb(GObject *source, GAsyncResult *res, gpointer user_data); ++ ++void dleyna_gasync_task_process_cb(dleyna_task_atom_t *atom, ++ gpointer user_data); ++ ++void dleyna_gasync_task_cancel_cb(dleyna_task_atom_t *atom, ++ gpointer user_data); ++ ++void dleyna_gasync_task_delete_cb(dleyna_task_atom_t *atom, ++ gpointer user_data); ++ ++gpointer dleyna_gasync_task_get_user_data(dleyna_gasync_task_t *task); ++ ++GCancellable *dleyna_gasync_task_get_cancellable(dleyna_gasync_task_t *task); Index: patches/patch-libdleyna_renderer_manager_c =================================================================== RCS file: patches/patch-libdleyna_renderer_manager_c diff -N patches/patch-libdleyna_renderer_manager_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_manager_c 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,17 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/manager.c +--- libdleyna/renderer/manager.c.orig ++++ libdleyna/renderer/manager.c +@@ -25,7 +25,6 @@ + + #include <libdleyna/core/error.h> + #include <libdleyna/core/log.h> +-#include <libdleyna/core/service-task.h> + #include <libdleyna/core/white-list.h> + + #include "async.h" Index: patches/patch-libdleyna_renderer_upnp_c =================================================================== RCS file: patches/patch-libdleyna_renderer_upnp_c diff -N patches/patch-libdleyna_renderer_upnp_c --- /dev/null 1 Jan 1970 00:00:00 -0000 +++ patches/patch-libdleyna_renderer_upnp_c 27 Mar 2020 18:43:37 -0000 @@ -0,0 +1,49 @@ +$OpenBSD$ + +Make dleyna-renderer work with gupnp >= 1.1.0 + +https://patch-diff.githubusercontent.com/raw/intel/dleyna-renderer/pull/167 + +Index: libdleyna/renderer/upnp.c +--- libdleyna/renderer/upnp.c.orig ++++ libdleyna/renderer/upnp.c +@@ -28,10 +28,10 @@ + + #include <libdleyna/core/error.h> + #include <libdleyna/core/log.h> +-#include <libdleyna/core/service-task.h> + + #include "async.h" + #include "device.h" ++#include "gasync-task.h" + #include "host-service.h" + #include "prop-defs.h" + #include "upnp.h" +@@ -116,12 +116,12 @@ static const dleyna_task_queue_key_t *prv_create_devic + + queue_id = dleyna_task_processor_add_queue( + dlr_renderer_service_get_task_processor(), +- dleyna_service_task_create_source(), ++ dleyna_gasync_task_create_source(), + DLR_RENDERER_SINK, + DLEYNA_TASK_QUEUE_FLAG_AUTO_REMOVE, +- dleyna_service_task_process_cb, +- dleyna_service_task_cancel_cb, +- dleyna_service_task_delete_cb); ++ dleyna_gasync_task_process_cb, ++ dleyna_gasync_task_cancel_cb, ++ dleyna_gasync_task_delete_cb); + dleyna_task_queue_set_finally(queue_id, prv_device_chain_end); + dleyna_task_queue_set_user_data(queue_id, *priv_t); + +@@ -243,8 +243,8 @@ static void prv_server_unavailable_cb(GUPnPControlPoin + + udn = gupnp_device_info_get_udn((GUPnPDeviceInfo *)proxy); + +- ip_address = gupnp_context_get_host_ip( +- gupnp_control_point_get_context(cp)); ++ ip_address = gssdp_client_get_host_ip( ++ GSSDP_CLIENT(gupnp_control_point_get_context(cp))); + + if (!udn || !ip_address) + goto on_error;
