mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-02 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

types: more work on types

Browse source
This commit is contained in:
Wim Taymans 2017-03-24 11:40:58 +01:00
parent acedfe71c0
commit 5825c62d6d
76 changed files with 1713 additions and 1477 deletions
Download patch file Download diff file Expand all files Collapse all files

160
spa/include/spa/alloc-param.h Normal file
View file

@ -0,0 +1,160 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_ALLOC_PARAM_H__
#define __SPA_ALLOC_PARAM_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _SpaAllocParam SpaAllocParam;
#include <spa/defs.h>
#include <spa/type-map.h>
#include <spa/pod-utils.h>
#define SPA_TYPE__AllocParam "Spa:Object:AllocParam"
#define SPA_TYPE_ALLOC_PARAM_BASE SPA_TYPE__AllocParam ":"
typedef struct {
SpaPODObjectBody body;
/* SpaPODProp follow */
} SpaAllocParamBody;
struct _SpaAllocParam {
SpaPOD pod;
SpaAllocParamBody body;
};
static inline uint32_t
spa_alloc_param_query (const SpaAllocParam *param, uint32_t key, ...)
{
uint32_t count;
va_list args;
va_start (args, key);
count = spa_pod_contents_queryv (&param->pod, sizeof (SpaAllocParam), key, args);
va_end (args);
return count;
}
#define SPA_TYPE_ALLOC_PARAM__Buffers SPA_TYPE_ALLOC_PARAM_BASE "Buffers"
#define SPA_TYPE_ALLOC_PARAM_BUFFERS_BASE SPA_TYPE_ALLOC_PARAM__Buffers ":"
#define SPA_TYPE_ALLOC_PARAM_BUFFERS__size SPA_TYPE_ALLOC_PARAM_BUFFERS_BASE "size"
#define SPA_TYPE_ALLOC_PARAM_BUFFERS__stride SPA_TYPE_ALLOC_PARAM_BUFFERS_BASE "stride"
#define SPA_TYPE_ALLOC_PARAM_BUFFERS__buffers SPA_TYPE_ALLOC_PARAM_BUFFERS_BASE "buffers"
#define SPA_TYPE_ALLOC_PARAM_BUFFERS__align SPA_TYPE_ALLOC_PARAM_BUFFERS_BASE "align"
typedef struct {
uint32_t Buffers;
uint32_t size;
uint32_t stride;
uint32_t buffers;
uint32_t align;
} SpaTypeAllocParamBuffers;
static inline void
spa_type_alloc_param_buffers_map (SpaTypeMap *map, SpaTypeAllocParamBuffers *type)
{
if (type->Buffers == 0) {
type->Buffers = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM__Buffers);
type->size = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_BUFFERS__size);
type->stride = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_BUFFERS__stride);
type->buffers = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_BUFFERS__buffers);
type->align = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_BUFFERS__align);
}
}
#define SPA_TYPE_ALLOC_PARAM__MetaEnable SPA_TYPE_ALLOC_PARAM_BASE "MetaEnable"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE SPA_TYPE_ALLOC_PARAM__MetaEnable ":"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__type SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "type"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferSize SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferSize"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferStride SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferStride"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferBlocks SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferBlocks"
#define SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferAlign SPA_TYPE_ALLOC_PARAM_META_ENABLE_BASE "ringbufferAlign"
typedef struct {
uint32_t MetaEnable;
uint32_t type;
uint32_t ringbufferSize;
uint32_t ringbufferStride;
uint32_t ringbufferBlocks;
uint32_t ringbufferAlign;
} SpaTypeAllocParamMetaEnable;
static inline void
spa_type_alloc_param_meta_enable_map (SpaTypeMap *map, SpaTypeAllocParamMetaEnable *type)
{
if (type->MetaEnable == 0) {
type->MetaEnable = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM__MetaEnable);
type->type = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__type);
type->ringbufferSize = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferSize);
type->ringbufferStride = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferStride);
type->ringbufferBlocks = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferBlocks);
type->ringbufferAlign = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_META_ENABLE__ringbufferAlign);
}
}
#define SPA_TYPE_ALLOC_PARAM__VideoPadding SPA_TYPE_ALLOC_PARAM_BASE "VideoPadding"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE SPA_TYPE_ALLOC_PARAM__VideoPadding ":"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__top SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "top"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__bottom SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "bottom"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__left SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "left"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__right SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "right"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign0 SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "strideAlign0"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign1 SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "strideAlign1"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign2 SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "strideAlign2"
#define SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign3 SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING_BASE "strideAlign3"
typedef struct {
uint32_t VideoPadding;
uint32_t top;
uint32_t bottom;
uint32_t left;
uint32_t right;
uint32_t strideAlign[4];
} SpaTypeAllocParamVideoPadding;
static inline void
spa_type_alloc_param_video_padding_map (SpaTypeMap *map, SpaTypeAllocParamVideoPadding *type)
{
if (type->VideoPadding == 0) {
type->VideoPadding = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM__VideoPadding);
type->top = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__top);
type->bottom = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__bottom);
type->left = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__left);
type->right = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__right);
type->strideAlign[0] = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign0);
type->strideAlign[1] = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign1);
type->strideAlign[2] = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign2);
type->strideAlign[3] = spa_type_map_get_id (map, SPA_TYPE_ALLOC_PARAM_VIDEO_PADDING__strideAlign3);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_ALLOC_PARAM_H__ */

18
spa/include/spa/audio/format-utils.h
View file

@ -35,18 +35,18 @@ typedef struct {
uint32_t rate;
uint32_t channels;
uint32_t channel_mask;
} SpaPropAudio;
} SpaTypePropAudio;
static inline void
spa_prop_audio_map (SpaIDMap *map, SpaPropAudio *types)
spa_type_prop_audio_map (SpaTypeMap *map, SpaTypePropAudio *type)
{
if (types->format == 0) {
types->format = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__format);
types->flags = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__flags);
types->layout = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__layout);
types->rate = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__rate);
types->channels = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__channels);
types->channel_mask = spa_id_map_get_id (map, SPA_TYPE_PROP_AUDIO__channelMask);
if (type->format == 0) {
type->format = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__format);
type->flags = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__flags);
type->layout = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__layout);
type->rate = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__rate);
type->channels = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__channels);
type->channel_mask = spa_type_map_get_id (map, SPA_TYPE_PROP_AUDIO__channelMask);
}
}

80
spa/include/spa/audio/raw-utils.h
View file

@ -24,15 +24,15 @@
extern "C" {
#endif
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/audio/raw.h>
#if __BYTE_ORDER == __BIG_ENDIAN
#define _SPA_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#define _SPA_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#define _SPA_TYPE_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#define _SPA_TYPE_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define _SPA_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#define _SPA_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#define _SPA_TYPE_AUDIO_FORMAT_NE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "LE"
#define _SPA_TYPE_AUDIO_FORMAT_OE(fmt) SPA_TYPE_AUDIO_FORMAT_BASE fmt "BE"
#endif
typedef struct {
@ -68,47 +68,47 @@ typedef struct {
uint32_t U18_OE;
uint32_t F32_OE;
uint32_t F64_OE;
} SpaAudioFormats;
} SpaTypeAudioFormat;
static inline void
spa_audio_formats_map (SpaIDMap *map, SpaAudioFormats *types)
spa_type_audio_format_map (SpaTypeMap *map, SpaTypeAudioFormat *type)
{
if (types->ENCODED == 0) {
types->UNKNOWN = 0;
types->ENCODED = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__ENCODED);
if (type->ENCODED == 0) {
type->UNKNOWN = 0;
type->ENCODED = spa_type_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__ENCODED);
types->S8 = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__S8);
types->U8 = spa_id_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__U8);
type->S8 = spa_type_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__S8);
type->U8 = spa_type_map_get_id (map, SPA_TYPE_AUDIO_FORMAT__U8);
types->S16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S16"));
types->U16 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U16"));
types->S24_32 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S24_32"));
types->U24_32 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U24_32"));
types->S32 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S32"));
types->U32 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U32"));
types->S24 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S24"));
types->U24 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U24"));
types->S20 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S20"));
types->U20 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U20"));
types->S18 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("S18"));
types->U18 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("U18"));
types->F32 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("F32"));
types->F64 = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_NE ("F64"));
type->S16 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S16"));
type->U16 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U16"));
type->S24_32 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S24_32"));
type->U24_32 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U24_32"));
type->S32 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S32"));
type->U32 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U32"));
type->S24 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S24"));
type->U24 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U24"));
type->S20 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S20"));
type->U20 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U20"));
type->S18 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("S18"));
type->U18 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("U18"));
type->F32 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("F32"));
type->F64 = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_NE ("F64"));
types->S16_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S16"));
types->U16_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U16"));
types->S24_32_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S24_32"));
types->U24_32_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U24_32"));
types->S32_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S32"));
types->U32_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U32"));
types->S24_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S24"));
types->U24_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U24"));
types->S20_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S20"));
types->U20_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U20"));
types->S18_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("S18"));
types->U18_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("U18"));
types->F32_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("F32"));
types->F64_OE = spa_id_map_get_id (map, _SPA_AUDIO_FORMAT_OE ("F64"));
type->S16_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S16"));
type->U16_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U16"));
type->S24_32_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S24_32"));
type->U24_32_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U24_32"));
type->S32_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S32"));
type->U32_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U32"));
type->S24_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S24"));
type->U24_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U24"));
type->S20_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S20"));
type->U20_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U20"));
type->S18_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("S18"));
type->U18_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("U18"));
type->F32_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("F32"));
type->F64_OE = spa_type_map_get_id (map, _SPA_TYPE_AUDIO_FORMAT_OE ("F64"));
}
}

20
spa/include/spa/node-command.h → spa/include/spa/command-node.h
View file

@ -24,7 +24,7 @@
extern "C" {
#endif
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/command.h>
#define SPA_TYPE_COMMAND__Node SPA_TYPE_COMMAND_BASE "Node"
@ -44,18 +44,18 @@ typedef struct {
uint32_t Drain;
uint32_t Marker;
uint32_t ClockUpdate;
} SpaCommandNode;
} SpaTypeCommandNode;
static inline void
spa_command_node_map (SpaIDMap *map, SpaCommandNode *types)
spa_type_command_node_map (SpaTypeMap *map, SpaTypeCommandNode *type)
{
if (types->Pause == 0) {
types->Pause = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Pause);
types->Start = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Start);
types->Flush = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Flush);
types->Drain = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Drain);
types->Marker = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__Marker);
types->ClockUpdate = spa_id_map_get_id (map, SPA_TYPE_COMMAND_NODE__ClockUpdate);
if (type->Pause == 0) {
type->Pause = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__Pause);
type->Start = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__Start);
type->Flush = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__Flush);
type->Drain = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__Drain);
type->Marker = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__Marker);
type->ClockUpdate = spa_type_map_get_id (map, SPA_TYPE_COMMAND_NODE__ClockUpdate);
}
}

24
spa/include/spa/node-event.h → spa/include/spa/event-node.h
View file

@ -26,7 +26,7 @@ extern "C" {
#include <spa/defs.h>
#include <spa/event.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/node.h>
#define SPA_TYPE_EVENT__Node SPA_TYPE_EVENT_BASE "Node"
@ -50,20 +50,20 @@ typedef struct {
uint32_t Buffering;
uint32_t RequestRefresh;
uint32_t RequestClockUpdate;
} SpaEventNode;
} SpaTypeEventNode;
static inline void
spa_event_node_map (SpaIDMap *map, SpaEventNode *types)
spa_type_event_node_map (SpaTypeMap *map, SpaTypeEventNode *type)
{
if (types->AsyncComplete == 0) {
types->AsyncComplete = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__AsyncComplete);
types->HaveOutput = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__HaveOutput);
types->NeedInput = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__NeedInput);
types->ReuseBuffer = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__ReuseBuffer);
types->Error = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__Error);
types->Buffering = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__Buffering);
types->RequestRefresh = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestRefresh);
types->RequestClockUpdate = spa_id_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestClockUpdate);
if (type->AsyncComplete == 0) {
type->AsyncComplete = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__AsyncComplete);
type->HaveOutput = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__HaveOutput);
type->NeedInput = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__NeedInput);
type->ReuseBuffer = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__ReuseBuffer);
type->Error = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__Error);
type->Buffering = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__Buffering);
type->RequestRefresh = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestRefresh);
type->RequestClockUpdate = spa_type_map_get_id (map, SPA_TYPE_EVENT_NODE__RequestClockUpdate);
}
}

86
spa/include/spa/format-utils.h
View file

@ -28,33 +28,33 @@ extern "C" {
#include <spa/format.h>
#include <spa/pod-utils.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
typedef struct {
uint32_t audio;
uint32_t video;
uint32_t image;
} SpaMediaTypes;
} SpaTypeMediaType;
static inline void
spa_media_types_fill (SpaMediaTypes *types, SpaIDMap *map)
spa_type_media_type_map (SpaTypeMap *map, SpaTypeMediaType *type)
{
if (types->audio == 0) {
types->audio = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__audio);
types->video = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__video);
types->image = spa_id_map_get_id (map, SPA_TYPE_MEDIA_TYPE__image);
if (type->audio == 0) {
type->audio = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__audio);
type->video = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__video);
type->image = spa_type_map_get_id (map, SPA_TYPE_MEDIA_TYPE__image);
}
}
typedef struct {
uint32_t raw;
} SpaMediaSubtypes;
} SpaTypeMediaSubtype;
static inline void
spa_media_subtypes_map (SpaIDMap *map, SpaMediaSubtypes *types)
spa_type_media_subtype_map (SpaTypeMap *map, SpaTypeMediaSubtype *type)
{
if (types->raw == 0) {
types->raw = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__raw);
if (type->raw == 0) {
type->raw = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__raw);
}
}
@ -73,26 +73,26 @@ typedef struct {
uint32_t vp9;
uint32_t jpeg;
uint32_t bayer;
} SpaMediaSubtypesVideo;
} SpaTypeMediaSubtypeVideo;
static inline void
spa_media_subtypes_video_map (SpaIDMap *map, SpaMediaSubtypesVideo *types)
spa_type_media_subtype_video_map (SpaTypeMap *map, SpaTypeMediaSubtypeVideo *type)
{
if (types->h264 == 0) {
types->h264 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h264);
types->mjpg = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mjpg);
types->dv = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__dv);
types->mpegts = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpegts);
types->h263 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h263);
types->mpeg1 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg1);
types->mpeg2 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg2);
types->mpeg4 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg4);
types->xvid = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__xvid);
types->vc1 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vc1);
types->vp8 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp8);
types->vp9 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp9);
types->jpeg = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__jpeg);
types->bayer = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__bayer);
if (type->h264 == 0) {
type->h264 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h264);
type->mjpg = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mjpg);
type->dv = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__dv);
type->mpegts = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpegts);
type->h263 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__h263);
type->mpeg1 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg1);
type->mpeg2 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg2);
type->mpeg4 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mpeg4);
type->xvid = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__xvid);
type->vc1 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vc1);
type->vp8 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp8);
type->vp9 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vp9);
type->jpeg = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__jpeg);
type->bayer = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__bayer);
}
}
@ -109,24 +109,24 @@ typedef struct {
uint32_t g729;
uint32_t amr;
uint32_t gsm;
} SpaMediaSubtypesAudio;
} SpaTypeMediaSubtypeAudio;
static inline void
spa_media_subtypes_audio_map (SpaIDMap *map, SpaMediaSubtypesAudio *types)
spa_type_media_subtype_audio_map (SpaTypeMap *map, SpaTypeMediaSubtypeAudio *type)
{
if (types->mp3 == 0) {
types->mp3 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mp3);
types->aac = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__aac);
types->vorbis = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vorbis);
types->wma = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__wma);
types->ra = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__ra);
types->sbc = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__sbc);
types->adpcm = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__adpcm);
types->g723 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g723);
types->g726 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g726);
types->g729 = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g729);
types->amr = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__amr);
types->gsm = spa_id_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__gsm);
if (type->mp3 == 0) {
type->mp3 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__mp3);
type->aac = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__aac);
type->vorbis = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__vorbis);
type->wma = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__wma);
type->ra = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__ra);
type->sbc = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__sbc);
type->adpcm = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__adpcm);
type->g723 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g723);
type->g726 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g726);
type->g729 = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__g729);
type->amr = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__amr);
type->gsm = spa_type_map_get_id (map, SPA_TYPE_MEDIA_SUBTYPE__gsm);
}
}

