mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-03 09:01:54 -05:00
avb: use descriptors for ADP
Remove some of the json parsing for now, work with descriptors. Remove some parsing code. Implement GET_AVB_INFO. Keep descriptors in a list. Add some utils.
This commit is contained in:
Wim Taymans
parent
b6b8471540
commit
50199c9824
14 changed files with 584 additions and 434 deletions
|
|
@ -524,6 +524,7 @@ pipewire_module_avbtp = shared_library('pipewire-module-avbtp',
|
|||
[ 'module-avbtp.c',
|
||||
'module-avbtp/avb.c',
|
||||
'module-avbtp/adp.c',
|
||||
'module-avbtp/acmp.c',
|
||||
'module-avbtp/aecp.c',
|
||||
'module-avbtp/aecp-aem.c',
|
||||
'module-avbtp/avdecc.c',
|
||||
|
|
|
|||
167
src/modules/module-avbtp/acmp.c
Normal file
167
src/modules/module-avbtp/acmp.c
Normal file
|
|
@ -0,0 +1,167 @@
|
|||
/* AVB support
|
||||
*
|
||||
* Copyright © 2022 Wim Taymans
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#include <spa/utils/json.h>
|
||||
#include <spa/debug/mem.h>
|
||||
|
||||
#include <pipewire/pipewire.h>
|
||||
|
||||
#include "acmp.h"
|
||||
#include "internal.h"
|
||||
|
||||
struct acmp {
|
||||
struct server *server;
|
||||
struct spa_hook server_listener;
|
||||
};
|
||||
|
||||
struct msg_info {
|
||||
uint16_t type;
|
||||
const char *name;
|
||||
int (*handle) (struct acmp *acmp, const void *p, int len);
|
||||
};
|
||||
|
||||
static int reply_not_supported(struct acmp *acmp, const void *p, int len)
|
||||
{
|
||||
struct server *server = acmp->server;
|
||||
uint8_t buf[len];
|
||||
struct avbtp_packet_acmp *reply = (struct avbtp_packet_acmp*)buf;
|
||||
|
||||
memcpy(reply, p, len);
|
||||
AVBTP_PACKET_ACMP_SET_STATUS(reply, AVBTP_ACMP_STATUS_NOT_SUPPORTED);
|
||||
|
||||
return avbtp_server_send_packet(server, reply->hdr.eth.src, reply, len);
|
||||
}
|
||||
|
||||
static const struct msg_info msg_info[] = {
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_CONNECT_TX_COMMAND, "connect-tx-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_CONNECT_TX_RESPONSE, "connect-tx-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_TX_COMMAND, "disconnect-tx-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_TX_RESPONSE, "disconnect-tx-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_TX_STATE_COMMAND, "get-tx-state-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_TX_STATE_RESPONSE, "get-tx-state-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_CONNECT_RX_COMMAND, "connect-rx-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_CONNECT_RX_RESPONSE, "connect-rx-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_RX_COMMAND, "disconnect-rx-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_RX_RESPONSE, "disconnect-rx-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_RX_STATE_COMMAND, "get-rx-state-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_RX_STATE_RESPONSE, "get-rx-state-response", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_COMMAND, "get-tx-connection-command", NULL, },
|
||||
{ AVBTP_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_RESPONSE, "get-tx-connection-response", NULL, },
|
||||
};
|
||||
|
||||
static inline const struct msg_info *find_msg_info(uint16_t type, const char *name)
|
||||
{
|
||||
uint32_t i;
|
||||
for (i = 0; i < SPA_N_ELEMENTS(msg_info); i++) {
|
||||
if ((name == NULL && type == msg_info[i].type) ||
|
||||
(name != NULL && spa_streq(name, msg_info[i].name)))
|
||||
return &msg_info[i];
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int acmp_message(void *data, uint64_t now, const void *message, int len)
|
||||
{
|
||||
struct acmp *acmp = data;
|
||||
const struct avbtp_packet_acmp *p = message;
|
||||
const struct msg_info *info;
|
||||
int message_type;
|
||||
|
||||
if (AVBTP_PACKET_GET_SUBTYPE(&p->hdr) != AVBTP_SUBTYPE_ACMP)
|
||||
return 0;
|
||||
|
||||
message_type = AVBTP_PACKET_ACMP_GET_MESSAGE_TYPE(p);
|
||||
|
||||
info = find_msg_info(message_type, NULL);
|
||||
if (info == NULL)
|
||||
return reply_not_supported(acmp, p, len);
|
||||
|
||||
pw_log_info("got ACMP message %s", info->name);
|
||||
|
||||
if (info->handle == NULL)
|
||||
return reply_not_supported(acmp, p, len);
|
||||
|
||||
return info->handle(acmp, p, len);
|
||||
}
|
||||
|
||||
static void acmp_destroy(void *data)
|
||||
{
|
||||
struct acmp *acmp = data;
|
||||
spa_hook_remove(&acmp->server_listener);
|
||||
free(acmp);
|
||||
}
|
||||
|
||||
static int do_help(struct acmp *acmp, const char *args, FILE *out)
|
||||
{
|
||||
fprintf(out, "{ \"type\": \"help\","
|
||||
"\"text\": \""
|
||||
"/adp/help: this help \\n"
|
||||
"\" }");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int acmp_command(void *data, uint64_t now, const char *command, const char *args, FILE *out)
|
||||
{
|
||||
struct acmp *acmp = data;
|
||||
int res;
|
||||
|
||||
if (!spa_strstartswith(command, "/acmp/"))
|
||||
return 0;
|
||||
|
||||
command += strlen("/acmp/");
|
||||
|
||||
if (spa_streq(command, "help"))
|
||||
res = do_help(acmp, args, out);
|
||||
else
|
||||
res = -ENOTSUP;
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static const struct server_events server_events = {
|
||||
AVBTP_VERSION_SERVER_EVENTS,
|
||||
.destroy = acmp_destroy,
|
||||
.message = acmp_message,
|
||||
.command = acmp_command
|
||||
};
|
||||
|
||||
struct avbtp_acmp *avbtp_acmp_register(struct server *server)
|
||||
{
|
||||
struct acmp *acmp;
|
||||
|
||||
acmp = calloc(1, sizeof(*acmp));
|
||||
if (acmp == NULL)
|
||||
return NULL;
|
||||
|
||||
acmp->server = server;
|
||||
|
||||
avdecc_server_add_listener(server, &acmp->server_listener, &server_events, acmp);
|
||||
|
||||
return (struct avbtp_acmp*)acmp;
|
||||
}
|
||||
|
||||
void avbtp_acmp_unregister(struct avbtp_acmp *acmp)
|
||||
{
|
||||
acmp_destroy(acmp);
|
||||
}
|
||||
91
src/modules/module-avbtp/acmp.h
Normal file
91
src/modules/module-avbtp/acmp.h
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
/* AVB support
|
||||
*
|
||||
* Copyright © 2022 Wim Taymans
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef AVBTP_ACMP_H
|
||||
#define AVBTP_ACMP_H
|
||||
|
||||
#include "packets.h"
|
||||
#include "internal.h"
|
||||
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_CONNECT_TX_COMMAND 0
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_CONNECT_TX_RESPONSE 1
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_TX_COMMAND 2
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_TX_RESPONSE 3
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_TX_STATE_COMMAND 4
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_TX_STATE_RESPONSE 5
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_CONNECT_RX_COMMAND 6
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_CONNECT_RX_RESPONSE 7
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_RX_COMMAND 8
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_DISCONNECT_RX_RESPONSE 9
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_RX_STATE_COMMAND 10
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_RX_STATE_RESPONSE 11
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_COMMAND 12
|
||||
#define AVBTP_ACMP_MESSAGE_TYPE_GET_TX_CONNECTION_RESPONSE 13
|
||||
|
||||
#define AVBTP_ACMP_STATUS_SUCCESS 0
|
||||
#define AVBTP_ACMP_STATUS_LISTENER_UNKNOWN_ID 1
|
||||
#define AVBTP_ACMP_STATUS_TALKER_UNKNOWN_ID 2
|
||||
#define AVBTP_ACMP_STATUS_TALKER_DEST_MAC_FAIL 3
|
||||
#define AVBTP_ACMP_STATUS_TALKER_NO_STREAM_INDEX 4
|
||||
#define AVBTP_ACMP_STATUS_TALKER_NO_BANDWIDTH 5
|
||||
#define AVBTP_ACMP_STATUS_TALKER_EXCLUSIVE 6
|
||||
#define AVBTP_ACMP_STATUS_LISTENER_TALKER_TIMEOUT 7
|
||||
#define AVBTP_ACMP_STATUS_LISTENER_EXCLUSIVE 8
|
||||
#define AVBTP_ACMP_STATUS_STATE_UNAVAILABLE 9
|
||||
#define AVBTP_ACMP_STATUS_NOT_CONNECTED 10
|
||||
#define AVBTP_ACMP_STATUS_NO_SUCH_CONNECTION 11
|
||||
#define AVBTP_ACMP_STATUS_COULD_NOT_SEND_MESSAGE 12
|
||||
#define AVBTP_ACMP_STATUS_TALKER_MISBEHAVING 13
|
||||
#define AVBTP_ACMP_STATUS_LISTENER_MISBEHAVING 14
|
||||
#define AVBTP_ACMP_STATUS_RESERVED 15
|
||||
#define AVBTP_ACMP_STATUS_CONTROLLER_NOT_AUTHORIZED 16
|
||||
#define AVBTP_ACMP_STATUS_INCOMPATIBLE_REQUEST 17
|
||||
#define AVBTP_ACMP_STATUS_LISTENER_INVALID_CONNECTION 18
|
||||
#define AVBTP_ACMP_STATUS_NOT_SUPPORTED 31
|
||||
|
||||
struct avbtp_packet_acmp {
|
||||
struct avbtp_packet_header hdr;
|
||||
uint64_t stream_id;
|
||||
uint64_t controller_guid;
|
||||
uint64_t talker_guid;
|
||||
uint64_t listener_guid;
|
||||
uint16_t talker_unique_id;
|
||||
uint16_t listener_unique_id;
|
||||
char stream_dest_mac[6];
|
||||
uint16_t connection_count;
|
||||
uint16_t sequence_id;
|
||||
uint16_t flags;
|
||||
uint16_t stream_vlan_id;
|
||||
uint16_t reserved;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define AVBTP_PACKET_ACMP_SET_MESSAGE_TYPE(p,v) AVBTP_PACKET_SET_SUB1(&(p)->hdr, v)
|
||||
#define AVBTP_PACKET_ACMP_SET_STATUS(p,v) AVBTP_PACKET_SET_SUB2(&(p)->hdr, v)
|
||||
|
||||
#define AVBTP_PACKET_ACMP_GET_MESSAGE_TYPE(p) AVBTP_PACKET_GET_SUB1(&(p)->hdr)
|
||||
#define AVBTP_PACKET_ACMP_GET_STATUS(p) AVBTP_PACKET_GET_SUB2(&(p)->hdr)
|
||||
|
||||
struct avbtp_acmp *avbtp_acmp_register(struct server *server);
|
||||
|
||||
#endif /* AVBTP_ACMP_H */
|
||||
|
|
@ -27,7 +27,9 @@
|
|||
#include <pipewire/pipewire.h>
|
||||
|
||||
#include "adp.h"
|
||||
#include "aecp-aem-descriptors.h"
|
||||
#include "internal.h"
|
||||
#include "utils.h"
|
||||
|
||||
struct entity {
|
||||
struct spa_list link;
|
||||
|
|
@ -41,7 +43,6 @@ struct adp {
|
|||
struct spa_hook server_listener;
|
||||
|
||||
struct spa_list entities;
|
||||
uint64_t now;
|
||||
uint32_t available_index;
|
||||
};
|
||||
|
||||
|
|
@ -49,7 +50,7 @@ static struct entity *find_entity_by_id(struct adp *adp, uint64_t id)
|
|||
{
|
||||
struct entity *e;
|
||||
spa_list_for_each(e, &adp->entities, link)
|
||||
if (AVBTP_PACKET_ADP_GET_ENTITY_ID(&e->packet) == id)
|
||||
if (be64toh(e->packet.entity_id) == id)
|
||||
return e;
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -59,154 +60,19 @@ static void entity_free(struct entity *e)
|
|||
free(e);
|
||||
}
|
||||
|
||||
struct bit_info {
|
||||
uint32_t bits;
|
||||
const char *value;
|
||||
const char *description;
|
||||
};
|
||||
|
||||
static const struct bit_info entity_capabilities_info[] = {
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_EFU_MODE, "efu-mode", "EFU Mode" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_ADDRESS_ACCESS_SUPPORTED, "address-access-supported", "Address Access Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_GATEWAY_ENTITY, "gateway-entity", "Gateway Entity" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_SUPPORTED, "aem-supported", "AEM Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_LEGACY_AVC, "legacy-avc", "Legacy AVC" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_ASSOCIATION_ID_SUPPORTED, "association-id-supported", "Association Id Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_ASSOCIATION_ID_VALID, "association-id-valid", "Association Id Valid" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_VENDOR_UNIQUE_SUPPORTED, "vandor-unique-suported", "Vendor Unique Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_CLASS_A_SUPPORTED, "class-a-supported", "Class A Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_CLASS_B_SUPPORTED, "class-b-supported", "Class B Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_GPTP_SUPPORTED, "gptp-supported", "gPTP Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_AUTHENTICATION_SUPPORTED, "aem-authentication-supported", "AEM Authentication Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_AUTHENTICATION_REQUIRED, "aem-authentication-required", "AEM Authentication Required" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_PERSISTENT_ACQUIRE_SUPPORTED, "aem-persistent-acquire-supported", "AEM Persisitent Acquire Supported" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_IDENTIFY_CONTROL_INDEX_VALID, "aem-identify-control-index-valid", "AEM Identify Control Index Valid" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_AEM_INTERFACE_INDEX_VALID, "aem-interface-index-valid", "AEM Interface Index Valid" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_GENERAL_CONTROLLER_IGNORE, "general-controller-ignore", "General Controller Ignore" },
|
||||
{ AVBTP_ADP_ENTITY_CAPABILITY_ENTITY_NOT_READY, "Entity Not Ready" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
static const struct bit_info talker_capabilities_info[] = {
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_IMPLEMENTED, "implemented", "Implemented" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_OTHER_SOURCE, "other-source", "Other Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_CONTROL_SOURCE, "control-source", "Control Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_MEDIA_CLOCK_SOURCE, "media-clock-source", "Media Clock Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_SMPTE_SOURCE, "smpte-source", "SMPTE Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_MIDI_SOURCE, "midi-source", "MIDI Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_AUDIO_SOURCE, "audio-source", "Audio Source" },
|
||||
{ AVBTP_ADP_TALKER_CAPABILITY_VIDEO_SOURCE, "video-source", "Video Source" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const struct bit_info listener_capabilities_info[] = {
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_IMPLEMENTED, "implemented", "Implemented" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_OTHER_SINK, "other-sink", "Other Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_CONTROL_SINK, "control-sink", "Control Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_MEDIA_CLOCK_SINK, "media-clock-sink", "Media Clock Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_SMPTE_SINK, "smpte-sink", "SMPTE Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_MIDI_SINK, "midi-sink", "MIDI Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_AUDIO_SINK, "audio-sink", "Audio Sink" },
|
||||
{ AVBTP_ADP_LISTENER_CAPABILITY_VIDEO_SINK, "video-sink", "Video Sink" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static const struct bit_info controller_capabilities_info[] = {
|
||||
{ AVBTP_ADP_CONTROLLER_CAPABILITY_IMPLEMENTED, "implemented", "Implemented" },
|
||||
{ AVBTP_ADP_CONTROLLER_CAPABILITY_LAYER3_PROXY, "layer-3-proxy", "Layer 3 Proxy" },
|
||||
{ 0, NULL },
|
||||
};
|
||||
|
||||
static void print_bit_info(int indent, uint32_t bits, const struct bit_info *info)
|
||||
static int send_departing(struct adp *adp, uint64_t now, struct entity *e)
|
||||
{
|
||||
uint32_t i;
|
||||
for (i = 0; info[i].value; i++) {
|
||||
if ((info[i].bits & bits) == info[i].bits)
|
||||
pw_log_info("%*.s%08x %s", indent, "", info[i].bits, info[i].value);
|
||||
}
|
||||
}
|
||||
|
||||
static const char *message_type_as_string(uint8_t message_type)
|
||||
{
|
||||
switch (message_type) {
|
||||
case AVBTP_ADP_MESSAGE_TYPE_ENTITY_AVAILABLE:
|
||||
return "ENTITY_AVAIALABLE";
|
||||
case AVBTP_ADP_MESSAGE_TYPE_ENTITY_DEPARTING:
|
||||
return "ENTITY_DEPARTING";
|
||||
case AVBTP_ADP_MESSAGE_TYPE_ENTITY_DISCOVER:
|
||||
return "ENTITY_DISCOVER";
|
||||
}
|
||||
return "INVALID";
|
||||
}
|
||||
|
||||
#define KEY_VALID_TIME "valid-time"
|
||||
#define KEY_ENTITY_ID "entity-id"
|
||||
#define KEY_ENTITY_MODEL_ID "entity-model-id"
|
||||
#define KEY_ENTITY_CAPABILITIES "entity-capabilities"
|
||||
#define KEY_TALKER_STREAM_SOURCES "talker-stream-sources"
|
||||
#define KEY_TALKER_CAPABILITIES "talker-capabilities"
|
||||
#define KEY_LISTENER_STREAM_SINKS "listener-stream-sinks"
|
||||
#define KEY_LISTENER_CAPABILITIES "listener-capabilities"
|
||||
#define KEY_CONTROLLER_CAPABILITIES "controller-capabilities"
|
||||
#define KEY_AVAILABLE_INDEX "available-index"
|
||||
#define KEY_GPTP_GRANDMASTER_ID "gptp-grandmaster-id"
|
||||
#define KEY_GPTP_DOMAIN_NUMBER "gptp-domain-number"
|
||||
#define KEY_IDENTIFY_CONTROL_INDEX "indentify-control-index"
|
||||
#define KEY_INTERFACE_INDEX "interface-index"
|
||||
#define KEY_ASSOCIATION_ID "association-id"
|
||||
|
||||
static inline char *format_id(char *str, size_t size, const uint64_t id)
|
||||
{
|
||||
snprintf(str, size, "%02x:%02x:%02x:%02x:%02x:%02x:%04x",
|
||||
(uint8_t)(id >> 56),
|
||||
(uint8_t)(id >> 48),
|
||||
(uint8_t)(id >> 40),
|
||||
(uint8_t)(id >> 32),
|
||||
(uint8_t)(id >> 24),
|
||||
(uint8_t)(id >> 16),
|
||||
(uint16_t)(id));
|
||||
return str;
|
||||
}
|
||||
|
||||
static void adp_message_debug(struct adp *adp, const struct avbtp_packet_adp *p)
|
||||
{
|
||||
uint32_t v;
|
||||
char buf[256];
|
||||
|
||||
v = AVBTP_PACKET_ADP_GET_MESSAGE_TYPE(p);
|
||||
pw_log_info("message-type: %d (%s)", v, message_type_as_string(v));
|
||||
pw_log_info(" length: %d", AVBTP_PACKET_GET_LENGTH(&p->hdr));
|
||||
pw_log_info(" "KEY_VALID_TIME": %d", AVBTP_PACKET_ADP_GET_VALID_TIME(p));
|
||||
pw_log_info(" "KEY_ENTITY_ID": %s",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_ENTITY_ID(p)));
|
||||
pw_log_info(" "KEY_ENTITY_MODEL_ID": %s",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_ENTITY_MODEL_ID(p)));
|
||||
v = AVBTP_PACKET_ADP_GET_ENTITY_CAPABILITIES(p);
|
||||
pw_log_info(" "KEY_ENTITY_CAPABILITIES": 0x%08x", v);
|
||||
print_bit_info(4, v, entity_capabilities_info);
|
||||
pw_log_info(" "KEY_TALKER_STREAM_SOURCES": %d", AVBTP_PACKET_ADP_GET_TALKER_STREAM_SOURCES(p));
|
||||
v = AVBTP_PACKET_ADP_GET_TALKER_CAPABILITIES(p);
|
||||
pw_log_info(" "KEY_TALKER_CAPABILITIES": %04x", v);
|
||||
print_bit_info(4, v, talker_capabilities_info);
|
||||
pw_log_info(" "KEY_LISTENER_STREAM_SINKS": %d", AVBTP_PACKET_ADP_GET_LISTENER_STREAM_SINKS(p));
|
||||
v = AVBTP_PACKET_ADP_GET_LISTENER_CAPABILITIES(p);
|
||||
pw_log_info(" "KEY_LISTENER_CAPABILITIES": %04x", v);
|
||||
print_bit_info(4, v, listener_capabilities_info);
|
||||
v = AVBTP_PACKET_ADP_GET_CONTROLLER_CAPABILITIES(p);
|
||||
pw_log_info(" "KEY_CONTROLLER_CAPABILITIES": %08x", v);
|
||||
print_bit_info(4, v, controller_capabilities_info);
|
||||
pw_log_info(" "KEY_AVAILABLE_INDEX": 0x%08x", AVBTP_PACKET_ADP_GET_AVAILABLE_INDEX(p));
|
||||
pw_log_info(" "KEY_GPTP_GRANDMASTER_ID": %s",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_GPTP_GRANDMASTER_ID(p)));
|
||||
pw_log_info(" "KEY_GPTP_DOMAIN_NUMBER": %d", AVBTP_PACKET_ADP_GET_GPTP_DOMAIN_NUMBER(p));
|
||||
pw_log_info(" "KEY_IDENTIFY_CONTROL_INDEX": %d", AVBTP_PACKET_ADP_GET_IDENTIFY_CONTROL_INDEX(p));
|
||||
pw_log_info(" "KEY_INTERFACE_INDEX": %d", AVBTP_PACKET_ADP_GET_INTERFACE_INDEX(p));
|
||||
pw_log_info(" "KEY_ASSOCIATION_ID": %s",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_ASSOCIATION_ID(p)));
|
||||
AVBTP_PACKET_ADP_SET_MESSAGE_TYPE(&e->packet, AVBTP_ADP_MESSAGE_TYPE_ENTITY_DEPARTING);
|
||||
e->packet.available_index = htonl(adp->available_index++);
|
||||
avbtp_server_broadcast_packet(adp->server, &e->packet, sizeof(e->packet));
|
||||
e->last_time = now;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int send_advertise(struct adp *adp, uint64_t now, struct entity *e)
|
||||
{
|
||||
AVBTP_PACKET_ADP_SET_AVAILABLE_INDEX(&e->packet, adp->available_index++);
|
||||
AVBTP_PACKET_ADP_SET_MESSAGE_TYPE(&e->packet, AVBTP_ADP_MESSAGE_TYPE_ENTITY_AVAILABLE);
|
||||
e->packet.available_index = htonl(adp->available_index++);
|
||||
avbtp_server_broadcast_packet(adp->server, &e->packet, sizeof(e->packet));
|
||||
e->last_time = now;
|
||||
return 0;
|
||||
|
|
@ -219,7 +85,7 @@ static int send_discover(struct adp *adp, uint64_t entity_id)
|
|||
AVBTP_PACKET_SET_SUBTYPE(&p.hdr, AVBTP_SUBTYPE_ADP);
|
||||
AVBTP_PACKET_SET_LENGTH(&p.hdr, AVBTP_ADP_DATA_LENGTH);
|
||||
AVBTP_PACKET_ADP_SET_MESSAGE_TYPE(&p, AVBTP_ADP_MESSAGE_TYPE_ENTITY_DISCOVER);
|
||||
AVBTP_PACKET_ADP_SET_ENTITY_ID(&p, entity_id);
|
||||
p.entity_id = htonl(entity_id);
|
||||
avbtp_server_broadcast_packet(adp->server, &p, sizeof(p));
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -237,11 +103,8 @@ static int adp_message(void *data, uint64_t now, const void *message, int len)
|
|||
AVBTP_PACKET_GET_LENGTH(&p->hdr) != AVBTP_ADP_DATA_LENGTH)
|
||||
return 0;
|
||||
|
||||
if (adp->server->debug_messages)
|
||||
adp_message_debug(adp, p);
|
||||
|
||||
message_type = AVBTP_PACKET_ADP_GET_MESSAGE_TYPE(p);
|
||||
entity_id = AVBTP_PACKET_ADP_GET_ENTITY_ID(p);
|
||||
entity_id = be64toh(p->entity_id);
|
||||
|
||||
e = find_entity_by_id(adp, entity_id);
|
||||
|
||||
|
|
@ -255,23 +118,23 @@ static int adp_message(void *data, uint64_t now, const void *message, int len)
|
|||
e->packet = *p;
|
||||
spa_list_append(&adp->entities, &e->link);
|
||||
pw_log_info("entity %s available",
|
||||
format_id(buf, sizeof(buf), entity_id));
|
||||
avbtp_utils_format_id(buf, sizeof(buf), entity_id));
|
||||
}
|
||||
e->last_time = adp->now = now;
|
||||
e->last_time = now;
|
||||
break;
|
||||
case AVBTP_ADP_MESSAGE_TYPE_ENTITY_DEPARTING:
|
||||
if (e != NULL) {
|
||||
pw_log_info("entity %s departing",
|
||||
format_id(buf, sizeof(buf), entity_id));
|
||||
avbtp_utils_format_id(buf, sizeof(buf), entity_id));
|
||||
entity_free(e);
|
||||
}
|
||||
break;
|
||||
case AVBTP_ADP_MESSAGE_TYPE_ENTITY_DISCOVER:
|
||||
if (entity_id == 0UL ||
|
||||
(e != NULL && e->advertise &&
|
||||
AVBTP_PACKET_ADP_GET_ENTITY_ID(&e->packet) == entity_id)) {
|
||||
be64toh(e->packet.entity_id) == entity_id)) {
|
||||
pw_log_info("entity %s discover",
|
||||
format_id(buf, sizeof(buf), entity_id));
|
||||
avbtp_utils_format_id(buf, sizeof(buf), entity_id));
|
||||
send_discover(adp, entity_id);
|
||||
}
|
||||
break;
|
||||
|
|
@ -288,7 +151,7 @@ static void adp_destroy(void *data)
|
|||
free(adp);
|
||||
}
|
||||
|
||||
static void check_entries(struct adp *adp, uint64_t now)
|
||||
static void check_timeout(struct adp *adp, uint64_t now)
|
||||
{
|
||||
struct entity *e, *t;
|
||||
char buf[128];
|
||||
|
|
@ -296,106 +159,131 @@ static void check_entries(struct adp *adp, uint64_t now)
|
|||
spa_list_for_each_safe(e, t, &adp->entities, link) {
|
||||
int valid_time = AVBTP_PACKET_ADP_GET_VALID_TIME(&e->packet);
|
||||
|
||||
if (e->advertise) {
|
||||
if (e->last_time + (valid_time / 2) * SPA_NSEC_PER_SEC > now)
|
||||
continue;
|
||||
|
||||
pw_log_info("entity %s readvertise",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_ENTITY_ID(&e->packet)));
|
||||
|
||||
send_advertise(adp, now, e);
|
||||
} else {
|
||||
if (e->last_time + (valid_time + 2) * SPA_NSEC_PER_SEC > now)
|
||||
continue;
|
||||
|
||||
pw_log_info("entity %s timeout",
|
||||
format_id(buf, sizeof(buf), AVBTP_PACKET_ADP_GET_ENTITY_ID(&e->packet)));
|
||||
avbtp_utils_format_id(buf, sizeof(buf),
|
||||
be64toh(e->packet.entity_id)));
|
||||
|
||||
if (e->advertise)
|
||||
send_departing(adp, now, e);
|
||||
|
||||
entity_free(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
static void adp_periodic(void *data, uint64_t now)
|
||||
static void check_readvertize(struct adp *adp, uint64_t now, struct entity *e)
|
||||
{
|
||||
struct adp *adp = data;
|
||||
check_entries(adp, now);
|
||||
int valid_time = AVBTP_PACKET_ADP_GET_VALID_TIME(&e->packet);
|
||||
char buf[128];
|
||||
|
||||
if (!e->advertise)
|
||||
return;
|
||||
|
||||
if (e->last_time + (valid_time / 2) * SPA_NSEC_PER_SEC > now)
|
||||
return;
|
||||
|
||||
pw_log_debug("entity %s readvertise",
|
||||
avbtp_utils_format_id(buf, sizeof(buf),
|
||||
be64toh(e->packet.entity_id)));
|
||||
|
||||
send_advertise(adp, now, e);
|
||||
}
|
||||
|
||||
static int parse_id(const char *value, int len, uint64_t *id)
|
||||
{
|
||||
char str[64];
|
||||
uint8_t v[6];
|
||||
uint16_t unique_id;
|
||||
if (spa_json_parse_stringn(value, len, str, sizeof(str)) <= 0)
|
||||
return -EINVAL;
|
||||
if (sscanf(str, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hx",
|
||||
&v[0], &v[1], &v[2], &v[3],
|
||||
&v[4], &v[5], &unique_id) == 7) {
|
||||
*id = (uint64_t) v[0] << 56 |
|
||||
(uint64_t) v[1] << 48 |
|
||||
(uint64_t) v[2] << 40 |
|
||||
(uint64_t) v[3] << 32 |
|
||||
(uint64_t) v[4] << 24 |
|
||||
(uint64_t) v[5] << 16 |
|
||||
unique_id;
|
||||
} else if (!spa_atou64(str, id, 0))
|
||||
return -EINVAL;
|
||||
return 1;
|
||||
}
|
||||
static int parse_bits(struct spa_json *it, const char *value, int len, const struct bit_info *info, int *bits)
|
||||
{
|
||||
uint32_t i;
|
||||
int b = 0;
|
||||
struct spa_json sub;
|
||||
char val[256];
|
||||
|
||||
if (spa_json_is_array(value, len)) {
|
||||
spa_json_enter(it, &sub);
|
||||
while (spa_json_get_string(&sub, val, sizeof(val)) > 0) {
|
||||
for (i = 0; info[i].value; i++) {
|
||||
if (spa_streq(val, info[i].value)) {
|
||||
b |= info[i].bits;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (!spa_json_parse_int(value, len, &b)) {
|
||||
return -EINVAL;
|
||||
}
|
||||
*bits = b;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int do_help(struct adp *adp, const char *args)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_advertise(struct adp *adp, const char *args)
|
||||
static int check_advertise(struct adp *adp, uint64_t now)
|
||||
{
|
||||
struct server *server = adp->server;
|
||||
const struct descriptor *d;
|
||||
struct avbtp_aem_desc_entity *entity;
|
||||
struct avbtp_aem_desc_avb_interface *avb_interface;
|
||||
struct entity *e;
|
||||
struct spa_json it[2];
|
||||
char key[128];
|
||||
uint64_t entity_id;
|
||||
struct avbtp_packet_adp *p;
|
||||
char buf[128];
|
||||
|
||||
d = server_find_descriptor(server, AVBTP_AEM_DESC_ENTITY, 0);
|
||||
if (d == NULL)
|
||||
return 0;
|
||||
|
||||
entity = d->ptr;
|
||||
entity_id = be64toh(entity->entity_id);
|
||||
|
||||
if ((e = find_entity_by_id(adp, entity_id)) != NULL) {
|
||||
if (e->advertise)
|
||||
check_readvertize(adp, now, e);
|
||||
return 0;
|
||||
}
|
||||
|
||||
d = server_find_descriptor(server, AVBTP_AEM_DESC_AVB_INTERFACE, 0);
|
||||
avb_interface = d ? d->ptr : NULL;
|
||||
|
||||
pw_log_info("entity %s advertise",
|
||||
avbtp_utils_format_id(buf, sizeof(buf), entity_id));
|
||||
|
||||
e = calloc(1, sizeof(*e));
|
||||
if (e == NULL)
|
||||
return -errno;
|
||||
|
||||
e->advertise = true;
|
||||
e->last_time = adp->now;
|
||||
e->last_time = now;
|
||||
|
||||
p = &e->packet;
|
||||
AVBTP_PACKET_SET_LENGTH(&p->hdr, AVBTP_ADP_DATA_LENGTH);
|
||||
AVBTP_PACKET_SET_SUBTYPE(&p->hdr, AVBTP_SUBTYPE_ADP);
|
||||
AVBTP_PACKET_ADP_SET_ENTITY_ID(p, server->entity_id);
|
||||
AVBTP_PACKET_ADP_SET_MESSAGE_TYPE(p, AVBTP_ADP_MESSAGE_TYPE_ENTITY_AVAILABLE);
|
||||
AVBTP_PACKET_ADP_SET_VALID_TIME(p, 10);
|
||||
|
||||
p->entity_id = entity->entity_id;
|
||||
p->entity_model_id = entity->entity_model_id;
|
||||
p->entity_capabilities = entity->entity_capabilities;
|
||||
p->talker_stream_sources = entity->talker_stream_sources;
|
||||
p->talker_capabilities = entity->talker_capabilities;
|
||||
p->listener_stream_sinks = entity->listener_stream_sinks;
|
||||
p->listener_capabilities = entity->listener_capabilities;
|
||||
p->controller_capabilities = entity->controller_capabilities;
|
||||
p->available_index = entity->available_index;
|
||||
if (avb_interface) {
|
||||
p->gptp_grandmaster_id = avb_interface->clock_identity;
|
||||
p->gptp_domain_number = avb_interface->domain_number;
|
||||
}
|
||||
p->identify_control_index = 0;
|
||||
p->interface_index = 0;
|
||||
p->association_id = entity->association_id;
|
||||
|
||||
spa_list_append(&adp->entities, &e->link);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void adp_periodic(void *data, uint64_t now)
|
||||
{
|
||||
struct adp *adp = data;
|
||||
check_timeout(adp, now);
|
||||
check_advertise(adp, now);
|
||||
}
|
||||
|
||||
static int do_help(struct adp *adp, const char *args, FILE *out)
|
||||
{
|
||||
fprintf(out, "{ \"type\": \"help\","
|
||||
"\"text\": \""
|
||||
"/adp/help: this help \\n"
|
||||
"/adp/discover [{ \"entity-id\": <id> }] : trigger discover\\n"
|
||||
"\" }");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_discover(struct adp *adp, const char *args, FILE *out)
|
||||
{
|
||||
struct spa_json it[2];
|
||||
char key[128];
|
||||
uint64_t entity_id = 0ULL;
|
||||
|
||||
spa_json_init(&it[0], args, strlen(args));
|
||||
if (spa_json_enter_object(&it[0], &it[1]) <= 0)
|
||||
return -EINVAL;
|
||||
|
||||
while (spa_json_get_string(&it[1], key, sizeof(key)) > 0) {
|
||||
int len, int_val;
|
||||
int len;
|
||||
const char *value;
|
||||
uint64_t id_val;
|
||||
|
||||
|
|
@ -405,77 +293,16 @@ static int do_advertise(struct adp *adp, const char *args)
|
|||
if (spa_json_is_null(value, len))
|
||||
continue;
|
||||
|
||||
if (spa_streq(key, KEY_VALID_TIME)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_VALID_TIME(p, int_val);
|
||||
} else if (spa_streq(key, KEY_ENTITY_ID)) {
|
||||
if (parse_id(value, len, &id_val) > 0)
|
||||
AVBTP_PACKET_ADP_SET_ENTITY_ID(p, id_val);
|
||||
} else if (spa_streq(key, KEY_ENTITY_MODEL_ID)) {
|
||||
if (parse_id(value, len, &id_val) > 0)
|
||||
AVBTP_PACKET_ADP_SET_ENTITY_MODEL_ID(p, id_val);
|
||||
} else if (spa_streq(key, KEY_ENTITY_CAPABILITIES)) {
|
||||
if (parse_bits(&it[1], value, len, entity_capabilities_info, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_ENTITY_CAPABILITIES(p, int_val);
|
||||
} else if (spa_streq(key, KEY_TALKER_STREAM_SOURCES)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_TALKER_STREAM_SOURCES(p, int_val);
|
||||
} else if (spa_streq(key, KEY_TALKER_CAPABILITIES)) {
|
||||
if (parse_bits(&it[1], value, len, talker_capabilities_info, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_TALKER_CAPABILITIES(p, int_val);
|
||||
} else if (spa_streq(key, KEY_LISTENER_STREAM_SINKS)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_LISTENER_STREAM_SINKS(p, int_val);
|
||||
} else if (spa_streq(key, KEY_LISTENER_CAPABILITIES)) {
|
||||
if (parse_bits(&it[1], value, len, listener_capabilities_info, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_LISTENER_CAPABILITIES(p, int_val);
|
||||
} else if (spa_streq(key, KEY_CONTROLLER_CAPABILITIES)) {
|
||||
if (parse_bits(&it[1], value, len, controller_capabilities_info, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_CONTROLLER_CAPABILITIES(p, int_val);
|
||||
} else if (spa_streq(key, KEY_AVAILABLE_INDEX)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_AVAILABLE_INDEX(p, int_val);
|
||||
} else if (spa_streq(key, KEY_GPTP_GRANDMASTER_ID)) {
|
||||
if (parse_id(value, len, &id_val) > 0)
|
||||
AVBTP_PACKET_ADP_SET_GPTP_GRANDMASTER_ID(p, id_val);
|
||||
} else if (spa_streq(key, KEY_GPTP_DOMAIN_NUMBER)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_GPTP_DOMAIN_NUMBER(p, int_val);
|
||||
} else if (spa_streq(key, KEY_IDENTIFY_CONTROL_INDEX)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_IDENTIFY_CONTROL_INDEX(p, int_val);
|
||||
} else if (spa_streq(key, KEY_INTERFACE_INDEX)) {
|
||||
if (spa_json_parse_int(value, len, &int_val))
|
||||
AVBTP_PACKET_ADP_SET_INTERFACE_INDEX(p, int_val);
|
||||
} else if (spa_streq(key, KEY_ASSOCIATION_ID)) {
|
||||
if (parse_id(value, len, &id_val))
|
||||
AVBTP_PACKET_ADP_SET_ASSOCIATION_ID(p, id_val);
|
||||
if (spa_streq(key, "entity-id")) {
|
||||
if (avbtp_utils_parse_id(value, len, &id_val) >= 0)
|
||||
entity_id = id_val;
|
||||
}
|
||||
}
|
||||
if (find_entity_by_id(adp, AVBTP_PACKET_ADP_GET_ENTITY_ID(p))) {
|
||||
free(e);
|
||||
return -EEXIST;
|
||||
}
|
||||
spa_list_append(&adp->entities, &e->link);
|
||||
|
||||
if (adp->server->debug_messages)
|
||||
adp_message_debug(adp, p);
|
||||
|
||||
send_discover(adp, entity_id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_depart(struct adp *adp, const char *args)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_discover(struct adp *adp, const char *args)
|
||||
{
|
||||
send_discover(adp, 0UL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int adp_command(void *data, uint64_t now, const char *command, const char *args)
|
||||
static int adp_command(void *data, uint64_t now, const char *command, const char *args, FILE *out)
|
||||
{
|
||||
struct adp *adp = data;
|
||||
int res;
|
||||
|
|
@ -484,16 +311,11 @@ static int adp_command(void *data, uint64_t now, const char *command, const char
|
|||
return 0;
|
||||
|
||||
command += strlen("/adp/");
|
||||
adp->now = now;
|
||||
|
||||
if (spa_streq(command, "help"))
|
||||
res = do_help(adp, args);
|
||||
else if (spa_streq(command, "advertise"))
|
||||
res = do_advertise(adp, args);
|
||||
else if (spa_streq(command, "depart"))
|
||||
res = do_depart(adp, args);
|
||||
res = do_help(adp, args, out);
|
||||
else if (spa_streq(command, "discover"))
|
||||
res = do_discover(adp, args);
|
||||
res = do_discover(adp, args, out);
|
||||
else
|
||||
res = -ENOTSUP;
|
||||
|
||||
|
|
|
|||
|
|
@ -96,37 +96,9 @@ struct avbtp_packet_adp {
|
|||
|
||||
#define AVBTP_PACKET_ADP_SET_MESSAGE_TYPE(p,v) AVBTP_PACKET_SET_SUB1(&(p)->hdr, v)
|
||||
#define AVBTP_PACKET_ADP_SET_VALID_TIME(p,v) AVBTP_PACKET_SET_SUB2(&(p)->hdr, v)
|
||||
#define AVBTP_PACKET_ADP_SET_ENTITY_ID(p,v) ((p)->entity_id = htobe64(v))
|
||||
#define AVBTP_PACKET_ADP_SET_ENTITY_MODEL_ID(p,v) ((p)->entity_model_id = htobe64(v))
|
||||
#define AVBTP_PACKET_ADP_SET_ENTITY_CAPABILITIES(p,v) ((p)->entity_capabilities = htonl(v))
|
||||
#define AVBTP_PACKET_ADP_SET_TALKER_STREAM_SOURCES(p,v) ((p)->talker_stream_sources = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_TALKER_CAPABILITIES(p,v) ((p)->talker_capabilities = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_LISTENER_STREAM_SINKS(p,v) ((p)->listener_stream_sinks = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_LISTENER_CAPABILITIES(p,v) ((p)->listener_capabilities = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_CONTROLLER_CAPABILITIES(p,v) ((p)->controller_capabilities = htonl(v))
|
||||
#define AVBTP_PACKET_ADP_SET_AVAILABLE_INDEX(p,v) ((p)->available_index = htonl(v))
|
||||
#define AVBTP_PACKET_ADP_SET_GPTP_GRANDMASTER_ID(p,v) ((p)->gptp_grandmaster_id = htobe64(v))
|
||||
#define AVBTP_PACKET_ADP_SET_GPTP_DOMAIN_NUMBER(p,v) ((p)->gptp_domain_number = (v))
|
||||
#define AVBTP_PACKET_ADP_SET_IDENTIFY_CONTROL_INDEX(p,v) ((p)->identify_control_index = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_INTERFACE_INDEX(p,v) ((p)->interface_index = htons(v))
|
||||
#define AVBTP_PACKET_ADP_SET_ASSOCIATION_ID(p,v) ((p)->association_id = htobe64(v))
|
||||
|
||||
#define AVBTP_PACKET_ADP_GET_MESSAGE_TYPE(p) AVBTP_PACKET_GET_SUB1(&(p)->hdr)
|
||||
#define AVBTP_PACKET_ADP_GET_VALID_TIME(p) AVBTP_PACKET_GET_SUB2(&(p)->hdr)
|
||||
#define AVBTP_PACKET_ADP_GET_ENTITY_ID(p) be64toh((p)->entity_id)
|
||||
#define AVBTP_PACKET_ADP_GET_ENTITY_MODEL_ID(p) be64toh((p)->entity_model_id)
|
||||
#define AVBTP_PACKET_ADP_GET_ENTITY_CAPABILITIES(p) ntohl((p)->entity_capabilities)
|
||||
#define AVBTP_PACKET_ADP_GET_TALKER_STREAM_SOURCES(p) ntohs((p)->talker_stream_sources)
|
||||
#define AVBTP_PACKET_ADP_GET_TALKER_CAPABILITIES(p) ntohs((p)->talker_capabilities)
|
||||
#define AVBTP_PACKET_ADP_GET_LISTENER_STREAM_SINKS(p) ntohs((p)->listener_stream_sinks)
|
||||
#define AVBTP_PACKET_ADP_GET_LISTENER_CAPABILITIES(p) ntohs((p)->listener_capabilities)
|
||||
#define AVBTP_PACKET_ADP_GET_CONTROLLER_CAPABILITIES(p) ntohl((p)->controller_capabilities)
|
||||
#define AVBTP_PACKET_ADP_GET_AVAILABLE_INDEX(p) ntohl((p)->available_index)
|
||||
#define AVBTP_PACKET_ADP_GET_GPTP_GRANDMASTER_ID(p) be64toh((p)->gptp_grandmaster_id)
|
||||
#define AVBTP_PACKET_ADP_GET_GPTP_DOMAIN_NUMBER(p) ((p)->gptp_domain_number)
|
||||
#define AVBTP_PACKET_ADP_GET_IDENTIFY_CONTROL_INDEX(p) ntohs((p)->identify_control_index)
|
||||
#define AVBTP_PACKET_ADP_GET_INTERFACE_INDEX(p) ntohs((p)->interface_index)
|
||||
#define AVBTP_PACKET_ADP_GET_ASSOCIATION_ID(p) be64toh((p)->association_id)
|
||||
|
||||
struct avbtp_adp *avbtp_adp_register(struct server *server);
|
||||
|
||||
|
|
|
|||
|
|
@ -243,4 +243,5 @@ struct avbtp_aem_desc_stream_port {
|
|||
uint16_t number_of_maps;
|
||||
uint16_t base_map;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#endif /* AVBTP_AECP_AEM_DESCRIPTORS_H */
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ static int handle_acquire_entity(struct aecp *aecp, const void *m, int len)
|
|||
desc_type = ntohs(ae->descriptor_type);
|
||||
desc_id = ntohs(ae->descriptor_id);
|
||||
|
||||
desc = find_descriptor(server, desc_type, desc_id);
|
||||
desc = server_find_descriptor(server, desc_type, desc_id);
|
||||
if (desc == NULL)
|
||||
return reply_status(aecp, AVBTP_AECP_AEM_STATUS_NO_SUCH_DESCRIPTOR, p, len);
|
||||
|
||||
|
|
@ -86,7 +86,7 @@ static int handle_lock_entity(struct aecp *aecp, const void *m, int len)
|
|||
desc_type = ntohs(ae->descriptor_type);
|
||||
desc_id = ntohs(ae->descriptor_id);
|
||||
|
||||
desc = find_descriptor(server, desc_type, desc_id);
|
||||
desc = server_find_descriptor(server, desc_type, desc_id);
|
||||
if (desc == NULL)
|
||||
return reply_status(aecp, AVBTP_AECP_AEM_STATUS_NO_SUCH_DESCRIPTOR, p, len);
|
||||
|
||||
|
|
@ -97,16 +97,16 @@ static int handle_lock_entity(struct aecp *aecp, const void *m, int len)
|
|||
}
|
||||
|
||||
/* READ_DESCRIPTOR */
|
||||
static int handle_read_descriptor(struct aecp *aecp, const void *h, int len)
|
||||
static int handle_read_descriptor(struct aecp *aecp, const void *m, int len)
|
||||
{
|
||||
struct server *server = aecp->server;
|
||||
const struct avbtp_packet_aecp_aem *p = h;
|
||||
struct avbtp_packet_aecp_header *reply;
|
||||
const struct avbtp_packet_aecp_aem *p = m;
|
||||
struct avbtp_packet_aecp_aem *reply;
|
||||
const struct avbtp_packet_aecp_aem_read_descriptor *rd;
|
||||
uint16_t desc_type, desc_id;
|
||||
const struct descriptor *desc;
|
||||
const struct avbtp_packet_aecp_aem_read_descriptor *rd;
|
||||
uint8_t buf[2048];
|
||||
size_t size;
|
||||
size_t size, psize;
|
||||
|
||||
rd = (struct avbtp_packet_aecp_aem_read_descriptor*)p->payload;
|
||||
|
||||
|
|
@ -115,22 +115,72 @@ static int handle_read_descriptor(struct aecp *aecp, const void *h, int len)
|
|||
|
||||
pw_log_info("descriptor type:%04x index:%d", desc_type, desc_id);
|
||||
|
||||
desc = find_descriptor(server, desc_type, desc_id);
|
||||
desc = server_find_descriptor(server, desc_type, desc_id);
|
||||
if (desc == NULL)
|
||||
return reply_status(aecp, AVBTP_AECP_AEM_STATUS_NO_SUCH_DESCRIPTOR, p, len);
|
||||
|
||||
size = sizeof(struct avbtp_packet_aecp_aem) + sizeof(*rd);
|
||||
memcpy(buf, p, len);
|
||||
|
||||
psize = sizeof(*rd);
|
||||
size = sizeof(*reply) + psize;
|
||||
|
||||
memcpy(buf, p, size);
|
||||
memcpy(buf + size, desc->ptr, desc->size);
|
||||
size += desc->size;
|
||||
psize += desc->size;
|
||||
|
||||
reply = (struct avbtp_packet_aecp_header *)buf;
|
||||
AVBTP_PACKET_SET_LENGTH(&reply->hdr, size - 26 );
|
||||
AVBTP_PACKET_AECP_SET_MESSAGE_TYPE(reply, AVBTP_AECP_MESSAGE_TYPE_AEM_RESPONSE);
|
||||
AVBTP_PACKET_AECP_SET_STATUS(reply, AVBTP_AECP_AEM_STATUS_SUCCESS);
|
||||
reply = (struct avbtp_packet_aecp_aem*)buf;
|
||||
AVBTP_PACKET_AECP_SET_MESSAGE_TYPE(&reply->aecp, AVBTP_AECP_MESSAGE_TYPE_AEM_RESPONSE);
|
||||
AVBTP_PACKET_AECP_SET_STATUS(&reply->aecp, AVBTP_AECP_AEM_STATUS_SUCCESS);
|
||||
AVBTP_PACKET_SET_LENGTH(&reply->aecp.hdr, psize + 12);
|
||||
|
||||
return avbtp_server_send_packet(server, reply->hdr.eth.src, reply, size);
|
||||
return avbtp_server_send_packet(server, reply->aecp.hdr.eth.src, reply, size);
|
||||
}
|
||||
|
||||
/* GET_AVB_INFO */
|
||||
static int handle_get_avb_info(struct aecp *aecp, const void *m, int len)
|
||||
{
|
||||
struct server *server = aecp->server;
|
||||
const struct avbtp_packet_aecp_aem *p = m;
|
||||
struct avbtp_packet_aecp_aem *reply;
|
||||
struct avbtp_packet_aecp_aem_get_avb_info *i;
|
||||
struct avbtp_aem_desc_avb_interface *avb_interface;
|
||||
uint16_t desc_type, desc_id;
|
||||
const struct descriptor *desc;
|
||||
uint8_t buf[2048];
|
||||
size_t size, psize;
|
||||
|
||||
i = (struct avbtp_packet_aecp_aem_get_avb_info*)p->payload;
|
||||
|
||||
desc_type = ntohs(i->descriptor_type);
|
||||
desc_id = ntohs(i->descriptor_id);
|
||||
|
||||
desc = server_find_descriptor(server, desc_type, desc_id);
|
||||
if (desc == NULL)
|
||||
return reply_status(aecp, AVBTP_AECP_AEM_STATUS_NO_SUCH_DESCRIPTOR, p, len);
|
||||
|
||||
if (desc_type != AVBTP_AEM_DESC_AVB_INTERFACE || desc_id != 0)
|
||||
return reply_not_implemented(aecp, m, len);
|
||||
|
||||
avb_interface = desc->ptr;
|
||||
|
||||
memcpy(buf, p, len);
|
||||
|
||||
psize = sizeof(*i);
|
||||
size = sizeof(*reply) + psize;
|
||||
|
||||
reply = (struct avbtp_packet_aecp_aem *)buf;
|
||||
AVBTP_PACKET_AECP_SET_MESSAGE_TYPE(&reply->aecp, AVBTP_AECP_MESSAGE_TYPE_AEM_RESPONSE);
|
||||
AVBTP_PACKET_AECP_SET_STATUS(&reply->aecp, AVBTP_AECP_AEM_STATUS_SUCCESS);
|
||||
AVBTP_PACKET_SET_LENGTH(&reply->aecp.hdr, psize + 12);
|
||||
|
||||
i = (struct avbtp_packet_aecp_aem_get_avb_info*)reply->payload;
|
||||
i->gptp_grandmaster_id = avb_interface->clock_identity;
|
||||
i->propagation_delay = htonl(0);
|
||||
i->gptp_domain_number = avb_interface->domain_number;
|
||||
i->flags = 0;
|
||||
i->msrp_mappings_count = htons(0);
|
||||
|
||||
return avbtp_server_send_packet(server, reply->aecp.hdr.eth.src, reply, size);
|
||||
}
|
||||
|
||||
/* AEM_COMMAND */
|
||||
|
|
@ -180,7 +230,7 @@ static const struct cmd_info cmd_info[] = {
|
|||
{ AVBTP_AECP_AEM_CMD_REGISTER_UNSOLICITED_NOTIFICATION, "register-unsolicited-notification", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_DEREGISTER_UNSOLICITED_NOTIFICATION, "deregister-unsolicited-notification", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_IDENTIFY_NOTIFICATION, "identify-notification", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_GET_AVB_INFO, "get-avb-info", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_GET_AVB_INFO, "get-avb-info", handle_get_avb_info, },
|
||||
{ AVBTP_AECP_AEM_CMD_GET_AS_PATH, "get-as-path", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_GET_COUNTERS, "get-counters", NULL, },
|
||||
{ AVBTP_AECP_AEM_CMD_REBOOT, "reboot", NULL, },
|
||||
|
|
|
|||
|
|
@ -270,6 +270,16 @@ struct avbtp_packet_aecp_aem_identify_notification {
|
|||
uint16_t descriptor_id;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct avbtp_packet_aecp_aem_msrp_mapping {
|
||||
uint8_t traffic_class;
|
||||
uint8_t priority;
|
||||
uint16_t vlan_id;
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
#define AVBTP_AEM_AVB_INFO_FLAG_GPTP_GRANDMASTER_SUPPORTED (1u<<0)
|
||||
#define AVBTP_AEM_AVB_INFO_FLAG_GPTP_ENABLED (1u<<1)
|
||||
#define AVBTP_AEM_AVB_INFO_FLAG_SRP_ENABLED (1u<<2)
|
||||
|
||||
struct avbtp_packet_aecp_aem_get_avb_info {
|
||||
uint16_t descriptor_type;
|
||||
uint16_t descriptor_id;
|
||||
|
|
@ -278,7 +288,7 @@ struct avbtp_packet_aecp_aem_get_avb_info {
|
|||
uint8_t gptp_domain_number;
|
||||
uint8_t flags;
|
||||
uint16_t msrp_mappings_count;
|
||||
uint32_t msrp_mappings;
|
||||
uint8_t msrp_mappings[0];
|
||||
} __attribute__ ((__packed__));
|
||||
|
||||
struct avbtp_packet_aecp_aem_get_as_path {
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
struct msg_info {
|
||||
uint16_t type;
|
||||
const char *name;
|
||||
const char *description;
|
||||
int (*handle) (struct aecp *aecp, const void *p, int len);
|
||||
};
|
||||
|
||||
|
|
@ -51,16 +50,16 @@ static int reply_not_implemented(struct aecp *aecp, const void *p, int len)
|
|||
}
|
||||
|
||||
static const struct msg_info msg_info[] = {
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AEM_COMMAND, "aem-command", "AEM Command", avbtp_aecp_aem_handle_command, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AEM_RESPONSE, "aem-response", "AEM Response", avbtp_aecp_aem_handle_response, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_ADDRESS_ACCESS_COMMAND, "address-access-command", "Address Access Command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_ADDRESS_ACCESS_RESPONSE, "address-access-response", "Address Access Response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AVC_COMMAND, "avc-command", "AVC Command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AVC_RESPONSE, "avc-response", "AVC Response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_VENDOR_UNIQUE_COMMAND, "vendor-unique-command", "Vendor Unique Command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_VENDOR_UNIQUE_RESPONSE, "vendor-unique-response", "Vendor Unique Response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_EXTENDED_COMMAND, "extended-command", "Extended Command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_EXTENDED_RESPONSE, "extended-response", "Extended Response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AEM_COMMAND, "aem-command", avbtp_aecp_aem_handle_command, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AEM_RESPONSE, "aem-response", avbtp_aecp_aem_handle_response, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_ADDRESS_ACCESS_COMMAND, "address-access-command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_ADDRESS_ACCESS_RESPONSE, "address-access-response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AVC_COMMAND, "avc-command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_AVC_RESPONSE, "avc-response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_VENDOR_UNIQUE_COMMAND, "vendor-unique-command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_VENDOR_UNIQUE_RESPONSE, "vendor-unique-response", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_EXTENDED_COMMAND, "extended-command", NULL, },
|
||||
{ AVBTP_AECP_MESSAGE_TYPE_EXTENDED_RESPONSE, "extended-response", NULL, },
|
||||
};
|
||||
|
||||
static inline const struct msg_info *find_msg_info(uint16_t type, const char *name)
|
||||
|
|
@ -90,7 +89,7 @@ static int aecp_message(void *data, uint64_t now, const void *message, int len)
|
|||
if (info == NULL)
|
||||
return reply_not_implemented(aecp, p, len);
|
||||
|
||||
pw_log_info("got AECP message %s", info->name);
|
||||
pw_log_debug("got AECP message %s", info->name);
|
||||
|
||||
if (info->handle == NULL)
|
||||
return reply_not_implemented(aecp, p, len);
|
||||
|
|
@ -105,16 +104,16 @@ static void aecp_destroy(void *data)
|
|||
free(aecp);
|
||||
}
|
||||
|
||||
static void aecp_periodic(void *data, uint64_t now)
|
||||
{
|
||||
}
|
||||
|
||||
static int do_help(struct aecp *aecp, const char *args)
|
||||
static int do_help(struct aecp *aecp, const char *args, FILE *out)
|
||||
{
|
||||
fprintf(out, "{ \"type\": \"help\","
|
||||
"\"text\": \""
|
||||
"/adp/help: this help \\n"
|
||||
"\" }");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int aecp_command(void *data, uint64_t now, const char *command, const char *args)
|
||||
static int aecp_command(void *data, uint64_t now, const char *command, const char *args, FILE *out)
|
||||
{
|
||||
struct aecp *aecp = data;
|
||||
int res;
|
||||
|
|
@ -123,10 +122,9 @@ static int aecp_command(void *data, uint64_t now, const char *command, const cha
|
|||
return 0;
|
||||
|
||||
command += strlen("/aecp/");
|
||||
aecp->now = now;
|
||||
|
||||
if (spa_streq(command, "help"))
|
||||
res = do_help(aecp, args);
|
||||
res = do_help(aecp, args, out);
|
||||
else
|
||||
res = -ENOTSUP;
|
||||
|
||||
|
|
@ -137,7 +135,6 @@ static const struct server_events server_events = {
|
|||
AVBTP_VERSION_SERVER_EVENTS,
|
||||
.destroy = aecp_destroy,
|
||||
.message = aecp_message,
|
||||
.periodic = aecp_periodic,
|
||||
.command = aecp_command
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -51,15 +51,9 @@ struct avbtp_packet_aecp_header {
|
|||
|
||||
#define AVBTP_PACKET_AECP_SET_MESSAGE_TYPE(p,v) AVBTP_PACKET_SET_SUB1(&(p)->hdr, v)
|
||||
#define AVBTP_PACKET_AECP_SET_STATUS(p,v) AVBTP_PACKET_SET_SUB2(&(p)->hdr, v)
|
||||
#define AVBTP_PACKET_AECP_SET_TARGET_GUID(p,v) ((p)->target_guid = htobe64(v))
|
||||
#define AVBTP_PACKET_AECP_SET_CONTROLLER_GUID(p,v) ((p)->controller_guid = htobe64(v))
|
||||
#define AVBTP_PACKET_AECP_SET_SEQUENCE_ID(p,v) ((p)->sequence_id = htons(v))
|
||||
|
||||
#define AVBTP_PACKET_AECP_GET_MESSAGE_TYPE(p) AVBTP_PACKET_GET_SUB1(&(p)->hdr)
|
||||
#define AVBTP_PACKET_AECP_GET_STATUS(p) AVBTP_PACKET_GET_SUB2(&(p)->hdr)
|
||||
#define AVBTP_PACKET_AECP_GET_TARGET_GUID(p,v) be64toh((p)->target_guid)
|
||||
#define AVBTP_PACKET_AECP_GET_CONTROLLER_GUID(p,v) be64toh((p)->controller_guid)
|
||||
#define AVBTP_PACKET_AECP_GET_SEQUENCE_ID(p,v) ntohs((p)->sequence_id)
|
||||
|
||||
struct avbtp_aecp *avbtp_aecp_register(struct server *server);
|
||||
|
||||
|
|
|
|||
|
|
@ -52,7 +52,7 @@ static const uint8_t AVB_MAC_BROADCAST[6] = { 0x91, 0xe0, 0xf0, 0x01, 0x00, 0x00
|
|||
#define server_emit_destroy(s) server_emit(s, destroy, 0)
|
||||
#define server_emit_message(s,n,m,l) server_emit(s, message, 0, n, m, l)
|
||||
#define server_emit_periodic(s,n) server_emit(s, periodic, 0, n)
|
||||
#define server_emit_command(s,n,c,a) server_emit(s, command, 0, n, c, a)
|
||||
#define server_emit_command(s,n,c,a,f) server_emit(s, command, 0, n, c, a, f)
|
||||
|
||||
static void on_timer_event(void *data, uint64_t expirations)
|
||||
{
|
||||
|
|
@ -208,7 +208,6 @@ struct server *avdecc_server_new(struct impl *impl, const char *ifname, struct s
|
|||
{
|
||||
struct server *server;
|
||||
int res = 0;
|
||||
struct timespec now;
|
||||
|
||||
server = calloc(1, sizeof(*server));
|
||||
if (server == NULL)
|
||||
|
|
@ -218,40 +217,20 @@ struct server *avdecc_server_new(struct impl *impl, const char *ifname, struct s
|
|||
spa_list_append(&impl->servers, &server->link);
|
||||
server->ifname = strdup(ifname);
|
||||
spa_hook_list_init(&server->listener_list);
|
||||
spa_list_init(&server->descriptors);
|
||||
|
||||
server->debug_messages = true;
|
||||
server->debug_messages = false;
|
||||
|
||||
if ((res = setup_socket(server)) < 0)
|
||||
goto error_free;
|
||||
|
||||
init_descriptors(server);
|
||||
|
||||
avbtp_adp_register(server);
|
||||
avbtp_aecp_register(server);
|
||||
avbtp_maap_register(server);
|
||||
avbtp_adp_register(server);
|
||||
avbtp_acmp_register(server);
|
||||
|
||||
|
||||
clock_gettime(CLOCK_REALTIME, &now);
|
||||
server_emit_command(server, SPA_TIMESPEC_TO_NSEC(&now),
|
||||
"/adp/advertise",
|
||||
"{"
|
||||
" valid-time = 10 "
|
||||
" entity-model-id = \"00:01:02:03:04:05:0600\" "
|
||||
" entity-capabilities = [ "
|
||||
" aem-supported "
|
||||
" class-a-supported "
|
||||
" gptp-supported "
|
||||
" aem-identify-control-index-valid "
|
||||
" aem-interface-index-valid ] "
|
||||
" talker-stream-sources = 8 "
|
||||
" talker-capabilities = [ implemented audio-source ] "
|
||||
" listener-stream-sinks = 8 "
|
||||
" listener-capabilities = [ implemented audio-sink ] "
|
||||
" controller-capabilities = [ ] "
|
||||
" gptp-grandmaster-id = \"10:20:30:40:50:60:0001\" "
|
||||
" gptp-domain-number = 6 "
|
||||
" association-id = 0 "
|
||||
"}");
|
||||
return server;
|
||||
|
||||
error_free:
|
||||
|
|
|
|||
|
|
@ -26,24 +26,9 @@
|
|||
#include "aecp-aem-descriptors.h"
|
||||
#include "internal.h"
|
||||
|
||||
static void add_descriptor(struct server *server, uint16_t type, uint16_t index, size_t size, void *ptr)
|
||||
{
|
||||
struct descriptor *d;
|
||||
|
||||
if ((d = calloc(1, sizeof(struct descriptor) + size)) == NULL)
|
||||
return;
|
||||
|
||||
d->type = type;
|
||||
d->index = index;
|
||||
d->size = size;
|
||||
d->ptr = SPA_PTROFF(d, sizeof(struct descriptor), void);
|
||||
memcpy(d->ptr, ptr, size);
|
||||
server->descriptors[server->n_descriptors++] = d;
|
||||
}
|
||||
|
||||
void init_descriptors(struct server *server)
|
||||
{
|
||||
add_descriptor(server, AVBTP_AEM_DESC_STRINGS, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_STRINGS, 0,
|
||||
sizeof(struct avbtp_aem_desc_strings),
|
||||
&(struct avbtp_aem_desc_strings)
|
||||
{
|
||||
|
|
@ -51,7 +36,7 @@ void init_descriptors(struct server *server)
|
|||
.string_1 = "Configuration 1",
|
||||
.string_2 = "Wim Taymans",
|
||||
});
|
||||
add_descriptor(server, AVBTP_AEM_DESC_LOCALE, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_LOCALE, 0,
|
||||
sizeof(struct avbtp_aem_desc_locale),
|
||||
&(struct avbtp_aem_desc_locale)
|
||||
{
|
||||
|
|
@ -59,7 +44,7 @@ void init_descriptors(struct server *server)
|
|||
.number_of_strings = htons(1),
|
||||
.base_strings = htons(0)
|
||||
});
|
||||
add_descriptor(server, AVBTP_AEM_DESC_ENTITY, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_ENTITY, 0,
|
||||
sizeof(struct avbtp_aem_desc_entity),
|
||||
&(struct avbtp_aem_desc_entity)
|
||||
{
|
||||
|
|
@ -115,7 +100,7 @@ void init_descriptors(struct server *server)
|
|||
{ htons(AVBTP_AEM_DESC_CLOCK_DOMAIN), htons(1) }
|
||||
}
|
||||
};
|
||||
add_descriptor(server, AVBTP_AEM_DESC_CONFIGURATION, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_CONFIGURATION, 0,
|
||||
sizeof(config), &config);
|
||||
|
||||
struct {
|
||||
|
|
@ -173,7 +158,7 @@ void init_descriptors(struct server *server)
|
|||
{ .pull_frequency = htonl(192000) },
|
||||
}
|
||||
};
|
||||
add_descriptor(server, AVBTP_AEM_DESC_AUDIO_UNIT, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_AUDIO_UNIT, 0,
|
||||
sizeof(audio_unit), &audio_unit);
|
||||
|
||||
struct {
|
||||
|
|
@ -212,7 +197,7 @@ void init_descriptors(struct server *server)
|
|||
htobe64(0x00a0060860000800ULL),
|
||||
},
|
||||
};
|
||||
add_descriptor(server, AVBTP_AEM_DESC_STREAM_INPUT, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_STREAM_INPUT, 0,
|
||||
sizeof(stream_input_0), &stream_input_0);
|
||||
|
||||
struct {
|
||||
|
|
@ -250,7 +235,7 @@ void init_descriptors(struct server *server)
|
|||
htobe64(0x00a0060860000800ULL),
|
||||
},
|
||||
};
|
||||
add_descriptor(server, AVBTP_AEM_DESC_STREAM_OUTPUT, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_STREAM_OUTPUT, 0,
|
||||
sizeof(stream_output_0), &stream_output_0);
|
||||
|
||||
struct avbtp_aem_desc_avb_interface avb_interface = {
|
||||
|
|
@ -271,7 +256,7 @@ void init_descriptors(struct server *server)
|
|||
};
|
||||
strncpy(avb_interface.object_name, server->ifname, 63);
|
||||
memcpy(avb_interface.mac_address, server->mac_addr, 6);
|
||||
add_descriptor(server, AVBTP_AEM_DESC_AVB_INTERFACE, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_AVB_INTERFACE, 0,
|
||||
sizeof(avb_interface), &avb_interface);
|
||||
|
||||
struct avbtp_aem_desc_clock_source clock_source = {
|
||||
|
|
@ -284,6 +269,6 @@ void init_descriptors(struct server *server)
|
|||
.clock_source_location_type = htons(AVBTP_AEM_DESC_STREAM_INPUT),
|
||||
.clock_source_location_index = htons(0),
|
||||
};
|
||||
add_descriptor(server, AVBTP_AEM_DESC_CLOCK_SOURCE, 0,
|
||||
server_add_descriptor(server, AVBTP_AEM_DESC_CLOCK_SOURCE, 0,
|
||||
sizeof(clock_source), &clock_source);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,10 +53,11 @@ struct server_events {
|
|||
|
||||
void (*periodic) (void *data, uint64_t now);
|
||||
|
||||
int (*command) (void *data, uint64_t now, const char *command, const char *args);
|
||||
int (*command) (void *data, uint64_t now, const char *command, const char *args, FILE *out);
|
||||
};
|
||||
|
||||
struct descriptor {
|
||||
struct spa_list link;
|
||||
uint16_t type;
|
||||
uint16_t index;
|
||||
uint32_t size;
|
||||
|
|
@ -77,22 +78,38 @@ struct server {
|
|||
|
||||
struct spa_hook_list listener_list;
|
||||
|
||||
const struct descriptor *descriptors[512];
|
||||
uint32_t n_descriptors;
|
||||
struct spa_list descriptors;
|
||||
|
||||
unsigned debug_messages:1;
|
||||
};
|
||||
|
||||
static inline const struct descriptor *find_descriptor(struct server *server, uint16_t type, uint16_t index)
|
||||
static inline const struct descriptor *server_find_descriptor(struct server *server,
|
||||
uint16_t type, uint16_t index)
|
||||
{
|
||||
uint32_t i;
|
||||
for (i = 0; i < server->n_descriptors; i++) {
|
||||
if (server->descriptors[i]->type == type &&
|
||||
server->descriptors[i]->index == index)
|
||||
return server->descriptors[i];
|
||||
struct descriptor *d;
|
||||
spa_list_for_each(d, &server->descriptors, link) {
|
||||
if (d->type == type &&
|
||||
d->index == index)
|
||||
return d;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
static inline const struct descriptor *server_add_descriptor(struct server *server,
|
||||
uint16_t type, uint16_t index, size_t size, void *ptr)
|
||||
{
|
||||
struct descriptor *d;
|
||||
|
||||
if ((d = calloc(1, sizeof(struct descriptor) + size)) == NULL)
|
||||
return NULL;
|
||||
|
||||
d->type = type;
|
||||
d->index = index;
|
||||
d->size = size;
|
||||
d->ptr = SPA_PTROFF(d, sizeof(struct descriptor), void);
|
||||
memcpy(d->ptr, ptr, size);
|
||||
spa_list_append(&server->descriptors, &d->link);
|
||||
return d;
|
||||
}
|
||||
|
||||
struct server *avdecc_server_new(struct impl *impl, const char *ifname, struct spa_dict *props);
|
||||
void avdecc_server_free(struct server *server);
|
||||
|
|
@ -106,8 +123,6 @@ int avbtp_server_send_packet(struct server *server, const uint8_t dest[6], void
|
|||
struct aecp {
|
||||
struct server *server;
|
||||
struct spa_hook server_listener;
|
||||
|
||||
uint64_t now;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
|||
66
src/modules/module-avbtp/utils.h
Normal file
66
src/modules/module-avbtp/utils.h
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
/* AVB support
|
||||
*
|
||||
* Copyright © 2022 Wim Taymans
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a
|
||||
* copy of this software and associated documentation files (the "Software"),
|
||||
* to deal in the Software without restriction, including without limitation
|
||||
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||||
* and/or sell copies of the Software, and to permit persons to whom the
|
||||
* Software is furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice (including the next
|
||||
* paragraph) shall be included in all copies or substantial portions of the
|
||||
* Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||||
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
* DEALINGS IN THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#ifndef AVBTP_UTILS_H
|
||||
#define AVBTP_UTILS_H
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
static inline char *avbtp_utils_format_id(char *str, size_t size, const uint64_t id)
|
||||
{
|
||||
snprintf(str, size, "%02x:%02x:%02x:%02x:%02x:%02x:%04x",
|
||||
(uint8_t)(id >> 56),
|
||||
(uint8_t)(id >> 48),
|
||||
(uint8_t)(id >> 40),
|
||||
(uint8_t)(id >> 32),
|
||||
(uint8_t)(id >> 24),
|
||||
(uint8_t)(id >> 16),
|
||||
(uint16_t)(id));
|
||||
return str;
|
||||
}
|
||||
|
||||
static inline int avbtp_utils_parse_id(const char *str, int len, uint64_t *id)
|
||||
{
|
||||
char s[64];
|
||||
uint8_t v[6];
|
||||
uint16_t unique_id;
|
||||
if (spa_json_parse_stringn(str, len, s, sizeof(s)) <= 0)
|
||||
return -EINVAL;
|
||||
if (sscanf(s, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx:%hx",
|
||||
&v[0], &v[1], &v[2], &v[3],
|
||||
&v[4], &v[5], &unique_id) == 7) {
|
||||
*id = (uint64_t) v[0] << 56 |
|
||||
(uint64_t) v[1] << 48 |
|
||||
(uint64_t) v[2] << 40 |
|
||||
(uint64_t) v[3] << 32 |
|
||||
(uint64_t) v[4] << 24 |
|
||||
(uint64_t) v[5] << 16 |
|
||||
unique_id;
|
||||
} else if (!spa_atou64(str, id, 0))
|
||||
return -EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#endif /* AVBTP_UTILS_H */
|
||||
Loading…
Add table
Add a link
Reference in a new issue