mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -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>