8
spa/include/spa/meson.build
View file

@ -4,17 +4,16 @@ spa_headers = [
'buffer.h',
'clock.h',
'command.h',
'command-node.h',
'defs.h',
'dict.h',
'event.h',
'event-node.h',
'format.h',
'id-map.h',
'list.h',
'log.h',
'loop.h',
'monitor.h',
'node-command.h',
'node-event.h',
'node.h',
'plugin.h',
'pod.h',
@ -22,7 +21,8 @@ spa_headers = [
'pod-iter.h',
'pod-utils.h',
'props.h',
'ringbuffer.h'
'ringbuffer.h',
'type-map.h',
]
install_headers(spa_headers, subdir : 'spa')

30
spa/include/spa/monitor.h
View file

@ -67,24 +67,24 @@ typedef struct {
uint32_t klass;
uint32_t info;
uint32_t factory;
} SpaMonitorTypes;
} SpaTypeMonitor;
static inline void
spa_monitor_types_map (SpaIDMap *map, SpaMonitorTypes *types)
spa_type_monitor_map (SpaTypeMap *map, SpaTypeMonitor *type)
{
if (types->Added == 0) {
types->Monitor = spa_id_map_get_id (map, SPA_TYPE__Monitor);
types->Added = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Added);
types->Removed = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Removed);
types->Changed = spa_id_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Changed);
types->MonitorItem = spa_id_map_get_id (map, SPA_TYPE__MonitorItem);
types->id = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__id);
types->flags = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__flags);
types->state = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__state);
types->name = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__name);
types->klass = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__class);
types->info = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__info);
types->factory = spa_id_map_get_id (map, SPA_TYPE_MONITOR_ITEM__factory);
if (type->Added == 0) {
type->Monitor = spa_type_map_get_id (map, SPA_TYPE__Monitor);
type->Added = spa_type_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Added);
type->Removed = spa_type_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Removed);
type->Changed = spa_type_map_get_id (map, SPA_TYPE_EVENT_MONITOR__Changed);
type->MonitorItem = spa_type_map_get_id (map, SPA_TYPE__MonitorItem);
type->id = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__id);
type->flags = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__flags);
type->state = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__state);
type->name = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__name);
type->klass = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__class);
type->info = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__info);
type->factory = spa_type_map_get_id (map, SPA_TYPE_MONITOR_ITEM__factory);
}
}

4
spa/include/spa/node.h
View file

@ -52,8 +52,8 @@ typedef enum {
#include <spa/plugin.h>
#include <spa/props.h>
#include <spa/alloc-param.h>
#include <spa/node-event.h>
#include <spa/node-command.h>
#include <spa/event-node.h>
#include <spa/command-node.h>
#include <spa/buffer.h>
#include <spa/format.h>

8
spa/include/spa/plugin.h
View file

@ -68,25 +68,25 @@ struct _SpaHandle {
/**
* SpaInterfaceInfo:
* @uri: the uri of the interface, can be used to get the interface
* @type: the type of the interface, can be used to get the interface
*
* This structure lists the information about available interfaces on
* handles.
*/
typedef struct {
const char *uri;
const char *type;
} SpaInterfaceInfo;
/**
* SpaSupport:
* @uri: the uri of the support item
* @type: the type of the support item
* @data: specific data for the item
*
* Extra supporting infrastructure passed to the init() function of
* a factory. It can be extra information or interfaces such as logging.
*/
typedef struct {
const char *uri;
const char *type;
void *data;
} SpaSupport;

4
spa/include/spa/ringbuffer.h
View file

@ -26,8 +26,8 @@ extern "C" {
typedef struct _SpaRingbuffer SpaRingbuffer;
#define SPA_RINGBUFFER_URI "http://spaplug.in/ns/ringbuffer"
#define SPA_RINGBUFFER_PREFIX SPA_RINGBUFFER_URI "#"
#define SPA_TYPE__RingBuffer "Spa:Object:RingBuffer"
#define SPA_TYPE_RINGBUFFER_BASE SPA_TYPE__RingBuffer ":"
#include <string.h>

39
spa/include/spa/id-map.h → spa/include/spa/type-map.h
View file

@ -17,52 +17,53 @@
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_ID_MAP_H__
#define __SPA_ID_MAP_H__
#ifndef __SPA_TYPE_MAP_H__
#define __SPA_TYPE_MAP_H__
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _SpaIDMap SpaIDMap;
typedef struct _SpaTypeMap SpaTypeMap;
#include <spa/defs.h>
#include <spa/plugin.h>
#include <spa/type.h>
#define SPA_TYPE__IDMap "Spa:Interface:IDMap"
#define SPA_TYPE_ID_MAP_BASE SPA_TYPE__IDMap ":"
#define SPA_TYPE__TypeMap "Spa:Interface:TypeMap"
#define SPA_TYPE_TYPE_MAP_BASE SPA_TYPE__TypeMap ":"
/**
* SpaIDMap:
* SpaTypeMap:
*
* Maps between uri and its id
* Maps between string types and their type id
*/
struct _SpaIDMap {
struct _SpaTypeMap {
/* the total size of this structure. This can be used to expand this
* structure in the future */
const size_t size;
/**
* SpaIDMap::info
* SpaTypeMap::info
*
* Extra information about the map
* Extra information about the type map
*/
const SpaDict *info;
uint32_t (*get_id) (SpaIDMap *map,
const char *uri);
SpaType (*get_id) (SpaTypeMap *map,
const char *type);
const char * (*get_uri) (SpaIDMap *map,
uint32_t id);
const char * (*get_type) (SpaTypeMap *map,
SpaType id);
uint32_t (*get_size) (SpaIDMap *map);
size_t (*get_size) (SpaTypeMap *map);
};
#define spa_id_map_get_id(n,...) (n)->get_id((n),__VA_ARGS__)
#define spa_id_map_get_uri(n,...) (n)->get_uri((n),__VA_ARGS__)
#define spa_id_map_get_size(n) (n)->get_size(n)
#define spa_type_map_get_id(n,...) (n)->get_id((n),__VA_ARGS__)
#define spa_type_map_get_type(n,...) (n)->get_type((n),__VA_ARGS__)
#define spa_type_map_get_size(n) (n)->get_size(n)
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_ID_MAP_H__ */
#endif /* __SPA_TYPE_MAP_H__ */

36
spa/include/spa/type.h Normal file
View file

@ -0,0 +1,36 @@
/* Simple Plugin API
* Copyright (C) 2016 Wim Taymans <wim.taymans@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __SPA_TYPE_H__
#define __SPA_TYPE_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/defs.h>
typedef uint32_t SpaType;
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_TYPE_H__ */

42
spa/include/spa/video/format-utils.h
View file

@ -47,30 +47,30 @@ typedef struct {
uint32_t level;
uint32_t stream_format;
uint32_t alignment;
} SpaPropVideo;
} SpaTypePropVideo;
static inline void
spa_prop_video_map (SpaIDMap *map, SpaPropVideo *types)
spa_type_prop_video_map (SpaTypeMap *map, SpaTypePropVideo *type)
{
if (types->format == 0) {
types->format = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__format);
types->size = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__size);
types->framerate = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__framerate);
types->max_framerate = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__maxFramerate);
types->views = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__views);
types->interlace_mode = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__interlaceMode);
types->pixel_aspect_ratio = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__pixelAspectRatio);
types->multiview_mode = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewMode);
types->multiview_flags = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewFlags);
types->chroma_site = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__chromaSite);
types->color_range = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorRange);
types->color_matrix = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorMatrix);
types->transfer_function = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__transferFunction);
types->color_primaries = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorPrimaries);
types->profile = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__profile);
types->level = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__level);
types->stream_format = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__streamFormat);
types->alignment = spa_id_map_get_id (map, SPA_TYPE_PROP_VIDEO__alignment);
if (type->format == 0) {
type->format = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__format);
type->size = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__size);
type->framerate = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__framerate);
type->max_framerate = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__maxFramerate);
type->views = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__views);
type->interlace_mode = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__interlaceMode);
type->pixel_aspect_ratio = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__pixelAspectRatio);
type->multiview_mode = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewMode);
type->multiview_flags = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__multiviewFlags);
type->chroma_site = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__chromaSite);
type->color_range = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorRange);
type->color_matrix = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorMatrix);
type->transfer_function = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__transferFunction);
type->color_primaries = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__colorPrimaries);
type->profile = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__profile);
type->level = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__level);
type->stream_format = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__streamFormat);
type->alignment = spa_type_map_get_id (map, SPA_TYPE_PROP_VIDEO__alignment);
}
}

138
spa/include/spa/video/raw-utils.h
View file

@ -26,7 +26,7 @@ extern "C" {
typedef struct _SpaVideoInfoRaw SpaVideoInfoRaw;
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/video/raw.h>
typedef struct
@ -96,77 +96,77 @@ typedef struct
uint32_t P010_10LE;
uint32_t IYU2;
uint32_t VYUY;
} SpaVideoFormats;
} SpaTypeVideoFormat;
static inline void
spa_video_formats_map (SpaIDMap *map, SpaVideoFormats *types)
spa_type_video_format_map (SpaTypeMap *map, SpaTypeVideoFormat *type)
{
if (types->ENCODED == 0) {
types->UNKNOWN = 0;
types->ENCODED = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ENCODED);
types->I420 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420);
types->YV12 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YV12);
types->YUY2 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUY2);
types->UYVY = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVY);
types->AYUV = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV);
types->RGBx = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBx);
types->BGRx = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRx);
types->xRGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xRGB);
types->xBGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xBGR);
types->RGBA = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBA);
types->BGRA = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRA);
types->ARGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB);
types->ABGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ABGR);
types->RGB = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB);
types->BGR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR);
types->Y41B = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y41B);
types->Y42B = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y42B);
types->YVYU = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVYU);
types->Y444 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444);
types->v210 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v210);
types->v216 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v216);
types->NV12 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12);
types->NV21 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV21);
types->GRAY8 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY8);
types->GRAY16_BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_BE);
types->GRAY16_LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_LE);
types->v308 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v308);
types->RGB16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB16);
types->BGR16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR16);
types->RGB15 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB15);
types->BGR15 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR15);
types->UYVP = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVP);
types->A420 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420);
types->RGB8P = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB8P);
types->YUV9 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUV9);
types->YVU9 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVU9);
types->IYU1 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU1);
types->ARGB64 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB64);
types->AYUV64 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV64);
types->r210 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__r210);
types->I420_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10BE);
types->I420_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10LE);
types->I422_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10BE);
types->I422_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10LE);
types->Y444_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10BE);
types->Y444_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10LE);
types->GBR = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR);
types->GBR_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10BE);
types->GBR_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10LE);
types->NV16 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV16);
types->NV24 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV24);
types->NV12_64Z32 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12_64Z32);
types->A420_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10BE);
types->A420_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10LE);
types->A422_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10BE);
types->A422_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10LE);
types->A444_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10BE);
types->A444_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10LE);
types->NV61 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV61);
types->P010_10BE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10BE);
types->P010_10LE = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10LE);
types->IYU2 = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU2);
types->VYUY = spa_id_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__VYUY);
if (type->ENCODED == 0) {
type->UNKNOWN = 0;
type->ENCODED = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ENCODED);
type->I420 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420);
type->YV12 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YV12);
type->YUY2 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUY2);
type->UYVY = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVY);
type->AYUV = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV);
type->RGBx = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBx);
type->BGRx = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRx);
type->xRGB = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xRGB);
type->xBGR = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__xBGR);
type->RGBA = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGBA);
type->BGRA = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGRA);
type->ARGB = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB);
type->ABGR = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ABGR);
type->RGB = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB);
type->BGR = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR);
type->Y41B = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y41B);
type->Y42B = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y42B);
type->YVYU = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVYU);
type->Y444 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444);
type->v210 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v210);
type->v216 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v216);
type->NV12 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12);
type->NV21 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV21);
type->GRAY8 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY8);
type->GRAY16_BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_BE);
type->GRAY16_LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GRAY16_LE);
type->v308 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__v308);
type->RGB16 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB16);
type->BGR16 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR16);
type->RGB15 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB15);
type->BGR15 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__BGR15);
type->UYVP = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__UYVP);
type->A420 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420);
type->RGB8P = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__RGB8P);
type->YUV9 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YUV9);
type->YVU9 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__YVU9);
type->IYU1 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU1);
type->ARGB64 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__ARGB64);
type->AYUV64 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__AYUV64);
type->r210 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__r210);
type->I420_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10BE);
type->I420_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I420_10LE);
type->I422_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10BE);
type->I422_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__I422_10LE);
type->Y444_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10BE);
type->Y444_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__Y444_10LE);
type->GBR = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR);
type->GBR_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10BE);
type->GBR_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__GBR_10LE);
type->NV16 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV16);
type->NV24 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV24);
type->NV12_64Z32 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV12_64Z32);
type->A420_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10BE);
type->A420_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A420_10LE);
type->A422_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10BE);
type->A422_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A422_10LE);
type->A444_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10BE);
type->A444_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__A444_10LE);
type->NV61 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__NV61);
type->P010_10BE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10BE);
type->P010_10LE = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__P010_10LE);
type->IYU2 = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__IYU2);
type->VYUY = spa_type_map_get_id (map, SPA_TYPE_VIDEO_FORMAT__VYUY);
}
}

1
spa/include/spa/video/raw.h
View file

