mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-10-29 05:40:27 -04:00
251 lines
8.9 KiB
C
251 lines
8.9 KiB
C
/* Simple Plugin API
|
|
*
|
|
* Copyright © 2019 Wim Taymans <wim.taymans@gmail.com>
|
|
*
|
|
* 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/defs.h>
|
|
#include <spa/node/node.h>
|
|
#include <spa/node/io.h>
|
|
#include <spa/node/command.h>
|
|
#include <spa/node/event.h>
|
|
|
|
#include "pwtest.h"
|
|
|
|
PWTEST(node_io_abi_sizes)
|
|
{
|
|
#if defined(__x86_64__) && defined(__LP64__)
|
|
pwtest_int_eq(sizeof(struct spa_io_buffers), 8U);
|
|
pwtest_int_eq(sizeof(struct spa_io_memory), 16U);
|
|
pwtest_int_eq(sizeof(struct spa_io_range), 16U);
|
|
pwtest_int_eq(sizeof(struct spa_io_clock), 160U);
|
|
pwtest_int_eq(sizeof(struct spa_io_latency), 24U);
|
|
pwtest_int_eq(sizeof(struct spa_io_sequence), 16U);
|
|
pwtest_int_eq(sizeof(struct spa_io_segment_bar), 64U);
|
|
pwtest_int_eq(sizeof(struct spa_io_segment_video), 80U);
|
|
pwtest_int_eq(sizeof(struct spa_io_segment), 184U);
|
|
|
|
pwtest_int_eq(sizeof(struct spa_io_position), 1688U);
|
|
pwtest_int_eq(sizeof(struct spa_io_rate_match), 48U);
|
|
|
|
spa_assert_se(sizeof(struct spa_node_info) == 48);
|
|
spa_assert_se(sizeof(struct spa_port_info) == 48);
|
|
|
|
spa_assert_se(sizeof(struct spa_result_node_error) == 8);
|
|
spa_assert_se(sizeof(struct spa_result_node_params) == 24);
|
|
|
|
return PWTEST_PASS;
|
|
#else
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_buffers));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_memory));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_range));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_clock));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_latency));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_sequence));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_bar));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_video));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment));
|
|
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_position));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_io_rate_match));
|
|
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_node_info));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_port_info));
|
|
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_error));
|
|
fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_params));
|
|
|
|
return PWTEST_SKIP;
|
|
#endif
|
|
|
|
}
|
|
|
|
PWTEST(node_io_abi)
|
|
{
|
|
/* io */
|
|
pwtest_int_eq(SPA_IO_Invalid, 0);
|
|
pwtest_int_eq(SPA_IO_Buffers, 1);
|
|
pwtest_int_eq(SPA_IO_Range, 2);
|
|
pwtest_int_eq(SPA_IO_Clock, 3);
|
|
pwtest_int_eq(SPA_IO_Latency, 4);
|
|
pwtest_int_eq(SPA_IO_Control, 5);
|
|
pwtest_int_eq(SPA_IO_Notify, 6);
|
|
pwtest_int_eq(SPA_IO_Position, 7);
|
|
pwtest_int_eq(SPA_IO_RateMatch, 8);
|
|
pwtest_int_eq(SPA_IO_Memory, 9);
|
|
|
|
/* position state */
|
|
pwtest_int_eq(SPA_IO_POSITION_STATE_STOPPED, 0);
|
|
pwtest_int_eq(SPA_IO_POSITION_STATE_STARTING, 1);
|
|
pwtest_int_eq(SPA_IO_POSITION_STATE_RUNNING, 2);
|
|
|
|
return PWTEST_PASS;
|
|
}
|
|
|
|
PWTEST(node_command_abi)
|
|
{
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Suspend, 0);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Pause, 1);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Start, 2);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Enable, 3);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Disable, 4);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Flush, 5);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Drain, 6);
|
|
pwtest_int_eq(SPA_NODE_COMMAND_Marker, 7);
|
|
|
|
return PWTEST_PASS;
|
|
}
|
|
|
|
PWTEST(node_event_abi)
|
|
{
|
|
pwtest_int_eq(SPA_NODE_EVENT_Error, 0);
|
|
pwtest_int_eq(SPA_NODE_EVENT_Buffering, 1);
|
|
pwtest_int_eq(SPA_NODE_EVENT_RequestRefresh, 2);
|
|
|
|
return PWTEST_PASS;
|
|
}
|
|
|
|
#define TEST_FUNC(a,b,func, id) \
|
|
do { \
|
|
off_t diff = SPA_PTRDIFF(&a.func, &a); \
|
|
a.func = b.func; \
|
|
pwtest_ptr_eq(diff, SPA_PTRDIFF(&b.func, &b)); \
|
|
pwtest_bool_true(diff == 0 || (diff-1)/sizeof(void*) == id); \
|
|
} while(0)
|
|
|
|
PWTEST(node_node_abi)
|
|
{
|
|
struct spa_node_events e;
|
|
struct spa_node_callbacks c;
|
|
struct spa_node_methods m;
|
|
struct {
|
|
uint32_t version;
|
|
void (*info) (void *data, const struct spa_node_info *info);
|
|
void (*port_info) (void *data,
|
|
enum spa_direction direction, uint32_t port,
|
|
const struct spa_port_info *info);
|
|
void (*result) (void *data, int seq, int res,
|
|
uint32_t type, const void *result);
|
|
void (*event) (void *data, const struct spa_event *event);
|
|
} events = { SPA_VERSION_NODE_EVENTS, };
|
|
struct {
|
|
uint32_t version;
|
|
int (*ready) (void *data, int state);
|
|
int (*reuse_buffer) (void *data,
|
|
uint32_t port_id,
|
|
uint32_t buffer_id);
|
|
int (*xrun) (void *data, uint64_t trigger, uint64_t delay,
|
|
struct spa_pod *info);
|
|
} callbacks = { SPA_VERSION_NODE_CALLBACKS, };
|
|
struct {
|
|
uint32_t version;
|
|
int (*add_listener) (void *object,
|
|
struct spa_hook *listener,
|
|
const struct spa_node_events *events,
|
|
void *data);
|
|
int (*set_callbacks) (void *object,
|
|
const struct spa_node_callbacks *callbacks,
|
|
void *data);
|
|
int (*sync) (void *object, int seq);
|
|
int (*enum_params) (void *object, int seq,
|
|
uint32_t id, uint32_t start, uint32_t max,
|
|
const struct spa_pod *filter);
|
|
int (*set_param) (void *object,
|
|
uint32_t id, uint32_t flags,
|
|
const struct spa_pod *param);
|
|
int (*set_io) (void *object,
|
|
uint32_t id, void *data, size_t size);
|
|
int (*send_command) (void *object, const struct spa_command *command);
|
|
int (*add_port) (void *object,
|
|
enum spa_direction direction, uint32_t port_id,
|
|
const struct spa_dict *props);
|
|
int (*remove_port) (void *object,
|
|
enum spa_direction direction, uint32_t port_id);
|
|
int (*port_enum_params) (void *object, int seq,
|
|
enum spa_direction direction, uint32_t port_id,
|
|
uint32_t id, uint32_t start, uint32_t max,
|
|
const struct spa_pod *filter);
|
|
int (*port_set_param) (void *object,
|
|
enum spa_direction direction,
|
|
uint32_t port_id,
|
|
uint32_t id, uint32_t flags,
|
|
const struct spa_pod *param);
|
|
int (*port_use_buffers) (void *object,
|
|
enum spa_direction direction,
|
|
uint32_t port_id,
|
|
uint32_t flags,
|
|
struct spa_buffer **buffers,
|
|
uint32_t n_buffers);
|
|
int (*port_set_io) (void *object,
|
|
enum spa_direction direction,
|
|
uint32_t port_id,
|
|
uint32_t id,
|
|
void *data, size_t size);
|
|
int (*port_reuse_buffer) (void *object, uint32_t port_id, uint32_t buffer_id);
|
|
int (*process) (void *object);
|
|
} methods = { SPA_VERSION_NODE_METHODS, 0 };
|
|
|
|
TEST_FUNC(e, events, version, 0);
|
|
TEST_FUNC(e, events, info, SPA_NODE_EVENT_INFO);
|
|
TEST_FUNC(e, events, port_info, SPA_NODE_EVENT_PORT_INFO);
|
|
TEST_FUNC(e, events, result, SPA_NODE_EVENT_RESULT);
|
|
TEST_FUNC(e, events, event, SPA_NODE_EVENT_EVENT);
|
|
pwtest_int_eq(SPA_NODE_EVENT_NUM, 4);
|
|
pwtest_int_eq(sizeof(e), sizeof(events));
|
|
|
|
TEST_FUNC(c, callbacks, version, 0);
|
|
TEST_FUNC(c, callbacks, ready, SPA_NODE_CALLBACK_READY);
|
|
TEST_FUNC(c, callbacks, reuse_buffer, SPA_NODE_CALLBACK_REUSE_BUFFER);
|
|
TEST_FUNC(c, callbacks, xrun, SPA_NODE_CALLBACK_XRUN);
|
|
pwtest_int_eq(SPA_NODE_CALLBACK_NUM, 3);
|
|
pwtest_int_eq(sizeof(c), sizeof(callbacks));
|
|
|
|
TEST_FUNC(m, methods, version, 0);
|
|
TEST_FUNC(m, methods, add_listener, SPA_NODE_METHOD_ADD_LISTENER);
|
|
TEST_FUNC(m, methods, set_callbacks, SPA_NODE_METHOD_SET_CALLBACKS);
|
|
TEST_FUNC(m, methods, sync, SPA_NODE_METHOD_SYNC);
|
|
TEST_FUNC(m, methods, enum_params, SPA_NODE_METHOD_ENUM_PARAMS);
|
|
TEST_FUNC(m, methods, set_param, SPA_NODE_METHOD_SET_PARAM);
|
|
TEST_FUNC(m, methods, set_io, SPA_NODE_METHOD_SET_IO);
|
|
TEST_FUNC(m, methods, send_command, SPA_NODE_METHOD_SEND_COMMAND);
|
|
TEST_FUNC(m, methods, add_port, SPA_NODE_METHOD_ADD_PORT);
|
|
TEST_FUNC(m, methods, remove_port, SPA_NODE_METHOD_REMOVE_PORT);
|
|
TEST_FUNC(m, methods, port_enum_params, SPA_NODE_METHOD_PORT_ENUM_PARAMS);
|
|
TEST_FUNC(m, methods, port_use_buffers, SPA_NODE_METHOD_PORT_USE_BUFFERS);
|
|
TEST_FUNC(m, methods, port_set_io, SPA_NODE_METHOD_PORT_SET_IO);
|
|
TEST_FUNC(m, methods, port_reuse_buffer, SPA_NODE_METHOD_PORT_REUSE_BUFFER);
|
|
TEST_FUNC(m, methods, process, SPA_NODE_METHOD_PROCESS);
|
|
pwtest_int_eq(SPA_NODE_METHOD_NUM, 15);
|
|
pwtest_int_eq(sizeof(m), sizeof(methods));
|
|
|
|
return PWTEST_PASS;
|
|
}
|
|
|
|
PWTEST_SUITE(spa_node)
|
|
{
|
|
pwtest_add(node_io_abi_sizes, PWTEST_NOARG);
|
|
pwtest_add(node_io_abi, PWTEST_NOARG);
|
|
pwtest_add(node_command_abi, PWTEST_NOARG);
|
|
pwtest_add(node_event_abi, PWTEST_NOARG);
|
|
pwtest_add(node_node_abi, PWTEST_NOARG);
|
|
|
|
return PWTEST_PASS;
|
|
}
|