@ -27,7 +27,6 @@ extern "C" {
typedef struct _SpaVideoInfoRaw SpaVideoInfoRaw;
#include <spa/props.h>
#include <spa/id-map.h>
#include <spa/video/chroma.h>
#include <spa/video/color.h>
#include <spa/video/multiview.h>

21
spa/lib/audio-raw.c
View file

@ -30,23 +30,24 @@ SpaResult
spa_format_audio_parse (const SpaFormat *format,
SpaAudioInfo *info)
{
static SpaMediaTypes media_types = { 0, };
static SpaMediaSubtypes media_subtypes = { 0, };
static SpaMediaSubtypesAudio media_subtypes_audio = { 0, };
static SpaPropAudio prop_audio = { 0, };
static SpaTypeMediaType media_type = { 0, };
static SpaTypeMediaSubtype media_subtype = { 0, };
static SpaTypeMediaSubtypeAudio media_subtype_audio = { 0, };
static SpaTypePropAudio prop_audio = { 0, };
SpaTypeMap *map = spa_type_map_get_default();
spa_media_types_fill (&media_types, spa_id_map_get_default());
spa_media_subtypes_map (spa_id_map_get_default(), &media_subtypes);
spa_media_subtypes_audio_map (spa_id_map_get_default (), &media_subtypes_audio);
spa_prop_audio_map (spa_id_map_get_default (), &prop_audio);
spa_type_media_type_map (map, &media_type);
spa_type_media_subtype_map (map, &media_subtype);
spa_type_media_subtype_audio_map (map, &media_subtype_audio);
spa_type_prop_audio_map (map, &prop_audio);
if (format->body.media_type.value != media_types.audio)
if (format->body.media_type.value != media_type.audio)
return SPA_RESULT_INVALID_MEDIA_TYPE;
info->media_type = format->body.media_type.value;
info->media_subtype = format->body.media_subtype.value;
if (info->media_subtype == media_subtypes.raw) {
if (info->media_subtype == media_subtype.raw) {
spa_format_query (format,
prop_audio.format, SPA_POD_TYPE_URI, &info->info.raw.format,
prop_audio.flags, SPA_POD_TYPE_INT, &info->info.raw.flags,

16
spa/lib/debug.c
View file

@ -215,7 +215,7 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
break;
case SPA_POD_TYPE_URI:
printf ("%-*sURI %d %s\n", prefix, "", *(int32_t *) body,
spa_id_map_get_uri (spa_id_map_get_default(), *(int32_t*)body));
spa_type_map_get_type (spa_type_map_get_default(), *(int32_t*)body));
break;
case SPA_POD_TYPE_INT:
printf ("%-*sInt %d\n", prefix, "", *(int32_t *) body);
@ -236,7 +236,7 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
{
SpaPODPointerBody *b = body;
printf ("%-*sPointer %s %p\n", prefix, "",
spa_id_map_get_uri (spa_id_map_get_default(), b->type), b->value);
spa_type_map_get_type (spa_type_map_get_default(), b->type), b->value);
break;
}
case SPA_POD_TYPE_RECTANGLE:
@ -278,7 +278,7 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
SpaPOD *p;
printf ("%-*sObject: size %d, id %d, type %s\n", prefix, "", size, b->id,
spa_id_map_get_uri (spa_id_map_get_default(), b->type));
spa_type_map_get_type (spa_type_map_get_default(), b->type));
SPA_POD_OBJECT_BODY_FOREACH (b, size, p)
print_pod_value (p->size, p->type, SPA_POD_BODY (p), prefix + 2);
break;
@ -290,7 +290,7 @@ print_pod_value (uint32_t size, uint32_t type, void *body, int prefix)
int i;
printf ("%-*sProp: key %s, flags %d\n", prefix, "",
spa_id_map_get_uri (spa_id_map_get_default(), b->key), b->flags);
spa_type_map_get_type (spa_type_map_get_default(), b->key), b->flags);
if (b->flags & SPA_POD_PROP_FLAG_UNSET)
printf ("%-*sUnset (Default):\n", prefix + 2, "");
else
@ -336,7 +336,7 @@ print_format_value (uint32_t size, uint32_t type, void *body)
break;
case SPA_POD_TYPE_URI:
{
const char *str = spa_id_map_get_uri (spa_id_map_get_default(), *(int32_t*)body);
const char *str = spa_type_map_get_type (spa_type_map_get_default(), *(int32_t*)body);
if (str) {
const char *h = rindex (str, ':');
if (h)
@ -400,8 +400,8 @@ spa_debug_format (const SpaFormat *format)
mtype = format->body.media_type.value;
mstype = format->body.media_subtype.value;
media_type = spa_id_map_get_uri (spa_id_map_get_default (), mtype);
media_subtype = spa_id_map_get_uri (spa_id_map_get_default (), mstype);
media_type = spa_type_map_get_type (spa_type_map_get_default (), mtype);
media_subtype = spa_type_map_get_type (spa_type_map_get_default (), mstype);
fprintf (stderr, "%-6s %s/%s\n", "", rindex (media_type, ':')+1, rindex (media_subtype, ':')+1);
@ -412,7 +412,7 @@ spa_debug_format (const SpaFormat *format)
(prop->body.flags & SPA_POD_PROP_FLAG_OPTIONAL))
continue;
key = spa_id_map_get_uri (spa_id_map_get_default (), prop->body.key);
key = spa_type_map_get_type (spa_type_map_get_default (), prop->body.key);
fprintf (stderr, " %20s : (%s) ", rindex (key, ':')+1, pod_type_names[prop->body.value.type].name);

56
spa/lib/mapper.c
View file

@ -22,66 +22,74 @@
#include <stdio.h>
#include <string.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <lib/debug.h>
#define MAX_URIS 4096
typedef struct {
SpaIDMap map;
char *uris[MAX_URIS];
unsigned int n_uris;
} IDMap;
SpaTypeMap map;
char *types[MAX_URIS];
unsigned int n_types;
} TypeMap;
static uint32_t
id_map_get_id (SpaIDMap *map, const char *uri)
type_map_get_id (SpaTypeMap *map, const char *type)
{
IDMap *this = SPA_CONTAINER_OF (map, IDMap, map);
TypeMap *this = SPA_CONTAINER_OF (map, TypeMap, map);
unsigned int i = 0;
if (uri != NULL) {
for (i = 1; i <= this->n_uris; i++) {
if (strcmp (this->uris[i], uri) == 0)
if (type != NULL) {
for (i = 1; i <= this->n_types; i++) {
if (strcmp (this->types[i], type) == 0)
return i;
}
this->uris[i] = (char *)uri;
this->n_uris++;
this->types[i] = (char *)type;
this->n_types++;
}
return i;
}
static const char *
id_map_get_uri (SpaIDMap *map, uint32_t id)
type_map_get_type (SpaTypeMap *map, uint32_t id)
{
IDMap *this = SPA_CONTAINER_OF (map, IDMap, map);
TypeMap *this = SPA_CONTAINER_OF (map, TypeMap, map);
if (id <= this->n_uris)
return this->uris[id];
if (id <= this->n_types)
return this->types[id];
return NULL;
}
static IDMap default_id_map = {
{ sizeof (SpaIDMap),
static size_t
type_map_get_size (SpaTypeMap *map)
{
TypeMap *this = SPA_CONTAINER_OF (map, TypeMap, map);
return this->n_types;
}
static TypeMap default_type_map = {
{ sizeof (SpaTypeMap),
NULL,
id_map_get_id,
id_map_get_uri,
type_map_get_id,
type_map_get_type,
type_map_get_size,
},
{ NULL, },
0
};
static SpaIDMap *default_map = &default_id_map.map;
static SpaTypeMap *default_map = &default_type_map.map;
SpaIDMap *
spa_id_map_get_default (void)
SpaTypeMap *
spa_type_map_get_default (void)
{
return default_map;
}
void
spa_id_map_set_default (SpaIDMap *map)
spa_type_map_set_default (SpaTypeMap *map)
{
default_map = map;
}

6
spa/lib/mapper.h
View file

@ -24,10 +24,10 @@
extern "C" {
#endif
#include <spa/id-map.h>
#include <spa/type-map.h>
void spa_id_map_set_default (SpaIDMap *map);
SpaIDMap * spa_id_map_get_default (void);
void spa_type_map_set_default (SpaTypeMap *map);
SpaTypeMap * spa_type_map_get_default (void);
#ifdef __cplusplus
} /* extern "C" */

25
spa/lib/video-raw.c
View file

@ -31,23 +31,24 @@ SpaResult
spa_format_video_parse (const SpaFormat *format,
SpaVideoInfo *info)
{
static SpaMediaTypes media_types = { 0, };
static SpaMediaSubtypes media_subtypes = { 0, };
static SpaMediaSubtypesVideo media_subtypes_video = { 0, };
static SpaPropVideo prop_video = { 0, };
static SpaTypeMediaType media_type = { 0, };
static SpaTypeMediaSubtype media_subtype = { 0, };
static SpaTypeMediaSubtypeVideo media_subtype_video = { 0, };
static SpaTypePropVideo prop_video = { 0, };
SpaTypeMap *map = spa_type_map_get_default ();
spa_media_types_fill (&media_types, spa_id_map_get_default ());
spa_media_subtypes_map (spa_id_map_get_default (), &media_subtypes);
spa_media_subtypes_video_map (spa_id_map_get_default (), &media_subtypes_video);
spa_prop_video_map (spa_id_map_get_default (), &prop_video);
spa_type_media_type_map (map, &media_type);
spa_type_media_subtype_map (map, &media_subtype);
spa_type_media_subtype_video_map (map, &media_subtype_video);
spa_type_prop_video_map (map, &prop_video);
if (format->body.media_type.value != media_types.video)
if (format->body.media_type.value != media_type.video)
return SPA_RESULT_INVALID_MEDIA_TYPE;
info->media_type = format->body.media_type.value;
info->media_subtype = format->body.media_subtype.value;
if (info->media_subtype == media_subtypes.raw)
if (info->media_subtype == media_subtype.raw)
spa_format_query (format,
prop_video.format, SPA_POD_TYPE_URI, &info->info.raw.format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.raw.size,
@ -64,13 +65,13 @@ spa_format_video_parse (const SpaFormat *format,
prop_video.transfer_function, SPA_POD_TYPE_INT, &info->info.raw.transfer_function,
prop_video.color_primaries, SPA_POD_TYPE_INT, &info->info.raw.color_primaries,
0);
else if (info->media_subtype == media_subtypes_video.h264)
else if (info->media_subtype == media_subtype_video.h264)
spa_format_query (format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.h264.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.framerate,
prop_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.h264.max_framerate,
0);
else if (info->media_subtype == media_subtypes_video.mjpg)
else if (info->media_subtype == media_subtype_video.mjpg)
spa_format_query (format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.mjpg.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.mjpg.framerate,

51
spa/plugins/alsa/alsa-monitor.c
View file

@ -28,7 +28,7 @@
#include <asoundlib.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/loop.h>
#include <spa/monitor.h>
#include <lib/debug.h>
@ -45,15 +45,22 @@ typedef struct {
typedef struct {
uint32_t handle_factory;
SpaMonitorTypes monitor_types;
} URI;
SpaTypeMonitor monitor;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->handle_factory = spa_type_map_get_id (map, SPA_TYPE__HandleFactory);
spa_type_monitor_map (map, &type->monitor);
}
struct _SpaALSAMonitor {
SpaHandle handle;
SpaMonitor monitor;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *main_loop;
@ -170,20 +177,20 @@ fill_item (SpaALSAMonitor *this, ALSAItem *item, struct udev_device *udevice)
spa_pod_builder_init (&b, this->item_buffer, sizeof (this->item_buffer));
spa_pod_builder_push_object (&b, &f[0], 0, this->uri.monitor_types.MonitorItem);
spa_pod_builder_push_object (&b, &f[0], 0, this->type.monitor.MonitorItem);
spa_pod_builder_add (&b,
SPA_POD_PROP (&f[1], this->uri.monitor_types.id, 0, SPA_POD_TYPE_STRING, 1, udev_device_get_syspath (item->udevice)),
SPA_POD_PROP (&f[1], this->uri.monitor_types.flags, 0, SPA_POD_TYPE_INT, 1, 0),
SPA_POD_PROP (&f[1], this->uri.monitor_types.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE),
SPA_POD_PROP (&f[1], this->uri.monitor_types.name, 0, SPA_POD_TYPE_STRING, 1, name),
SPA_POD_PROP (&f[1], this->uri.monitor_types.klass, 0, SPA_POD_TYPE_STRING, 1, "Audio/Device"),
SPA_POD_PROP (&f[1], this->uri.monitor_types.factory, 0, SPA_POD_TYPE_POINTER, 1, this->uri.handle_factory,
SPA_POD_PROP (&f[1], this->type.monitor.id, 0, SPA_POD_TYPE_STRING, 1, udev_device_get_syspath (item->udevice)),
SPA_POD_PROP (&f[1], this->type.monitor.flags, 0, SPA_POD_TYPE_INT, 1, 0),
SPA_POD_PROP (&f[1], this->type.monitor.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE),
SPA_POD_PROP (&f[1], this->type.monitor.name, 0, SPA_POD_TYPE_STRING, 1, name),
SPA_POD_PROP (&f[1], this->type.monitor.klass, 0, SPA_POD_TYPE_STRING, 1, "Audio/Device"),
SPA_POD_PROP (&f[1], this->type.monitor.factory, 0, SPA_POD_TYPE_POINTER, 1, this->type.handle_factory,
factory),
0);
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1], this->uri.monitor_types.info, 0,
SPA_POD_TYPE_PROP, &f[1], this->type.monitor.info, 0,
SPA_POD_TYPE_STRUCT, 1, &f[2], 0);
spa_pod_builder_add (&b,
@ -271,11 +278,11 @@ alsa_on_fd_events (SpaSource *source)
str = "change";
if (strcmp (str, "add") == 0) {
type = this->uri.monitor_types.Added;
type = this->type.monitor.Added;
} else if (strcmp (str, "change") == 0) {
type = this->uri.monitor_types.Changed;
type = this->type.monitor.Changed;
} else if (strcmp (str, "remove") == 0) {
type = this->uri.monitor_types.Removed;
type = this->type.monitor.Removed;
} else
return;
@ -402,7 +409,7 @@ spa_alsa_monitor_get_interface (SpaHandle *handle,
this = (SpaALSAMonitor *) handle;
if (interface_id == this->uri.monitor_types.Monitor)
if (interface_id == this->type.monitor.Monitor)
*interface = &this->monitor;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -435,11 +442,11 @@ alsa_monitor_init (const SpaHandleFactory *factory,
this = (SpaALSAMonitor *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data;
}
if (this->map == NULL) {
@ -450,8 +457,8 @@ alsa_monitor_init (const SpaHandleFactory *factory,
spa_log_error (this->log, "a main-loop is needed");
return SPA_RESULT_ERROR;
}
this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_TYPE__HandleFactory);
spa_monitor_types_map (this->map, &this->uri.monitor_types);
init_type (&this->type, this->map);
this->monitor = alsamonitor;

92
spa/plugins/alsa/alsa-sink.c
View file

@ -82,13 +82,13 @@ spa_alsa_sink_node_get_props (SpaNode *node,
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP (&f[1], this->uri.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], this->uri.prop_card_name, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], this->uri.prop_period_size, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], this->uri.prop_periods, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], this->uri.prop_period_event, SPA_POD_TYPE_BOOL, this->props.period_event));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP (&f[1], this->type.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], this->type.prop_card_name, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], this->type.prop_period_size, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], this->type.prop_periods, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], this->type.prop_period_event, SPA_POD_TYPE_BOOL, this->props.period_event));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
@ -111,10 +111,10 @@ spa_alsa_sink_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
} else {
spa_props_query (props,
this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->uri.prop_period_size, SPA_POD_TYPE_INT, &this->props.period_size,
this->uri.prop_periods, SPA_POD_TYPE_INT, &this->props.periods,
this->uri.prop_period_event, SPA_POD_TYPE_BOOL, &this->props.period_event,
this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->type.prop_period_size, SPA_POD_TYPE_INT, &this->props.period_size,
this->type.prop_periods, SPA_POD_TYPE_INT, &this->props.periods,
this->type.prop_period_event, SPA_POD_TYPE_BOOL, &this->props.period_event,
0);
}
return SPA_RESULT_OK;
@ -147,8 +147,8 @@ do_command (SpaLoop *loop,
SpaResult res;
SpaCommand *cmd = data;
if (SPA_COMMAND_TYPE (cmd) == this->uri.command_node.Start ||
SPA_COMMAND_TYPE (cmd) == this->uri.command_node.Pause) {
if (SPA_COMMAND_TYPE (cmd) == this->type.command_node.Start ||
SPA_COMMAND_TYPE (cmd) == this->type.command_node.Pause) {
res = spa_node_port_send_command (&this->node,
SPA_DIRECTION_INPUT,
0,
@ -158,7 +158,7 @@ do_command (SpaLoop *loop,
res = SPA_RESULT_NOT_IMPLEMENTED;
if (async) {
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->type.event_node.AsyncComplete,
seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
@ -181,8 +181,8 @@ spa_alsa_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASink, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start ||
SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start ||
SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -302,17 +302,17 @@ next:
switch (index++) {
case 0:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_audio.format, SPA_POD_TYPE_URI, 3, this->uri.audio_formats.S16,
this->uri.audio_formats.S16,
this->uri.audio_formats.S32),
PROP_U_MM (&f[1], this->uri.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->uri.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes_audio.aac,
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype_audio.aac,
SPA_POD_TYPE_NONE);
break;
default:
@ -385,23 +385,23 @@ spa_alsa_sink_node_port_set_format (SpaNode *node,
this->info.params = this->params;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->period_frames * this->frame_size),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->period_frames * this->frame_size),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_RINGBUFFER),
PROP (&f[1], this->uri.alloc_param_meta_enable.ringbufferSize, SPA_POD_TYPE_INT, this->period_frames * this->frame_size * 32),
PROP (&f[1], this->uri.alloc_param_meta_enable.ringbufferStride, SPA_POD_TYPE_INT, 0),
PROP (&f[1], this->uri.alloc_param_meta_enable.ringbufferBlocks, SPA_POD_TYPE_INT, 1),
PROP (&f[1], this->uri.alloc_param_meta_enable.ringbufferAlign, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_RINGBUFFER),
PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferSize, SPA_POD_TYPE_INT, this->period_frames * this->frame_size * 32),
PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferStride, SPA_POD_TYPE_INT, 0),
PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferBlocks, SPA_POD_TYPE_INT, 1),
PROP (&f[1], this->type.alloc_param_meta_enable.ringbufferAlign, SPA_POD_TYPE_INT, 16));
this->params[2] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
@ -612,12 +612,12 @@ spa_alsa_sink_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
@ -720,7 +720,7 @@ spa_alsa_sink_get_interface (SpaHandle *handle,
this = (SpaALSASink *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -753,20 +753,20 @@ alsa_sink_init (const SpaHandleFactory *factory,
this = (SpaALSASink *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = alsasink_node;
this->stream = SND_PCM_STREAM_PLAYBACK;

80
spa/plugins/alsa/alsa-source.c
View file

@ -84,13 +84,13 @@ spa_alsa_source_node_get_props (SpaNode *node,
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP (&f[1], this->uri.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], this->uri.prop_card_name, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], this->uri.prop_period_size, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], this->uri.prop_periods, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], this->uri.prop_period_event, SPA_POD_TYPE_BOOL, this->props.period_event));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP (&f[1], this->type.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP (&f[1], this->type.prop_card_name, -SPA_POD_TYPE_STRING, this->props.card_name, sizeof (this->props.card_name)),
PROP_MM (&f[1], this->type.prop_period_size, SPA_POD_TYPE_INT, this->props.period_size, 1, INT32_MAX),
PROP_MM (&f[1], this->type.prop_periods, SPA_POD_TYPE_INT, this->props.periods, 1, INT32_MAX),
PROP (&f[1], this->type.prop_period_event, SPA_POD_TYPE_BOOL, this->props.period_event));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
@ -113,10 +113,10 @@ spa_alsa_source_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
} else {
spa_props_query (props,
this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->uri.prop_period_size, SPA_POD_TYPE_INT, &this->props.period_size,
this->uri.prop_periods, SPA_POD_TYPE_INT, &this->props.periods,
this->uri.prop_period_event, SPA_POD_TYPE_BOOL, &this->props.period_event,
this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->type.prop_period_size, SPA_POD_TYPE_INT, &this->props.period_size,
this->type.prop_periods, SPA_POD_TYPE_INT, &this->props.periods,
this->type.prop_period_event, SPA_POD_TYPE_BOOL, &this->props.period_event,
0);
}
@ -154,7 +154,7 @@ do_start (SpaLoop *loop,
}
if (async) {
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->type.event_node.AsyncComplete,
seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
@ -182,7 +182,7 @@ do_pause (SpaLoop *loop,
}
if (async) {
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->type.event_node.AsyncComplete,
seq, res);
spa_loop_invoke (this->main_loop,
do_send_event,
@ -205,7 +205,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaALSASource, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -219,7 +219,7 @@ spa_alsa_source_node_send_command (SpaNode *node,
NULL,
this);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -340,17 +340,17 @@ next:
switch (index++) {
case 0:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_audio.format, SPA_POD_TYPE_URI, 3, this->uri.audio_formats.S16,
this->uri.audio_formats.S16,
this->uri.audio_formats.S32),
PROP_U_MM (&f[1], this->uri.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->uri.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
case 1:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes_audio.aac,
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype_audio.aac,
SPA_POD_TYPE_NONE);
default:
return SPA_RESULT_ENUM_END;
@ -434,15 +434,15 @@ spa_alsa_source_node_port_set_format (SpaNode *node,
this->info.params = this->params;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->period_frames * this->frame_size),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->period_frames * this->frame_size),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 0),
PROP_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 1, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
@ -671,11 +671,11 @@ spa_alsa_source_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (SPA_RESULT_IS_OK (res = spa_alsa_pause (this, false))) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
} else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
} else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
if (SPA_RESULT_IS_OK (res = spa_alsa_start (this, false))) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
@ -783,9 +783,9 @@ spa_alsa_source_get_interface (SpaHandle *handle,
this = (SpaALSASource *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->uri.clock)
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -818,20 +818,20 @@ alsa_source_init (const SpaHandleFactory *factory,
this = (SpaALSASource *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = alsasource_node;
this->clock = alsasource_clock;

28
spa/plugins/alsa/alsa-utils.c
View file

@ -62,18 +62,18 @@ typedef struct {
} FormatInfo;
#if __BYTE_ORDER == __BIG_ENDIAN
#define _FORMAT_LE(fmt) offsetof(URI, audio_formats. fmt ## _OE)
#define _FORMAT_BE(fmt) offsetof(URI, audio_formats. fmt)
#define _FORMAT_LE(fmt) offsetof(Type, audio_format. fmt ## _OE)
#define _FORMAT_BE(fmt) offsetof(Type, audio_format. fmt)
#elif __BYTE_ORDER == __LITTLE_ENDIAN
#define _FORMAT_LE(fmt) offsetof(URI, audio_formats. fmt)
#define _FORMAT_BE(fmt) offsetof(URI, audio_formats. fmt ## _OE)
#define _FORMAT_LE(fmt) offsetof(Type, audio_format. fmt)
#define _FORMAT_BE(fmt) offsetof(Type, audio_format. fmt ## _OE)
#endif
static const FormatInfo format_info[] =
{
{ offsetof(URI, audio_formats.UNKNOWN), SND_PCM_FORMAT_UNKNOWN },
{ offsetof(URI, audio_formats.S8), SND_PCM_FORMAT_S8 },
{ offsetof(URI, audio_formats.U8), SND_PCM_FORMAT_U8 },
{ offsetof(Type, audio_format.UNKNOWN), SND_PCM_FORMAT_UNKNOWN },
{ offsetof(Type, audio_format.S8), SND_PCM_FORMAT_S8 },
{ offsetof(Type, audio_format.U8), SND_PCM_FORMAT_U8 },
{ _FORMAT_LE (S16), SND_PCM_FORMAT_S16_LE },
{ _FORMAT_BE (S16), SND_PCM_FORMAT_S16_BE },
{ _FORMAT_LE (U16), SND_PCM_FORMAT_U16_LE },
@ -93,12 +93,12 @@ static const FormatInfo format_info[] =
};
static snd_pcm_format_t
spa_alsa_format_to_alsa (URI *uri, uint32_t format)
spa_alsa_format_to_alsa (Type *map, uint32_t format)
{
int i;
for (i = 0; i < SPA_N_ELEMENTS (format_info); i++) {
uint32_t f = *SPA_MEMBER (uri, format_info[i].format_offset, uint32_t);
uint32_t f = *SPA_MEMBER (map, format_info[i].format_offset, uint32_t);
if (f == format)
return format_info[i].format;
}
@ -132,7 +132,7 @@ spa_alsa_set_format (SpaALSAState *state, SpaAudioInfo *fmt, SpaPortFormatFlags
CHECK (snd_pcm_hw_params_set_access(hndl, params, SND_PCM_ACCESS_MMAP_INTERLEAVED), "set_access");
/* set the sample format */
format = spa_alsa_format_to_alsa (&state->uri, info->format);
format = spa_alsa_format_to_alsa (&state->type, info->format);
spa_log_info (state->log, "Stream parameters are %iHz, %s, %i channels", info->rate, snd_pcm_format_name(format), info->channels);
CHECK (snd_pcm_hw_params_set_format (hndl, params, format), "set_format");
@ -270,7 +270,7 @@ pull_frames_queue (SpaALSAState *state,
snd_pcm_uframes_t frames)
{
if (spa_list_is_empty (&state->ready)) {
SpaEvent event = SPA_EVENT_INIT (state->uri.event_node.NeedInput);
SpaEvent event = SPA_EVENT_INIT (state->type.event_node.NeedInput);
state->event_cb (&state->node, &event, state->user_data);
}
if (!spa_list_is_empty (&state->ready)) {
@ -294,7 +294,7 @@ pull_frames_queue (SpaALSAState *state,
state->ready_offset += n_bytes;
if (state->ready_offset >= size) {
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->uri.event_node.ReuseBuffer,
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->type.event_node.ReuseBuffer,
0, b->outbuf->id);
spa_list_remove (&b->link);
@ -349,7 +349,7 @@ pull_frames_ringbuffer (SpaALSAState *state,
b->outstanding = true;
{
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->uri.event_node.ReuseBuffer,
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (state->type.event_node.ReuseBuffer,
0, b->outbuf->id);
state->event_cb (&state->node, (SpaEvent*)&rb, state->user_data);
}
@ -498,7 +498,7 @@ mmap_read (SpaALSAState *state)
output->status = SPA_RESULT_OK;
}
{
SpaEvent event = SPA_EVENT_INIT (state->uri.event_node.HaveOutput);
SpaEvent event = SPA_EVENT_INIT (state->type.event_node.HaveOutput);
state->event_cb (&state->node, &event, state->user_data);
}
}

66
spa/plugins/alsa/alsa-utils.h
View file

@ -28,7 +28,7 @@ extern "C" {
#include <asoundlib.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/list.h>
@ -71,40 +71,40 @@ typedef struct {
uint32_t prop_period_size;
uint32_t prop_periods;
uint32_t prop_period_event;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaMediaSubtypesAudio media_subtypes_audio;
SpaPropAudio prop_audio;
SpaAudioFormats audio_formats;
SpaEventNode event_node;
SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeAudio media_subtype_audio;
SpaTypePropAudio prop_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_card_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__cardName);
uri->prop_period_size = spa_id_map_get_id (map, SPA_TYPE_PROPS__periodSize);
uri->prop_periods = spa_id_map_get_id (map, SPA_TYPE_PROPS__periods);
uri->prop_period_event = spa_id_map_get_id (map, SPA_TYPE_PROPS__periodEvent);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_device = spa_type_map_get_id (map, SPA_TYPE_PROPS__device);
type->prop_device_name = spa_type_map_get_id (map, SPA_TYPE_PROPS__deviceName);
type->prop_card_name = spa_type_map_get_id (map, SPA_TYPE_PROPS__cardName);
type->prop_period_size = spa_type_map_get_id (map, SPA_TYPE_PROPS__periodSize);
type->prop_periods = spa_type_map_get_id (map, SPA_TYPE_PROPS__periods);
type->prop_period_event = spa_type_map_get_id (map, SPA_TYPE_PROPS__periodEvent);
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_media_subtypes_audio_map (map, &uri->media_subtypes_audio);
spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats);
spa_event_node_map (map, &uri->event_node);
spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_media_subtype_audio_map (map, &type->media_subtype_audio);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
struct _SpaALSAState {
@ -114,8 +114,8 @@ struct _SpaALSAState {
uint32_t seq;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *main_loop;
SpaLoop *data_loop;

28
spa/plugins/audiomixer/audiomixer.c
View file

@ -21,7 +21,7 @@
#include <stdio.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/node.h>
#include <spa/audio/format-utils.h>
#include <lib/props.h>
@ -58,22 +58,22 @@ typedef struct {
typedef struct {
uint32_t node;
SpaCommandNode command_node;
} URI;
SpaTypeCommandNode command_node;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
spa_command_node_map (map, &uri->command_node);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
spa_type_command_node_map (map, &type->command_node);
}
struct _SpaAudioMixer {
SpaHandle handle;
SpaNode node;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaEventNodeCallback event_cb;
@ -125,10 +125,10 @@ spa_audiomixer_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioMixer, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
else
@ -659,7 +659,7 @@ spa_audiomixer_get_interface (SpaHandle *handle,
this = (SpaAudioMixer *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -692,16 +692,16 @@ spa_audiomixer_init (const SpaHandleFactory *factory,
this = (SpaAudioMixer *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = audiomixer_node;

144
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -23,7 +23,7 @@
#include <stdio.h>
#include <sys/timerfd.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/loop.h>
@ -48,37 +48,37 @@ typedef struct {
uint32_t prop_volume;
uint32_t wave_sine;
uint32_t wave_square;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaPropAudio prop_audio;
SpaAudioFormats audio_formats;
SpaEventNode event_node;
SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropAudio prop_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_live = spa_id_map_get_id (map, SPA_TYPE_PROPS__live);
uri->prop_wave = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType);
uri->prop_freq = spa_id_map_get_id (map, SPA_TYPE_PROPS__frequency);
uri->prop_volume = spa_id_map_get_id (map, SPA_TYPE_PROPS__volume);
uri->wave_sine = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType ":sine");
uri->wave_square = spa_id_map_get_id (map, SPA_TYPE_PROPS__waveType ":square");
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats);
spa_event_node_map (map, &uri->event_node);
spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live);
type->prop_wave = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType);
type->prop_freq = spa_type_map_get_id (map, SPA_TYPE_PROPS__frequency);
type->prop_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume);
type->wave_sine = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType ":sine");
type->wave_square = spa_type_map_get_id (map, SPA_TYPE_PROPS__waveType ":square");
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
typedef struct _SpaAudioTestSrc SpaAudioTestSrc;
@ -108,8 +108,8 @@ struct _SpaAudioTestSrc {
SpaNode node;
SpaClock clock;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *data_loop;
@ -154,7 +154,7 @@ static void
reset_audiotestsrc_props (SpaAudioTestSrc *this, SpaAudioTestSrcProps *props)
{
props->live = DEFAULT_LIVE;
props->wave = this->uri. DEFAULT_WAVE;
props->wave = this->type. DEFAULT_WAVE;
props->freq = DEFAULT_FREQ;
props->volume = DEFAULT_VOLUME;
}
@ -190,14 +190,14 @@ spa_audiotestsrc_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->uri.prop_wave, SPA_POD_TYPE_URI, 3, this->props.wave,
this->uri.wave_sine,
this->uri.wave_square),
PROP_MM (&f[1], this->uri.prop_freq, SPA_POD_TYPE_DOUBLE, this->props.freq,
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->type.prop_wave, SPA_POD_TYPE_URI, 3, this->props.wave,
this->type.wave_sine,
this->type.wave_square),
PROP_MM (&f[1], this->type.prop_freq, SPA_POD_TYPE_DOUBLE, this->props.freq,
0.0, 50000000.0),
PROP_MM (&f[1], this->uri.prop_volume, SPA_POD_TYPE_DOUBLE, this->props.volume,
PROP_MM (&f[1], this->type.prop_volume, SPA_POD_TYPE_DOUBLE, this->props.volume,
0.0, 10.0));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
@ -220,10 +220,10 @@ spa_audiotestsrc_node_set_props (SpaNode *node,
reset_audiotestsrc_props (this, &this->props);
} else {
spa_props_query (props,
this->uri.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->uri.prop_wave, SPA_POD_TYPE_URI, &this->props.wave,
this->uri.prop_freq, SPA_POD_TYPE_DOUBLE, &this->props.freq,
this->uri.prop_volume, SPA_POD_TYPE_DOUBLE, &this->props.volume,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->type.prop_wave, SPA_POD_TYPE_URI, &this->props.wave,
this->type.prop_freq, SPA_POD_TYPE_DOUBLE, &this->props.freq,
this->type.prop_volume, SPA_POD_TYPE_DOUBLE, &this->props.volume,
0);
}
@ -240,7 +240,7 @@ send_have_output (SpaAudioTestSrc *this)
{
if (this->event_cb) {
SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
SpaEvent event = SPA_EVENT_INIT (this->type.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data);
}
@ -334,7 +334,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaAudioTestSrc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
struct timespec now;
if (!this->have_format)
@ -358,7 +358,7 @@ spa_audiotestsrc_node_send_command (SpaNode *node,
set_timer (this, true);
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -484,13 +484,13 @@ next:
switch (index++) {
case 0:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_audio.format, SPA_POD_TYPE_URI, 3, this->uri.audio_formats.S16,
this->uri.audio_formats.S16,
this->uri.audio_formats.S32),
PROP_U_MM (&f[1], this->uri.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->uri.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3, this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:
return SPA_RESULT_ENUM_END;
@ -560,15 +560,15 @@ spa_audiotestsrc_node_port_set_format (SpaNode *node,
this->info.params = this->params;
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, 1024),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 1024),
PROP_U_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, 1024),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 1024),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
@ -602,11 +602,11 @@ spa_audiotestsrc_node_port_get_format (SpaNode *node,
return SPA_RESULT_NO_FORMAT;
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes.raw,
PROP (&f[1], this->uri.prop_audio.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
PROP (&f[1], this->uri.prop_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, this->current_format.info.raw.rate),
PROP (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, this->current_format.info.raw.channels));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
@ -909,9 +909,9 @@ spa_audiotestsrc_get_interface (SpaHandle *handle,
this = (SpaAudioTestSrc *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->uri.clock)
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -953,22 +953,22 @@ audiotestsrc_init (const SpaHandleFactory *factory,
this = (SpaAudioTestSrc *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
if (this->data_loop == NULL) {
spa_log_error (this->log, "a data_loop is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = audiotestsrc_node;
this->clock = audiotestsrc_clock;

32
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -22,7 +22,7 @@
#include <sys/stat.h>
#include <fcntl.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/log.h>
#include <spa/node.h>
#include <spa/video/format-utils.h>
@ -52,15 +52,22 @@ typedef struct {
typedef struct {
uint32_t node;
SpaCommandNode command_node;
} URI;
SpaTypeCommandNode command_node;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
spa_type_command_node_map (map, &type->command_node);
}
struct _SpaFFMpegDec {
SpaHandle handle;
SpaNode node;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaEventNodeCallback event_cb;
@ -105,10 +112,10 @@ spa_ffmpeg_dec_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegDec, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
else
@ -491,7 +498,7 @@ spa_ffmpeg_dec_get_interface (SpaHandle *handle,
this = (SpaFFMpegDec *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -513,19 +520,18 @@ spa_ffmpeg_dec_init (SpaHandle *handle,
this = (SpaFFMpegDec *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
this->uri.node = spa_id_map_get_id (this->map, SPA_TYPE__Node);
init_type (&this->type, this->map);
this->node = ffmpeg_dec_node;
spa_command_node_map (this->map, &this->uri.command_node);
this->in_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->out_ports[0].info.flags = SPA_PORT_INFO_FLAG_NONE;

43
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -23,7 +23,7 @@
#include <fcntl.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/node.h>
#include <spa/video/format-utils.h>
#include <lib/props.h>
@ -57,17 +57,26 @@ typedef struct {
typedef struct {
uint32_t node;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaCommandNode command_node;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeCommandNode command_node;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_command_node_map (map, &type->command_node);
}
struct _SpaFFMpegEnc {
SpaHandle handle;
SpaNode node;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaEventNodeCallback event_cb;
@ -112,10 +121,10 @@ spa_ffmpeg_enc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaFFMpegEnc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
else
@ -258,8 +267,8 @@ spa_ffmpeg_enc_node_port_set_format (SpaNode *node,
return SPA_RESULT_OK;
}
if (format->body.media_type.value != this->uri.media_types.video ||
format->body.media_subtype.value != this->uri.media_subtypes.raw)
if (format->body.media_type.value != this->type.media_type.video ||
format->body.media_subtype.value != this->type.media_subtype.raw)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if ((res = spa_format_video_parse (format, &query_format) < 0))
@ -504,7 +513,7 @@ spa_ffmpeg_enc_get_interface (SpaHandle *handle,
this = (SpaFFMpegEnc *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -526,19 +535,15 @@ spa_ffmpeg_enc_init (SpaHandle *handle,
this = (SpaFFMpegEnc *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
this->uri.node = spa_id_map_get_id (this->map, SPA_TYPE__Node);
spa_media_types_fill (&this->uri.media_types, this->map);
spa_media_subtypes_map (this->map, &this->uri.media_subtypes);
spa_command_node_map (this->map, &this->uri.command_node);
this->node = ffmpeg_enc_node;

52
spa/plugins/v4l2/v4l2-monitor.c
View file

@ -26,7 +26,7 @@
#include <libudev.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/loop.h>
#include <spa/monitor.h>
#include <lib/debug.h>
@ -42,15 +42,22 @@ typedef struct {
typedef struct {
uint32_t handle_factory;
SpaMonitorTypes monitor_types;
} URI;
SpaTypeMonitor monitor;
} Type;
static inline void
init_type (Type *type, SpaTypeMap *map)
{
type->handle_factory = spa_type_map_get_id (map, SPA_TYPE__HandleFactory);
spa_type_monitor_map (map, &type->monitor);
}
struct _SpaV4l2Monitor {
SpaHandle handle;
SpaMonitor monitor;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *main_loop;
@ -108,20 +115,20 @@ fill_item (SpaV4l2Monitor *this, V4l2Item *item, struct udev_device *udevice)
spa_pod_builder_init (&b, this->item_buffer, sizeof (this->item_buffer));
spa_pod_builder_push_object (&b, &f[0], 0, this->uri.monitor_types.MonitorItem);
spa_pod_builder_push_object (&b, &f[0], 0, this->type.monitor.MonitorItem);
spa_pod_builder_add (&b,
SPA_POD_PROP (&f[1], this->uri.monitor_types.id, 0, SPA_POD_TYPE_STRING, 1, udev_device_get_syspath (item->udevice)),
SPA_POD_PROP (&f[1], this->uri.monitor_types.flags, 0, SPA_POD_TYPE_INT, 1, 0),
SPA_POD_PROP (&f[1], this->uri.monitor_types.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE),
SPA_POD_PROP (&f[1], this->uri.monitor_types.name, 0, SPA_POD_TYPE_STRING, 1, name),
SPA_POD_PROP (&f[1], this->uri.monitor_types.klass, 0, SPA_POD_TYPE_STRING, 1, "Video/Source"),
SPA_POD_PROP (&f[1], this->uri.monitor_types.factory, 0, SPA_POD_TYPE_POINTER, 1, this->uri.handle_factory,
SPA_POD_PROP (&f[1], this->type.monitor.id, 0, SPA_POD_TYPE_STRING, 1, udev_device_get_syspath (item->udevice)),
SPA_POD_PROP (&f[1], this->type.monitor.flags, 0, SPA_POD_TYPE_INT, 1, 0),
SPA_POD_PROP (&f[1], this->type.monitor.state, 0, SPA_POD_TYPE_INT, 1, SPA_MONITOR_ITEM_STATE_AVAILABLE),
SPA_POD_PROP (&f[1], this->type.monitor.name, 0, SPA_POD_TYPE_STRING, 1, name),
SPA_POD_PROP (&f[1], this->type.monitor.klass, 0, SPA_POD_TYPE_STRING, 1, "Video/Source"),
SPA_POD_PROP (&f[1], this->type.monitor.factory, 0, SPA_POD_TYPE_POINTER, 1, this->type.handle_factory,
&spa_v4l2_source_factory),
0);
spa_pod_builder_add (&b,
SPA_POD_TYPE_PROP, &f[1], this->uri.monitor_types.info, 0,
SPA_POD_TYPE_PROP, &f[1], this->type.monitor.info, 0,
SPA_POD_TYPE_STRUCT, 1, &f[2], 0);
@ -204,11 +211,11 @@ v4l2_on_fd_events (SpaSource *source)
action = "change";
if (strcmp (action, "add") == 0) {
type = this->uri.monitor_types.Added;
type = this->type.monitor.Added;
} else if (strcmp (action, "change") == 0) {
type = this->uri.monitor_types.Changed;
type = this->type.monitor.Changed;
} else if (strcmp (action, "remove") == 0) {
type = this->uri.monitor_types.Removed;
type = this->type.monitor.Removed;
} else
return;
@ -333,7 +340,7 @@ spa_v4l2_monitor_get_interface (SpaHandle *handle,
this = (SpaV4l2Monitor *) handle;
if (interface_id == this->uri.monitor_types.Monitor)
if (interface_id == this->type.monitor.Monitor)
*interface = &this->monitor;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -366,23 +373,22 @@ v4l2_monitor_init (const SpaHandleFactory *factory,
this = (SpaV4l2Monitor *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__MainLoop) == 0)
this->main_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
if (this->main_loop == NULL) {
spa_log_error (this->log, "a main-loop is needed");
return SPA_RESULT_ERROR;
}
this->uri.handle_factory = spa_id_map_get_id (this->map, SPA_TYPE__HandleFactory);
spa_monitor_types_map (this->map, &this->uri.monitor_types);
init_type (&this->type, this->map);
this->monitor = v4l2monitor;

124
spa/plugins/v4l2/v4l2-source.c
View file

@ -30,7 +30,7 @@
#include <spa/list.h>
#include <spa/log.h>
#include <spa/loop.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/format-builder.h>
#include <lib/debug.h>
#include <lib/props.h>
@ -71,36 +71,36 @@ typedef struct {
uint32_t prop_device;
uint32_t prop_device_name;
uint32_t prop_device_fd;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaMediaSubtypesVideo media_subtypes_video;
SpaPropVideo prop_video;
SpaVideoFormats video_formats;
SpaEventNode event_node;
SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeMediaSubtypeVideo media_subtype_video;
SpaTypePropVideo prop_video;
SpaTypeVideoFormat video_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_device_fd = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_media_subtypes_video_map (map, &uri->media_subtypes_video);
spa_prop_video_map (map, &uri->prop_video);
spa_video_formats_map (map, &uri->video_formats);
spa_event_node_map (map, &uri->event_node);
spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_device = spa_type_map_get_id (map, SPA_TYPE_PROPS__device);
type->prop_device_name = spa_type_map_get_id (map, SPA_TYPE_PROPS__deviceName);
type->prop_device_fd = spa_type_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_media_subtype_video_map (map, &type->media_subtype_video);
spa_type_prop_video_map (map, &type->prop_video);
spa_type_video_format_map (map, &type->video_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
typedef struct {
@ -148,9 +148,9 @@ struct _SpaV4l2Source {
SpaNode node;
SpaClock clock;
SpaIDMap *map;
SpaTypeMap *map;
SpaLog *log;
URI uri;
Type type;
uint32_t seq;
@ -206,10 +206,10 @@ spa_v4l2_source_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP_R (&f[1], this->uri.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP_R (&f[1], this->uri.prop_device_fd, SPA_POD_TYPE_INT, this->props.device_fd));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP_R (&f[1], this->type.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP_R (&f[1], this->type.prop_device_fd, SPA_POD_TYPE_INT, this->props.device_fd));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
@ -231,7 +231,7 @@ spa_v4l2_source_node_set_props (SpaNode *node,
return SPA_RESULT_OK;
} else {
spa_props_query (props,
this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
0);
}
return SPA_RESULT_OK;
@ -279,7 +279,7 @@ do_pause (SpaLoop *loop,
cmd);
if (async) {
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->type.event_node.AsyncComplete,
seq, res);
spa_loop_invoke (this->state[0].main_loop,
do_pause_done,
@ -330,7 +330,7 @@ do_start (SpaLoop *loop,
cmd);
if (async) {
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->uri.event_node.AsyncComplete,
SpaEventNodeAsyncComplete ac = SPA_EVENT_NODE_ASYNC_COMPLETE_INIT (this->type.event_node.AsyncComplete,
seq, res);
spa_loop_invoke (this->state[0].main_loop,
do_start_done,
@ -354,7 +354,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaV4l2Source, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
SpaV4l2State *state = &this->state[0];
SpaResult res;
@ -377,7 +377,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
command,
this);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
SpaV4l2State *state = &this->state[0];
if (!state->have_format)
@ -396,7 +396,7 @@ spa_v4l2_source_node_send_command (SpaNode *node,
command,
this);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.ClockUpdate) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.ClockUpdate) {
return SPA_RESULT_OK;
}
else
@ -587,28 +587,28 @@ spa_v4l2_source_node_port_get_format (SpaNode *node,
b.data = state->format_buffer;
b.size = sizeof (state->format_buffer);
spa_pod_builder_push_format (&b, &f[0], this->uri.format,
spa_pod_builder_push_format (&b, &f[0], this->type.format,
state->current_format.media_type,
state->current_format.media_subtype);
if (state->current_format.media_subtype == this->uri.media_subtypes.raw) {
if (state->current_format.media_subtype == this->type.media_subtype.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, state->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, state->current_format.info.raw.format),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
0);
}
else if (state->current_format.media_subtype == this->uri.media_subtypes_video.mjpg ||
state->current_format.media_subtype == this->uri.media_subtypes_video.jpeg) {
else if (state->current_format.media_subtype == this->type.media_subtype_video.mjpg ||
state->current_format.media_subtype == this->type.media_subtype_video.jpeg) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.mjpg.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.mjpg.framerate),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.mjpg.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.mjpg.framerate),
0);
}
else if (state->current_format.media_subtype == this->uri.media_subtypes_video.h264) {
else if (state->current_format.media_subtype == this->type.media_subtype_video.h264) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.h264.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.h264.framerate),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.h264.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.h264.framerate),
0);
} else
return SPA_RESULT_NO_FORMAT;
@ -807,10 +807,10 @@ spa_v4l2_source_node_port_send_command (SpaNode *node,
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
res = spa_v4l2_port_set_enabled (this, false);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
res = spa_v4l2_port_set_enabled (this, true);
} else
res = SPA_RESULT_NOT_IMPLEMENTED;
@ -918,9 +918,9 @@ spa_v4l2_source_get_interface (SpaHandle *handle,
this = (SpaV4l2Source *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->uri.clock)
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -954,17 +954,17 @@ v4l2_source_init (const SpaHandleFactory *factory,
this = (SpaV4l2Source *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__MainLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__MainLoop) == 0)
this->state[0].main_loop = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->state[0].data_loop = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
if (this->state[0].main_loop == NULL) {
@ -975,7 +975,7 @@ v4l2_source_init (const SpaHandleFactory *factory,
spa_log_error (this->log, "a data_loop is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = v4l2source_node;
this->clock = v4l2source_clock;

174
spa/plugins/v4l2/v4l2-utils.c
View file

@ -169,54 +169,54 @@ typedef struct {
off_t media_subtype_offset;
} FormatInfo;
#define VIDEO offsetof(URI, media_types.video)
#define IMAGE offsetof(URI, media_types.image)
#define VIDEO offsetof(Type, media_type.video)
#define IMAGE offsetof(Type, media_type.image)
#define RAW offsetof(URI, media_subtypes.raw)
#define RAW offsetof(Type, media_subtype.raw)
#define BAYER offsetof(URI, media_subtypes_video.bayer)
#define MJPG offsetof(URI, media_subtypes_video.mjpg)
#define JPEG offsetof(URI, media_subtypes_video.jpeg)
#define DV offsetof(URI, media_subtypes_video.dv)
#define MPEGTS offsetof(URI, media_subtypes_video.mpegts)
#define H264 offsetof(URI, media_subtypes_video.h264)
#define H263 offsetof(URI, media_subtypes_video.h263)
#define MPEG1 offsetof(URI, media_subtypes_video.mpeg1)
#define MPEG2 offsetof(URI, media_subtypes_video.mpeg2)
#define MPEG4 offsetof(URI, media_subtypes_video.mpeg4)
#define XVID offsetof(URI, media_subtypes_video.xvid)
#define VC1 offsetof(URI, media_subtypes_video.vc1)
#define VP8 offsetof(URI, media_subtypes_video.vp8)
#define BAYER offsetof(Type, media_subtype_video.bayer)
#define MJPG offsetof(Type, media_subtype_video.mjpg)
#define JPEG offsetof(Type, media_subtype_video.jpeg)
#define DV offsetof(Type, media_subtype_video.dv)
#define MPEGTS offsetof(Type, media_subtype_video.mpegts)
#define H264 offsetof(Type, media_subtype_video.h264)
#define H263 offsetof(Type, media_subtype_video.h263)
#define MPEG1 offsetof(Type, media_subtype_video.mpeg1)
#define MPEG2 offsetof(Type, media_subtype_video.mpeg2)
#define MPEG4 offsetof(Type, media_subtype_video.mpeg4)
#define XVID offsetof(Type, media_subtype_video.xvid)
#define VC1 offsetof(Type, media_subtype_video.vc1)
#define VP8 offsetof(Type, media_subtype_video.vp8)
#define FORMAT_UNKNOWN offsetof(URI, video_formats.UNKNOWN)
#define FORMAT_ENCODED offsetof(URI, video_formats.ENCODED)
#define FORMAT_RGB15 offsetof(URI, video_formats.RGB15)
#define FORMAT_BGR15 offsetof(URI, video_formats.BGR15)
#define FORMAT_RGB16 offsetof(URI, video_formats.RGB16)
#define FORMAT_BGR offsetof(URI, video_formats.BGR)
#define FORMAT_RGB offsetof(URI, video_formats.RGB)
#define FORMAT_BGRA offsetof(URI, video_formats.BGRA)
#define FORMAT_BGRx offsetof(URI, video_formats.BGRx)
#define FORMAT_ARGB offsetof(URI, video_formats.ARGB)
#define FORMAT_xRGB offsetof(URI, video_formats.xRGB)
#define FORMAT_GRAY8 offsetof(URI, video_formats.GRAY8)
#define FORMAT_GRAY16_LE offsetof(URI, video_formats.GRAY16_LE)
#define FORMAT_GRAY16_BE offsetof(URI, video_formats.GRAY16_BE)
#define FORMAT_YVU9 offsetof(URI, video_formats.YVU9)
#define FORMAT_YV12 offsetof(URI, video_formats.YV12)
#define FORMAT_YUY2 offsetof(URI, video_formats.YUY2)
#define FORMAT_YVYU offsetof(URI, video_formats.YVYU)
#define FORMAT_UYVY offsetof(URI, video_formats.UYVY)
#define FORMAT_Y42B offsetof(URI, video_formats.Y42B)
#define FORMAT_Y41B offsetof(URI, video_formats.Y41B)
#define FORMAT_YUV9 offsetof(URI, video_formats.YUV9)
#define FORMAT_I420 offsetof(URI, video_formats.I420)
#define FORMAT_NV12 offsetof(URI, video_formats.NV12)
#define FORMAT_NV12_64Z32 offsetof(URI, video_formats.NV12_64Z32)
#define FORMAT_NV21 offsetof(URI, video_formats.NV21)
#define FORMAT_NV16 offsetof(URI, video_formats.NV16)
#define FORMAT_NV61 offsetof(URI, video_formats.NV61)
#define FORMAT_NV24 offsetof(URI, video_formats.NV24)
#define FORMAT_UNKNOWN offsetof(Type, video_format.UNKNOWN)
#define FORMAT_ENCODED offsetof(Type, video_format.ENCODED)
#define FORMAT_RGB15 offsetof(Type, video_format.RGB15)
#define FORMAT_BGR15 offsetof(Type, video_format.BGR15)
#define FORMAT_RGB16 offsetof(Type, video_format.RGB16)
#define FORMAT_BGR offsetof(Type, video_format.BGR)
#define FORMAT_RGB offsetof(Type, video_format.RGB)
#define FORMAT_BGRA offsetof(Type, video_format.BGRA)
#define FORMAT_BGRx offsetof(Type, video_format.BGRx)
#define FORMAT_ARGB offsetof(Type, video_format.ARGB)
#define FORMAT_xRGB offsetof(Type, video_format.xRGB)
#define FORMAT_GRAY8 offsetof(Type, video_format.GRAY8)
#define FORMAT_GRAY16_LE offsetof(Type, video_format.GRAY16_LE)
#define FORMAT_GRAY16_BE offsetof(Type, video_format.GRAY16_BE)
#define FORMAT_YVU9 offsetof(Type, video_format.YVU9)
#define FORMAT_YV12 offsetof(Type, video_format.YV12)
#define FORMAT_YUY2 offsetof(Type, video_format.YUY2)
#define FORMAT_YVYU offsetof(Type, video_format.YVYU)
#define FORMAT_UYVY offsetof(Type, video_format.UYVY)
#define FORMAT_Y42B offsetof(Type, video_format.Y42B)
#define FORMAT_Y41B offsetof(Type, video_format.Y41B)
#define FORMAT_YUV9 offsetof(Type, video_format.YUV9)
#define FORMAT_I420 offsetof(Type, video_format.I420)
#define FORMAT_NV12 offsetof(Type, video_format.NV12)
#define FORMAT_NV12_64Z32 offsetof(Type, video_format.NV12_64Z32)
#define FORMAT_NV21 offsetof(Type, video_format.NV21)
#define FORMAT_NV16 offsetof(Type, video_format.NV16)
#define FORMAT_NV61 offsetof(Type, video_format.NV61)
#define FORMAT_NV24 offsetof(Type, video_format.NV24)
static const FormatInfo format_info[] =
{
@ -354,7 +354,7 @@ video_format_to_format_info (SpaVideoFormat format)
#endif
static const FormatInfo *
find_format_info_by_media_type (URI *uri,
find_format_info_by_media_type (Type *types,
uint32_t type,
uint32_t subtype,
uint32_t format,
@ -365,9 +365,9 @@ find_format_info_by_media_type (URI *uri,
for (i = startidx; i < SPA_N_ELEMENTS (format_info); i++) {
uint32_t media_type, media_subtype, media_format;
media_type = *SPA_MEMBER (uri, format_info[i].media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (uri, format_info[i].media_subtype_offset, uint32_t);
media_format = *SPA_MEMBER (uri, format_info[i].format_offset, uint32_t);
media_type = *SPA_MEMBER (types, format_info[i].media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (types, format_info[i].media_subtype_offset, uint32_t);
media_format = *SPA_MEMBER (types, format_info[i].format_offset, uint32_t);
if ((media_type == type) &&
(media_subtype == subtype) &&
@ -378,22 +378,22 @@ find_format_info_by_media_type (URI *uri,
}
static uint32_t
enum_filter_format (URI *uri, const SpaFormat *filter, uint32_t index)
enum_filter_format (Type *type, const SpaFormat *filter, uint32_t index)
{
uint32_t video_format = 0;
if ((filter->body.media_type.value == uri->media_types.video ||
filter->body.media_type.value == uri->media_types.image)) {
if (filter->body.media_subtype.value == uri->media_subtypes.raw) {
if ((filter->body.media_type.value == type->media_type.video ||
filter->body.media_type.value == type->media_type.image)) {
if (filter->body.media_subtype.value == type->media_subtype.raw) {
SpaPODProp *p;
uint32_t n_values;
const uint32_t *values;
if (!(p = spa_format_find_prop (filter, uri->prop_video.format)))
return uri->video_formats.UNKNOWN;
if (!(p = spa_format_find_prop (filter, type->prop_video.format)))
return type->video_format.UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_URI)
return uri->video_formats.UNKNOWN;
return type->video_format.UNKNOWN;
values = SPA_POD_BODY_CONST (&p->body.value);
n_values = SPA_POD_PROP_N_VALUES (p);
@ -407,7 +407,7 @@ enum_filter_format (URI *uri, const SpaFormat *filter, uint32_t index)
}
} else {
if (index == 0)
video_format = uri->video_formats.ENCODED;
video_format = type->video_format.ENCODED;
}
}
return video_format;
@ -538,11 +538,11 @@ next_fmtdesc:
while (state->next_fmtdesc) {
if (filter) {
video_format = enum_filter_format (&this->uri, filter, state->fmtdesc.index);
if (video_format == this->uri.video_formats.UNKNOWN)
video_format = enum_filter_format (&this->type, filter, state->fmtdesc.index);
if (video_format == this->type.video_format.UNKNOWN)
return SPA_RESULT_ENUM_END;
info = find_format_info_by_media_type (&this->uri,
info = find_format_info_by_media_type (&this->type,
filter->body.media_type.value,
filter->body.media_subtype.value,
video_format,
@ -572,7 +572,7 @@ next_frmsize:
SpaPODProp *p;
/* check if we have a fixed frame size */
if (!(p = spa_format_find_prop (filter, this->uri.prop_video.size)))
if (!(p = spa_format_find_prop (filter, this->type.prop_video.size)))
goto do_frmsize;
if (p->body.value.type != SPA_POD_TYPE_RECTANGLE)
@ -605,7 +605,7 @@ do_frmsize:
uint32_t i, n_values;
/* check if we have a fixed frame size */
if (!(p = spa_format_find_prop (filter, this->uri.prop_video.size)))
if (!(p = spa_format_find_prop (filter, this->type.prop_video.size)))
goto have_size;
range = p->body.flags & SPA_POD_PROP_RANGE_MASK;
@ -658,26 +658,26 @@ have_size:
}
}
media_type = *SPA_MEMBER (&this->uri, info->media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (&this->uri, info->media_subtype_offset, uint32_t);
video_format = *SPA_MEMBER (&this->uri, info->format_offset, uint32_t);
media_type = *SPA_MEMBER (&this->type, info->media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (&this->type, info->media_subtype_offset, uint32_t);
video_format = *SPA_MEMBER (&this->type, info->format_offset, uint32_t);
spa_pod_builder_push_format (&b, &f[0], this->uri.format,
spa_pod_builder_push_format (&b, &f[0], this->type.format,
media_type,
media_subtype);
if (media_subtype == this->uri.media_subtypes.raw) {
if (media_subtype == this->type.media_subtype.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, video_format),
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, video_format),
0);
}
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.size, SPA_POD_TYPE_RECTANGLE, state->frmsize.discrete.width,
PROP (&f[1], this->type.prop_video.size, SPA_POD_TYPE_RECTANGLE, state->frmsize.discrete.width,
state->frmsize.discrete.height),
0);
spa_pod_builder_push_prop (&b, &f[1],
this->uri.prop_video.framerate,
this->type.prop_video.framerate,
SPA_POD_PROP_RANGE_NONE |
SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_FLAG_READWRITE);
@ -705,7 +705,7 @@ have_size:
uint32_t i, n_values;
const SpaFraction step = { 1, 1 }, *values;
if (!(p = spa_format_find_prop (filter, this->uri.prop_video.framerate)))
if (!(p = spa_format_find_prop (filter, this->type.prop_video.framerate)))
goto have_framerate;
if (p->body.value.type != SPA_POD_TYPE_FRACTION)
@ -804,27 +804,27 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only)
fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
streamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
if (format->media_subtype == this->uri.media_subtypes.raw) {
if (format->media_subtype == this->type.media_subtype.raw) {
video_format = format->info.raw.format;
size = &format->info.raw.size;
framerate = &format->info.raw.framerate;
}
else if (format->media_subtype == this->uri.media_subtypes_video.mjpg ||
format->media_subtype == this->uri.media_subtypes_video.jpeg) {
video_format = this->uri.video_formats.ENCODED;
else if (format->media_subtype == this->type.media_subtype_video.mjpg ||
format->media_subtype == this->type.media_subtype_video.jpeg) {
video_format = this->type.video_format.ENCODED;
size = &format->info.mjpg.size;
framerate = &format->info.mjpg.framerate;
}
else if (format->media_subtype == this->uri.media_subtypes_video.h264) {
video_format = this->uri.video_formats.ENCODED;
else if (format->media_subtype == this->type.media_subtype_video.h264) {
video_format = this->type.video_format.ENCODED;
size = &format->info.h264.size;
framerate = &format->info.h264.framerate;
}
else {
video_format = this->uri.video_formats.ENCODED;
video_format = this->type.video_format.ENCODED;
}
info = find_format_info_by_media_type (&this->uri,
info = find_format_info_by_media_type (&this->type,
format->media_type,
format->media_subtype,
video_format,
@ -893,15 +893,15 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only)
state->info.params = state->params;
spa_pod_builder_init (&b, state->params_buffer, sizeof (state->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, fmt.fmt.pix.sizeimage),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, fmt.fmt.pix.bytesperline),
PROP_U_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, MAX_BUFFERS, 2, MAX_BUFFERS),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, fmt.fmt.pix.sizeimage),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, fmt.fmt.pix.bytesperline),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, MAX_BUFFERS, 2, MAX_BUFFERS),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
state->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
state->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
state->info.extra = NULL;
@ -979,7 +979,7 @@ v4l2_on_fd_events (SpaSource *source)
return;
{
SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
SpaEvent event = SPA_EVENT_INIT (this->type.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data);
}
}

12
spa/plugins/videotestsrc/draw.c
View file

@ -144,14 +144,14 @@ drawing_data_init (DrawingData *dd,
SpaVideoInfo *format = &this->current_format;
SpaRectangle *size = &format->info.raw.size;
if ((format->media_type != this->uri.media_types.video) ||
(format->media_subtype != this->uri.media_subtypes.raw))
if ((format->media_type != this->type.media_type.video) ||
(format->media_subtype != this->type.media_subtype.raw))
return SPA_RESULT_NOT_IMPLEMENTED;
if (format->info.raw.format == this->uri.video_formats.RGB) {
if (format->info.raw.format == this->type.video_format.RGB) {
dd->draw_pixel = draw_pixel_rgb;
}
else if (format->info.raw.format == this->uri.video_formats.UYVY) {
else if (format->info.raw.format == this->type.video_format.UYVY) {
dd->draw_pixel = draw_pixel_uyvy;
}
else
@ -282,9 +282,9 @@ draw (SpaVideoTestSrc *this, char *data)
return res;
pattern = this->props.pattern;
if (pattern == this->uri.pattern_smpte_snow)
if (pattern == this->type.pattern_smpte_snow)
draw_smpte_snow (&dd);
else if (pattern == this->uri.pattern_snow)
else if (pattern == this->type.pattern_snow)
draw_snow (&dd);
else
return SPA_RESULT_NOT_IMPLEMENTED;

136
spa/plugins/videotestsrc/videotestsrc.c
View file

@ -24,7 +24,7 @@
#include <stdio.h>
#include <sys/timerfd.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/loop.h>
@ -46,35 +46,35 @@ typedef struct {
uint32_t prop_pattern;
uint32_t pattern_smpte_snow;
uint32_t pattern_snow;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaPropVideo prop_video;
SpaVideoFormats video_formats;
SpaEventNode event_node;
SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropVideo prop_video;
SpaTypeVideoFormat video_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->clock = spa_id_map_get_id (map, SPA_TYPE__Clock);
uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_live = spa_id_map_get_id (map, SPA_TYPE_PROPS__live);
uri->prop_pattern = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType);
uri->pattern_smpte_snow = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType ":smpte-snow");
uri->pattern_snow = spa_id_map_get_id (map, SPA_TYPE_PROPS__patternType ":snow");
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_video_map (map, &uri->prop_video);
spa_video_formats_map (map, &uri->video_formats);
spa_event_node_map (map, &uri->event_node);
spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->clock = spa_type_map_get_id (map, SPA_TYPE__Clock);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_live = spa_type_map_get_id (map, SPA_TYPE_PROPS__live);
type->prop_pattern = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType);
type->pattern_smpte_snow = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType ":smpte-snow");
type->pattern_snow = spa_type_map_get_id (map, SPA_TYPE_PROPS__patternType ":snow");
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_video_map (map, &type->prop_video);
spa_type_video_format_map (map, &type->video_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
typedef struct _SpaVideoTestSrc SpaVideoTestSrc;
@ -102,8 +102,8 @@ struct _SpaVideoTestSrc {
SpaNode node;
SpaClock clock;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
SpaLoop *data_loop;
@ -147,7 +147,7 @@ static void
reset_videotestsrc_props (SpaVideoTestSrc *this, SpaVideoTestSrcProps *props)
{
props->live = DEFAULT_LIVE;
props->pattern = this->uri. DEFAULT_PATTERN;
props->pattern = this->type. DEFAULT_PATTERN;
}
#define PROP(f,key,type,...) \
@ -182,12 +182,12 @@ spa_videotestsrc_node_get_props (SpaNode *node,
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->uri.prop_pattern, SPA_POD_TYPE_URI, 3,
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_live, SPA_POD_TYPE_BOOL, this->props.live),
PROP_EN (&f[1], this->type.prop_pattern, SPA_POD_TYPE_URI, 3,
this->props.pattern,
this->uri.pattern_smpte_snow,
this->uri.pattern_snow));
this->type.pattern_smpte_snow,
this->type.pattern_snow));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
@ -209,8 +209,8 @@ spa_videotestsrc_node_set_props (SpaNode *node,
reset_videotestsrc_props (this, &this->props);
} else {
spa_props_query (props,
this->uri.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->uri.prop_pattern, SPA_POD_TYPE_URI, &this->props.pattern,
this->type.prop_live, SPA_POD_TYPE_BOOL, &this->props.live,
this->type.prop_pattern, SPA_POD_TYPE_URI, &this->props.pattern,
0);
}
@ -227,7 +227,7 @@ send_have_output (SpaVideoTestSrc *this)
{
if (this->event_cb) {
SpaEvent event = SPA_EVENT_INIT (this->uri.event_node.HaveOutput);
SpaEvent event = SPA_EVENT_INIT (this->type.event_node.HaveOutput);
this->event_cb (&this->node, &event, this->user_data);
}
return SPA_RESULT_OK;
@ -315,7 +315,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVideoTestSrc, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
struct timespec now;
if (!this->have_format)
@ -339,7 +339,7 @@ spa_videotestsrc_node_send_command (SpaNode *node,
set_timer (this, true);
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
if (!this->have_format)
return SPA_RESULT_NO_FORMAT;
@ -465,17 +465,17 @@ next:
switch (index++) {
case 0:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.video, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, 3,
this->uri.video_formats.RGB,
this->uri.video_formats.RGB,
this->uri.video_formats.UYVY),
PROP_U_MM (&f[1], this->uri.prop_video.size, SPA_POD_TYPE_RECTANGLE,
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.video, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, 3,
this->type.video_format.RGB,
this->type.video_format.RGB,
this->type.video_format.UYVY),
PROP_U_MM (&f[1], this->type.prop_video.size, SPA_POD_TYPE_RECTANGLE,
320, 240,
1, 1,
INT32_MAX, INT32_MAX),
PROP_U_MM (&f[1], this->uri.prop_video.framerate, SPA_POD_TYPE_FRACTION,
PROP_U_MM (&f[1], this->type.prop_video.framerate, SPA_POD_TYPE_FRACTION,
25, 1,
0, 1,
INT32_MAX, 1));
@ -542,10 +542,10 @@ spa_videotestsrc_node_port_set_format (SpaNode *node,
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
if (raw_info->format == this->uri.video_formats.RGB) {
if (raw_info->format == this->type.video_format.RGB) {
this->bpp = 3;
}
else if (raw_info->format == this->uri.video_formats.UYVY) {
else if (raw_info->format == this->type.video_format.UYVY) {
this->bpp = 2;
}
else
@ -560,15 +560,15 @@ spa_videotestsrc_node_port_set_format (SpaNode *node,
this->stride = SPA_ROUND_UP_N (this->bpp * raw_info->size.width, 4);
spa_pod_builder_init (&b, this->params_buffer, sizeof (this->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->stride * raw_info->size.height),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, this->stride),
PROP_U_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, this->stride * raw_info->size.height),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, this->stride),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, 32, 2, 32),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
this->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
this->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
this->info.extra = NULL;
@ -603,11 +603,11 @@ spa_videotestsrc_node_port_get_format (SpaNode *node,
spa_pod_builder_init (&b, this->format_buffer, sizeof (this->format_buffer));
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.video, this->uri.media_subtypes.raw,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &this->current_format.info.raw.framerate));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.video, this->type.media_subtype.raw,
PROP (&f[1], this->type.prop_video.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->type.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], this->type.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &this->current_format.info.raw.framerate));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
return SPA_RESULT_OK;
@ -909,9 +909,9 @@ spa_videotestsrc_get_interface (SpaHandle *handle,
this = (SpaVideoTestSrc *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else if (interface_id == this->uri.clock)
else if (interface_id == this->type.clock)
*interface = &this->clock;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -953,11 +953,11 @@ videotestsrc_init (const SpaHandleFactory *factory,
this = (SpaVideoTestSrc *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE_LOOP__DataLoop) == 0)
else if (strcmp (support[i].type, SPA_TYPE_LOOP__DataLoop) == 0)
this->data_loop = support[i].data;
}
if (this->map == NULL) {
@ -968,7 +968,7 @@ videotestsrc_init (const SpaHandleFactory *factory,
spa_log_error (this->log, "a data_loop is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = videotestsrc_node;
this->clock = videotestsrc_clock;

108
spa/plugins/volume/volume.c
View file

@ -21,7 +21,7 @@
#include <stddef.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/node.h>
#include <spa/list.h>
#include <spa/audio/format-utils.h>
@ -67,40 +67,40 @@ typedef struct {
uint32_t props;
uint32_t prop_volume;
uint32_t prop_mute;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaPropAudio prop_audio;
SpaAudioFormats audio_formats;
SpaEventNode event_node;
SpaCommandNode command_node;
SpaAllocParamBuffers alloc_param_buffers;
SpaAllocParamMetaEnable alloc_param_meta_enable;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropAudio prop_audio;
SpaTypeAudioFormat audio_format;
SpaTypeEventNode event_node;
SpaTypeCommandNode command_node;
SpaTypeAllocParamBuffers alloc_param_buffers;
SpaTypeAllocParamMetaEnable alloc_param_meta_enable;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->format = spa_id_map_get_id (map, SPA_TYPE__Format);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_volume = spa_id_map_get_id (map, SPA_TYPE_PROPS__volume);
uri->prop_mute = spa_id_map_get_id (map, SPA_TYPE_PROPS__mute);
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_prop_audio_map (map, &uri->prop_audio);
spa_audio_formats_map (map, &uri->audio_formats);
spa_event_node_map (map, &uri->event_node);
spa_command_node_map (map, &uri->command_node);
spa_alloc_param_buffers_map (map, &uri->alloc_param_buffers);
spa_alloc_param_meta_enable_map (map, &uri->alloc_param_meta_enable);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->format = spa_type_map_get_id (map, SPA_TYPE__Format);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_volume = spa_type_map_get_id (map, SPA_TYPE_PROPS__volume);
type->prop_mute = spa_type_map_get_id (map, SPA_TYPE_PROPS__mute);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_prop_audio_map (map, &type->prop_audio);
spa_type_audio_format_map (map, &type->audio_format);
spa_type_event_node_map (map, &type->event_node);
spa_type_command_node_map (map, &type->command_node);
spa_type_alloc_param_buffers_map (map, &type->alloc_param_buffers);
spa_type_alloc_param_meta_enable_map (map, &type->alloc_param_meta_enable);
}
struct _SpaVolume {
SpaHandle handle;
SpaNode node;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
uint8_t props_buffer[512];
@ -165,9 +165,9 @@ spa_volume_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVolume, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP_MM (&f[1], this->uri.prop_volume, SPA_POD_TYPE_DOUBLE, this->props.volume, 0.0, 10.0),
PROP (&f[1], this->uri.prop_mute, SPA_POD_TYPE_BOOL, this->props.mute));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP_MM (&f[1], this->type.prop_volume, SPA_POD_TYPE_DOUBLE, this->props.volume, 0.0, 10.0),
PROP (&f[1], this->type.prop_mute, SPA_POD_TYPE_BOOL, this->props.mute));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
@ -189,8 +189,8 @@ spa_volume_node_set_props (SpaNode *node,
reset_volume_props (&this->props);
} else {
spa_props_query (props,
this->uri.prop_volume, SPA_POD_TYPE_DOUBLE, &this->props.volume,
this->uri.prop_mute, SPA_POD_TYPE_BOOL, &this->props.mute,
this->type.prop_volume, SPA_POD_TYPE_DOUBLE, &this->props.volume,
this->type.prop_mute, SPA_POD_TYPE_BOOL, &this->props.mute,
0);
}
return SPA_RESULT_OK;
@ -207,10 +207,10 @@ spa_volume_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaVolume, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
update_state (this, SPA_NODE_STATE_PAUSED);
}
else
@ -322,14 +322,14 @@ next:
switch (index++) {
case 0:
spa_pod_builder_format (&b, &f[0], this->uri.format,
this->uri.media_types.audio, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_audio.format, SPA_POD_TYPE_URI, 3,
this->uri.audio_formats.S16,
this->uri.audio_formats.S16,
this->uri.audio_formats.S32),
PROP_U_MM (&f[1], this->uri.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->uri.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
spa_pod_builder_format (&b, &f[0], this->type.format,
this->type.media_type.audio, this->type.media_subtype.raw,
PROP_U_EN (&f[1], this->type.prop_audio.format, SPA_POD_TYPE_URI, 3,
this->type.audio_format.S16,
this->type.audio_format.S16,
this->type.audio_format.S32),
PROP_U_MM (&f[1], this->type.prop_audio.rate, SPA_POD_TYPE_INT, 44100, 1, INT32_MAX),
PROP_U_MM (&f[1], this->type.prop_audio.channels, SPA_POD_TYPE_INT, 2, 1, INT32_MAX));
break;
default:
@ -399,15 +399,15 @@ spa_volume_node_port_set_format (SpaNode *node,
port->info.params = port->params;
spa_pod_builder_init (&b, port->params_buffer, sizeof (port->params_buffer));
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_buffers.Buffers,
PROP (&f[1], this->uri.alloc_param_buffers.size, SPA_POD_TYPE_INT, 16),
PROP (&f[1], this->uri.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 16),
PROP_U_MM (&f[1], this->uri.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, MAX_BUFFERS, 2, MAX_BUFFERS),
PROP (&f[1], this->uri.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_buffers.Buffers,
PROP (&f[1], this->type.alloc_param_buffers.size, SPA_POD_TYPE_INT, 16),
PROP (&f[1], this->type.alloc_param_buffers.stride, SPA_POD_TYPE_INT, 16),
PROP_U_MM (&f[1], this->type.alloc_param_buffers.buffers, SPA_POD_TYPE_INT, MAX_BUFFERS, 2, MAX_BUFFERS),
PROP (&f[1], this->type.alloc_param_buffers.align, SPA_POD_TYPE_INT, 16));
port->params[0] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
spa_pod_builder_object (&b, &f[0], 0, this->uri.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->uri.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
spa_pod_builder_object (&b, &f[0], 0, this->type.alloc_param_meta_enable.MetaEnable,
PROP (&f[1], this->type.alloc_param_meta_enable.type, SPA_POD_TYPE_INT, SPA_META_TYPE_HEADER));
port->params[1] = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaAllocParam);
port->info.extra = NULL;
@ -662,7 +662,7 @@ find_free_buffer (SpaVolume *this, SpaVolumePort *port)
static void
release_buffer (SpaVolume *this, SpaBuffer *buffer)
{
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (this->uri.event_node.ReuseBuffer,
SpaEventNodeReuseBuffer rb = SPA_EVENT_NODE_REUSE_BUFFER_INIT (this->type.event_node.ReuseBuffer,
0, buffer->id);
this->event_cb (&this->node, (SpaEvent *)&rb, this->user_data);
}
@ -811,7 +811,7 @@ spa_volume_get_interface (SpaHandle *handle,
this = (SpaVolume *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -844,16 +844,16 @@ volume_init (const SpaHandleFactory *factory,
this = (SpaVolume *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = volume_node;
reset_volume_props (&this->props);

60
spa/plugins/xv/xv-sink.c
View file

@ -24,7 +24,7 @@
#include <linux/videodev2.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/log.h>
#include <spa/node.h>
#include <spa/video/format-utils.h>
@ -75,30 +75,30 @@ typedef struct {
uint32_t prop_device;
uint32_t prop_device_name;
uint32_t prop_device_fd;
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaCommandNode command_node;
} URI;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypeCommandNode command_node;
} Type;
static inline void
init_uri (URI *uri, SpaIDMap *map)
init_type (Type *type, SpaTypeMap *map)
{
uri->node = spa_id_map_get_id (map, SPA_TYPE__Node);
uri->props = spa_id_map_get_id (map, SPA_TYPE__Props);
uri->prop_device = spa_id_map_get_id (map, SPA_TYPE_PROPS__device);
uri->prop_device_name = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceName);
uri->prop_device_fd = spa_id_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_media_types_fill (&uri->media_types, map);
spa_media_subtypes_map (map, &uri->media_subtypes);
spa_command_node_map (map, &uri->command_node);
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
type->props = spa_type_map_get_id (map, SPA_TYPE__Props);
type->prop_device = spa_type_map_get_id (map, SPA_TYPE_PROPS__device);
type->prop_device_name = spa_type_map_get_id (map, SPA_TYPE_PROPS__deviceName);
type->prop_device_fd = spa_type_map_get_id (map, SPA_TYPE_PROPS__deviceFd);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_command_node_map (map, &type->command_node);
}
struct _SpaXvSink {
SpaHandle handle;
SpaNode node;
URI uri;
SpaIDMap *map;
Type type;
SpaTypeMap *map;
SpaLog *log;
uint8_t props_buffer[512];
@ -146,10 +146,10 @@ spa_xv_sink_node_get_props (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaXvSink, node);
spa_pod_builder_init (&b, this->props_buffer, sizeof (this->props_buffer));
spa_pod_builder_props (&b, &f[0], this->uri.props,
PROP (&f[1], this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP_R (&f[1], this->uri.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP_R (&f[1], this->uri.prop_device_fd, SPA_POD_TYPE_INT, this->props.device_fd));
spa_pod_builder_props (&b, &f[0], this->type.props,
PROP (&f[1], this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device)),
PROP_R (&f[1], this->type.prop_device_name, -SPA_POD_TYPE_STRING, this->props.device_name, sizeof (this->props.device_name)),
PROP_R (&f[1], this->type.prop_device_fd, SPA_POD_TYPE_INT, this->props.device_fd));
*props = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaProps);
return SPA_RESULT_OK;
@ -170,7 +170,7 @@ spa_xv_sink_node_set_props (SpaNode *node,
reset_xv_sink_props (&this->props);
} else {
spa_props_query (props,
this->uri.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
this->type.prop_device, -SPA_POD_TYPE_STRING, this->props.device, sizeof (this->props.device),
0);
}
return SPA_RESULT_OK;
@ -187,12 +187,12 @@ spa_xv_sink_node_send_command (SpaNode *node,
this = SPA_CONTAINER_OF (node, SpaXvSink, node);
if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Start) {
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
spa_xv_start (this);
update_state (this, SPA_NODE_STATE_STREAMING);
}
else if (SPA_COMMAND_TYPE (command) == this->uri.command_node.Pause) {
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
spa_xv_stop (this);
update_state (this, SPA_NODE_STATE_PAUSED);
@ -329,8 +329,8 @@ spa_xv_sink_node_port_set_format (SpaNode *node,
return SPA_RESULT_OK;
}
if (format->body.media_type.value == this->uri.media_types.video) {
if (format->body.media_subtype.value == this->uri.media_subtypes.raw) {
if (format->body.media_type.value == this->type.media_type.video) {
if (format->body.media_subtype.value == this->type.media_subtype.raw) {
if ((res = spa_format_video_parse (format, &info) < 0))
return res;
} else
@ -531,7 +531,7 @@ spa_xv_sink_get_interface (SpaHandle *handle,
this = (SpaXvSink *) handle;
if (interface_id == this->uri.node)
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
@ -564,16 +564,16 @@ xv_sink_init (const SpaHandleFactory *factory,
this = (SpaXvSink *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].uri, SPA_TYPE__IDMap) == 0)
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].uri, SPA_TYPE__Log) == 0)
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "an id-map is needed");
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_uri (&this->uri, this->map);
init_type (&this->type, this->map);
this->node = xvsink_node;
reset_xv_sink_props (&this->props);

6
spa/tests/test-mixer.c
View file

@ -365,13 +365,13 @@ main (int argc, char *argv[])
data.data_loop.update_item = NULL;
data.data_loop.remove_item = NULL;
data.support[0].uri = SPA_ID_MAP_URI;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_POLL__DataLoop;
data.support[1].uri = SPA_TYPE_LOOP__DataLoop;
data.support[1].data = &data.data_loop;
data.n_support = 2;
data.uri.node = spa_id_map_get_id (data.map, SPA_NODE_URI);
data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
if ((res = make_nodes (&data)) < 0) {
printf ("can't make nodes: %d\n", res);

115
spa/tests/test-props.c
View file

@ -23,7 +23,7 @@
#include <unistd.h>
#include <errno.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/log.h>
#include <spa/node.h>
#include <spa/loop.h>
@ -40,19 +40,19 @@
*/
spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
prop_video.format, SPA_PROP_TYPE_URI,
video_formats.I420
type.prop_video.format, SPA_PROP_TYPE_URI,
video_format.I420
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_ENUM, 2,
video_formats.I420,
video_formats.YUY2,
prop_video.size , SPA_PROP_TYPE_RECTANGLE,
video_format.I420,
video_format.YUY2,
type.prop_video.size , SPA_PROP_TYPE_RECTANGLE,
320, 240,
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_MIN_MAX,
1, 1,
INT32_MAX, INT32_MAX,
prop_video.framerate, SPA_PROP_TYPE_FRACTION, 25, 1,
type.prop_video.framerate, SPA_PROP_TYPE_FRACTION, 25, 1,
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_MIN_MAX,
0, 1,
@ -60,11 +60,23 @@ spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
0);
#endif
static uint32_t format_type;
static SpaMediaTypes media_types;
static SpaMediaSubtypes media_subtypes;
static SpaPropVideo prop_video;
static SpaVideoFormats video_formats;
static struct {
uint32_t format;
SpaTypeMediaType media_type;
SpaTypeMediaSubtype media_subtype;
SpaTypePropVideo prop_video;
SpaTypeVideoFormat video_format;
} type = { 0, };
static inline void
type_init (SpaTypeMap *map)
{
type.format = spa_type_map_get_id (map, SPA_TYPE__Format);
spa_type_media_type_map (map, &type.media_type);
spa_type_media_subtype_map (map, &type.media_subtype);
spa_type_prop_video_map (map, &type.prop_video);
spa_type_video_format_map (map, &type.video_format);
}
static void
do_static_struct (void)
@ -96,20 +108,20 @@ do_static_struct (void)
} props;
} test_format = {
{ { sizeof (test_format.props) + sizeof (SpaFormatBody), SPA_POD_TYPE_OBJECT },
{ { 0, format_type },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, media_types.video },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, media_subtypes.raw } },
{ { 0, type.format },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, type.media_type.video },
{ { sizeof (uint32_t), SPA_POD_TYPE_URI }, type.media_subtype.raw } },
}, {
{ { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ prop_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ type.prop_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (uint32_t), SPA_POD_TYPE_URI } }, },
{ video_formats.I420,
{ video_formats.I420, video_formats.YUY2 } }, 0,
{ type.video_format.I420,
{ type.video_format.I420, type.video_format.YUY2 } }, 0,
{ { sizeof (test_format.props.size_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ prop_video.size, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ type.prop_video.size, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaRectangle), SPA_POD_TYPE_RECTANGLE } }, },
{ { 320, 243 },
{ 1, 1 },
@ -117,7 +129,7 @@ do_static_struct (void)
{ { sizeof (test_format.props.framerate_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ prop_video.framerate, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ type.prop_video.framerate, SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (SpaFraction), SPA_POD_TYPE_FRACTION } }, },
{ { 25, 1 },
{ 0, 1 },
@ -133,8 +145,8 @@ do_static_struct (void)
SpaFraction frac = { 0, 0 };
match = spa_pod_contents_query (&test_format.fmt.pod, sizeof (SpaFormat),
prop_video.format, SPA_POD_TYPE_INT, &format,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &frac,
type.prop_video.format, SPA_POD_TYPE_INT, &format,
type.prop_video.framerate, SPA_POD_TYPE_FRACTION, &frac,
0);
printf ("%d %d %d %d\n", match, format, frac.num, frac.denom);
@ -149,30 +161,25 @@ main (int argc, char *argv[])
SpaPODFrame frame[4];
uint8_t buffer[1024];
SpaFormat *fmt;
SpaIDMap *map = spa_id_map_get_default();
format_type = spa_id_map_get_id (map, SPA_TYPE__Format);
spa_media_types_fill (&media_types, map);
spa_media_subtypes_map (map, &media_subtypes);
spa_prop_video_map (map, &prop_video);
spa_video_formats_map (map, &video_formats);
type_init (spa_type_map_get_default());
spa_pod_builder_init (&b, buffer, sizeof (buffer));
fmt = SPA_MEMBER (buffer, spa_pod_builder_push_format (&b, &frame[0], format_type,
media_types.video,
media_subtypes.raw), SpaFormat);
fmt = SPA_MEMBER (buffer, spa_pod_builder_push_format (&b, &frame[0], type.format,
type.media_type.video,
type.media_subtype.raw), SpaFormat);
spa_pod_builder_push_prop (&b, &frame[1],
prop_video.format,
type.prop_video.format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_uri (&b, video_formats.I420);
spa_pod_builder_uri (&b, video_formats.I420);
spa_pod_builder_uri (&b, video_formats.YUY2);
spa_pod_builder_uri (&b, type.video_format.I420);
spa_pod_builder_uri (&b, type.video_format.I420);
spa_pod_builder_uri (&b, type.video_format.YUY2);
spa_pod_builder_pop (&b, &frame[1]);
SpaRectangle size_min_max[] = { { 1, 1 }, { INT32_MAX, INT32_MAX } };
spa_pod_builder_push_prop (&b, &frame[1],
prop_video.size,
type.prop_video.size,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_rectangle (&b, 320, 240);
spa_pod_builder_raw (&b, size_min_max, sizeof(size_min_max));
@ -180,7 +187,7 @@ main (int argc, char *argv[])
SpaFraction rate_min_max[] = { { 0, 1 }, { INT32_MAX, 1 } };
spa_pod_builder_push_prop (&b, &frame[1],
prop_video.framerate,
type.prop_video.framerate,
SPA_POD_PROP_RANGE_MIN_MAX | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_fraction (&b, 25, 1);
spa_pod_builder_raw (&b, rate_min_max, sizeof(rate_min_max));
@ -192,18 +199,18 @@ main (int argc, char *argv[])
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_format (&b, &frame[0], format_type,
media_types.video, media_subtypes.raw,
spa_pod_builder_format (&b, &frame[0], type.format,
type.media_type.video, type.media_subtype.raw,
SPA_POD_TYPE_PROP, &frame[1],
prop_video.format, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_URI, 3,
video_formats.I420,
video_formats.I420,
video_formats.YUY2,
type.video_format.I420,
type.video_format.I420,
type.video_format.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.size, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.size, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_RECTANGLE, 3,
320, 241,
@ -211,7 +218,7 @@ main (int argc, char *argv[])
INT32_MAX, INT32_MAX,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_FRACTION, 3,
25, 1,
@ -226,19 +233,19 @@ main (int argc, char *argv[])
spa_pod_builder_init (&b, buffer, sizeof (buffer));
spa_pod_builder_add (&b,
SPA_POD_TYPE_OBJECT, &frame[0], 0, format_type,
SPA_POD_TYPE_URI, media_types.video,
SPA_POD_TYPE_URI, media_subtypes.raw,
SPA_POD_TYPE_OBJECT, &frame[0], 0, type.format,
SPA_POD_TYPE_URI, type.media_type.video,
SPA_POD_TYPE_URI, type.media_subtype.raw,
SPA_POD_TYPE_PROP, &frame[1],
prop_video.format, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_URI, 3,
video_formats.I420,
video_formats.I420,
video_formats.YUY2,
type.video_format.I420,
type.video_format.I420,
type.video_format.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.size, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.size, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_RECTANGLE, 3,
320, 242,
@ -246,7 +253,7 @@ main (int argc, char *argv[])
INT32_MAX, INT32_MAX,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
type.prop_video.framerate, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_MIN_MAX,
SPA_POD_TYPE_FRACTION, 3,
25, 1,

2
spa/tests/test-props2.c
View file

@ -28,7 +28,7 @@
#include <spa/pod-builder.h>
#include <spa/pod-iter.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/log.h>
#include <spa/video/format.h>
#include <lib/debug.h>

6
spa/tests/test-v4l2.c
View file

@ -465,13 +465,13 @@ main (int argc, char *argv[])
data.data_loop.update_item = do_update_item;
data.data_loop.remove_item = do_remove_item;
data.support[0].uri = SPA_ID_MAP_URI;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_POLL__DataLoop;
data.support[1].uri = SPA_TYPE_LOOP__DataLoop;
data.support[1].data = &data.data_loop;
data.n_support = 2;
data.uri.node = spa_id_map_get_id (data.map, SPA_NODE_URI);
data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
printf ("can't initialize SDL: %s\n", SDL_GetError ());

28
spa/tools/spa-inspect.c
View file

@ -23,7 +23,7 @@
#include <unistd.h>
#include <dlfcn.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/clock.h>
#include <spa/log.h>
#include <spa/node.h>
@ -34,14 +34,14 @@
typedef struct {
uint32_t node;
uint32_t clock;
} URI;
} Type;
typedef struct {
URI uri;
Type type;
SpaSupport support[4];
uint32_t n_support;
SpaIDMap *map;
SpaTypeMap *map;
SpaLog *log;
SpaLoop loop;
} AppData;
@ -143,16 +143,16 @@ inspect_factory (AppData *data, const SpaHandleFactory *factory)
printf ("can't enumerate interfaces: %d\n", res);
}
index++;
printf (" interface: '%s'\n", info->uri);
printf (" interface: '%s'\n", info->type);
interface_id = spa_id_map_get_id (data->map, info->uri);
interface_id = spa_type_map_get_id (data->map, info->type);
if ((res = spa_handle_get_interface (handle, interface_id, &interface)) < 0) {
printf ("can't get interface: %d\n", res);
continue;
}
if (interface_id == data->uri.node)
if (interface_id == data->type.node)
inspect_node (interface);
else
printf ("skipping unknown interface\n");
@ -189,25 +189,25 @@ main (int argc, char *argv[])
return -1;
}
data.map = spa_id_map_get_default();
data.map = spa_type_map_get_default();
data.log = NULL;
data.loop.size = sizeof (SpaLoop);
data.loop.add_source = do_add_source;
data.loop.update_source = do_update_source;
data.loop.remove_source = do_remove_source;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_TYPE__Log;
data.support[1].type = SPA_TYPE__Log;
data.support[1].data = data.log;
data.support[2].uri = SPA_TYPE_LOOP__MainLoop;
data.support[2].type = SPA_TYPE_LOOP__MainLoop;
data.support[2].data = &data.loop;
data.support[3].uri = SPA_TYPE_LOOP__DataLoop;
data.support[3].type = SPA_TYPE_LOOP__DataLoop;
data.support[3].data = &data.loop;
data.n_support = 4;
data.uri.node = spa_id_map_get_id (data.map, SPA_TYPE__Node);
data.uri.clock = spa_id_map_get_id (data.map, SPA_TYPE__Clock);
data.type.node = spa_type_map_get_id (data.map, SPA_TYPE__Node);
data.type.clock = spa_type_map_get_id (data.map, SPA_TYPE__Clock);
if ((handle = dlopen (argv[1], RTLD_NOW)) == NULL) {
printf ("can't load %s\n", argv[1]);

30
spa/tools/spa-monitor.c
View file

@ -26,20 +26,20 @@
#include <poll.h>
#include <spa/log.h>
#include <spa/id-map.h>
#include <spa/type-map.h>
#include <spa/monitor.h>
#include <spa/loop.h>
#include <lib/debug.h>
#include <lib/mapper.h>
typedef struct {
SpaMonitorTypes monitor_types;
} URI;
SpaTypeMonitor monitor;
} Type;
typedef struct {
URI uri;
Type type;
SpaIDMap *map;
SpaTypeMap *map;
SpaLog *log;
SpaLoop main_loop;
@ -68,15 +68,15 @@ on_monitor_event (SpaMonitor *monitor,
{
AppData *data = user_data;
if (SPA_EVENT_TYPE (event) == data->uri.monitor_types.Added) {
if (SPA_EVENT_TYPE (event) == data->type.monitor.Added) {
fprintf (stderr, "added:\n");
inspect_item ((SpaMonitorItem*)event);
}
else if (SPA_EVENT_TYPE (event) == data->uri.monitor_types.Removed) {
else if (SPA_EVENT_TYPE (event) == data->type.monitor.Removed) {
fprintf (stderr, "removed:\n");
inspect_item ((SpaMonitorItem*)event);
}
else if (SPA_EVENT_TYPE (event) == data->uri.monitor_types.Changed) {
else if (SPA_EVENT_TYPE (event) == data->type.monitor.Changed) {
fprintf (stderr, "changed:\n");
inspect_item ((SpaMonitorItem*)event);
}
@ -169,22 +169,22 @@ main (int argc, char *argv[])
SpaEnumHandleFactoryFunc enum_func;
uint32_t fidx;
data.map = spa_id_map_get_default ();
data.map = spa_type_map_get_default ();
data.log = NULL;
data.main_loop.size = sizeof (SpaLoop);
data.main_loop.add_source = do_add_source;
data.main_loop.update_source = do_update_source;
data.main_loop.remove_source = do_remove_source;
data.support[0].uri = SPA_TYPE__IDMap;
data.support[0].type = SPA_TYPE__TypeMap;
data.support[0].data = data.map;
data.support[1].uri = SPA_TYPE__Log;
data.support[1].type = SPA_TYPE__Log;
data.support[1].data = data.log;
data.support[2].uri = SPA_TYPE_LOOP__MainLoop;
data.support[2].type = SPA_TYPE_LOOP__MainLoop;
data.support[2].data = &data.main_loop;
data.n_support = 3;
spa_monitor_types_map (data.map, &data.uri.monitor_types);
spa_type_monitor_map (data.map, &data.type.monitor);
if (argc < 2) {
printf ("usage: %s <plugin.so>\n", argv[0]);
@ -219,7 +219,7 @@ main (int argc, char *argv[])
break;
}
if (!strcmp (info->uri, SPA_TYPE__Monitor)) {
if (!strcmp (info->type, SPA_TYPE__Monitor)) {
SpaHandle *handle;
void *interface;
@ -229,7 +229,7 @@ main (int argc, char *argv[])
continue;
}
if ((res = spa_handle_get_interface (handle, data.uri.monitor_types.Monitor, &interface)) < 0) {
if ((res = spa_handle_get_interface (handle, data.type.monitor.Monitor, &interface)) < 0) {
printf ("can't get interface: %d\n", res);
continue;
}