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

Remove dynamic types

Browse source 
Do not use dynamic types anymore. The reason is that it's difficult:

- to maintain a shared type database over a network.
- the extra overhead when translating between processes and for
  maintaining the translation tables.
- race conditions in translating in RT-threads, this is a problem
  because we want to make event streams.

We now have simple enums with types and extension points for all
types. This is also nicer to use in general.
We don't need the mapper anymore or pass strings around as types.
There is a parallel type info system to get more info about ids and
enums and their hierarchy. It can also be used for debugging.
This commit is contained in:
Wim Taymans 2018-08-23 17:47:57 +02:00
parent e6977fa178
commit fca3e1d85d
162 changed files with 5200 additions and 7461 deletions
Download patch file Download diff file Expand all files Collapse all files

50
spa/include/spa/param/audio/format-types.h Normal file
View file

@ -0,0 +1,50 @@
/* 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_PARAM_AUDIO_FORMAT_TYPES_H__
#define __SPA_PARAM_AUDIO_FORMAT_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/audio/format.h>
#include <spa/param/audio/raw-types.h>
#define SPA_TYPE__FormatAudio SPA_TYPE_FORMAT_BASE "Audio"
#define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE__FormatAudio ":"
static const struct spa_type_info spa_type_format_audio_ids[] = {
{ SPA_FORMAT_AUDIO_format, SPA_TYPE_FORMAT_AUDIO_BASE "format", SPA_POD_TYPE_INT,
spa_type_audio_format },
{ SPA_FORMAT_AUDIO_flags, SPA_TYPE_FORMAT_AUDIO_BASE "flags", SPA_POD_TYPE_INT,
spa_type_audio_flags },
{ SPA_FORMAT_AUDIO_layout, SPA_TYPE_FORMAT_AUDIO_BASE "layout", SPA_POD_TYPE_INT,
spa_type_audio_layout },
{ SPA_FORMAT_AUDIO_rate, SPA_TYPE_FORMAT_AUDIO_BASE "rate", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_AUDIO_channels, SPA_TYPE_FORMAT_AUDIO_BASE "channels", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_AUDIO_channelMask, SPA_TYPE_FORMAT_AUDIO_BASE "channelMask", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_AUDIO_FORMAT_TYPES_H */

49
spa/include/spa/param/audio/format-utils.h
View file

@ -24,43 +24,32 @@
extern "C" {
#endif
#include <spa/param/format-utils.h>
#include <spa/pod/parser.h>
#include <spa/param/audio/format.h>
#include <spa/param/audio/raw-utils.h>
struct spa_type_format_audio {
uint32_t format;
uint32_t flags;
uint32_t layout;
uint32_t rate;
uint32_t channels;
uint32_t channel_mask;
};
#if 0
#define SPA_TYPE_FORMAT__Audio SPA_TYPE_FORMAT_BASE "Audio"
#define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE_FORMAT__Audio ":"
static inline void
spa_type_format_audio_map(struct spa_type_map *map, struct spa_type_format_audio *type)
{
if (type->format == 0) {
type->format = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__format);
type->flags = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__flags);
type->layout = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__layout);
type->rate = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__rate);
type->channels = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__channels);
type->channel_mask = spa_type_map_get_id(map, SPA_TYPE_FORMAT_AUDIO__channelMask);
}
}
#define SPA_TYPE_FORMAT_AUDIO__format SPA_TYPE_FORMAT_AUDIO_BASE "format"
#define SPA_TYPE_FORMAT_AUDIO__flags SPA_TYPE_FORMAT_AUDIO_BASE "flags"
#define SPA_TYPE_FORMAT_AUDIO__layout SPA_TYPE_FORMAT_AUDIO_BASE "layout"
#define SPA_TYPE_FORMAT_AUDIO__rate SPA_TYPE_FORMAT_AUDIO_BASE "rate"
#define SPA_TYPE_FORMAT_AUDIO__channels SPA_TYPE_FORMAT_AUDIO_BASE "channels"
#define SPA_TYPE_FORMAT_AUDIO__channelMask SPA_TYPE_FORMAT_AUDIO_BASE "channel-mask"
#endif
static inline int
spa_format_audio_raw_parse(const struct spa_pod *format,
struct spa_audio_info_raw *info, struct spa_type_format_audio *type)
spa_format_audio_raw_parse(const struct spa_pod *format, struct spa_audio_info_raw *info)
{
return spa_pod_object_parse(format,
":",type->format, "I", &info->format,
":",type->layout, "i", &info->layout,
":",type->rate, "i", &info->rate,
":",type->channels, "i", &info->channels,
":",type->flags, "?i", &info->flags,
":",type->channel_mask, "?i", &info->channel_mask, NULL);
":", SPA_FORMAT_AUDIO_format, "I", &info->format,
":", SPA_FORMAT_AUDIO_layout, "i", &info->layout,
":", SPA_FORMAT_AUDIO_rate, "i", &info->rate,
":", SPA_FORMAT_AUDIO_channels, "i", &info->channels,
":", SPA_FORMAT_AUDIO_flags, "?i", &info->flags,
":", SPA_FORMAT_AUDIO_channelMask, "?i", &info->channel_mask, NULL);
}
#ifdef __cplusplus

18
spa/include/spa/param/audio/format.h
View file

@ -27,15 +27,15 @@ extern "C" {
#include <spa/param/format.h>
#include <spa/param/audio/raw.h>
#define SPA_TYPE_FORMAT__Audio SPA_TYPE_FORMAT_BASE "Audio"
#define SPA_TYPE_FORMAT_AUDIO_BASE SPA_TYPE_FORMAT__Audio ":"
#define SPA_TYPE_FORMAT_AUDIO__format SPA_TYPE_FORMAT_AUDIO_BASE "format"
#define SPA_TYPE_FORMAT_AUDIO__flags SPA_TYPE_FORMAT_AUDIO_BASE "flags"
#define SPA_TYPE_FORMAT_AUDIO__layout SPA_TYPE_FORMAT_AUDIO_BASE "layout"
#define SPA_TYPE_FORMAT_AUDIO__rate SPA_TYPE_FORMAT_AUDIO_BASE "rate"
#define SPA_TYPE_FORMAT_AUDIO__channels SPA_TYPE_FORMAT_AUDIO_BASE "channels"
#define SPA_TYPE_FORMAT_AUDIO__channelMask SPA_TYPE_FORMAT_AUDIO_BASE "channel-mask"
/** properties for audio SPA_ID_OBJECT_Format */
enum spa_format_audio {
SPA_FORMAT_AUDIO_format,
SPA_FORMAT_AUDIO_flags,
SPA_FORMAT_AUDIO_layout,
SPA_FORMAT_AUDIO_rate,
SPA_FORMAT_AUDIO_channels,
SPA_FORMAT_AUDIO_channelMask,
};
struct spa_audio_info {
uint32_t media_type;

90
spa/include/spa/param/audio/raw-types.h Normal file
View file

@ -0,0 +1,90 @@
/* 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_AUDIO_RAW_TYPES_H__
#define __SPA_AUDIO_RAW_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/audio/raw.h>
#define SPA_TYPE__AudioFormat SPA_TYPE_ENUM_BASE "AudioFormat"
#define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE__AudioFormat ":"
static const struct spa_type_info spa_type_audio_format[] = {
{ SPA_AUDIO_FORMAT_UNKNOWN, SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_ENCODED, SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S8, SPA_TYPE_AUDIO_FORMAT_BASE "S8", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U8, SPA_TYPE_AUDIO_FORMAT_BASE "U8", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S16LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S16BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U16_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U16LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U16_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U16BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24_32BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U24_32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U24_32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24_32BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S32LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S32BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U32LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U32BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S24LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S24BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U24_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U24LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U24_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U24BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S20LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S20BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U20_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U20LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U20_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U20BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "S18LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_S18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "S18BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U18_LE, SPA_TYPE_AUDIO_FORMAT_BASE "U18LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_U18_BE, SPA_TYPE_AUDIO_FORMAT_BASE "U18BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_F32_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F32LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_F32_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F32BE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_F64_LE, SPA_TYPE_AUDIO_FORMAT_BASE "F64LE", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FORMAT_F64_BE, SPA_TYPE_AUDIO_FORMAT_BASE "F64BE", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#define SPA_TYPE__AudioFlags SPA_TYPE_FLAGS_BASE "AudioFlags"
#define SPA_TYPE_AUDIO_FLAGS_BASE SPA_TYPE__AudioFlags ":"
static const struct spa_type_info spa_type_audio_flags[] = {
{ SPA_AUDIO_FLAG_NONE, SPA_TYPE_AUDIO_FLAGS_BASE "none", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_FLAG_UNPOSITIONED, SPA_TYPE_AUDIO_FLAGS_BASE "unpositioned", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#define SPA_TYPE__AudioLayout SPA_TYPE_ENUM_BASE "AudioLayout"
#define SPA_TYPE_AUDIO_ENUM_BASE SPA_TYPE__AudioLayout ":"
static const struct spa_type_info spa_type_audio_layout[] = {
{ SPA_AUDIO_LAYOUT_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "interleaved", SPA_POD_TYPE_INT, },
{ SPA_AUDIO_LAYOUT_NON_INTERLEAVED, SPA_TYPE_AUDIO_ENUM_BASE "non-interleaved", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_AUDIO_RAW_TYPES_H__ */

119
spa/include/spa/param/audio/raw-utils.h
View file

@ -1,119 +0,0 @@
/* 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_AUDIO_RAW_UTILS_H__
#define __SPA_AUDIO_RAW_UTILS_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/support/type-map.h>
#include <spa/param/audio/raw.h>
#if __BYTE_ORDER == __BIG_ENDIAN
#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_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
struct spa_type_audio_format {
uint32_t UNKNOWN;
uint32_t ENCODED;
uint32_t S8;
uint32_t U8;
uint32_t S16;
uint32_t U16;
uint32_t S24_32;
uint32_t U24_32;
uint32_t S32;
uint32_t U32;
uint32_t S24;
uint32_t U24;
uint32_t S20;
uint32_t U20;
uint32_t S18;
uint32_t U18;
uint32_t F32;
uint32_t F64;
uint32_t S16_OE;
uint32_t U16_OE;
uint32_t S24_32_OE;
uint32_t U24_32_OE;
uint32_t S32_OE;
uint32_t U32_OE;
uint32_t S24_OE;
uint32_t U24_OE;
uint32_t S20_OE;
uint32_t U20_OE;
uint32_t S18_OE;
uint32_t U18_OE;
uint32_t F32_OE;
uint32_t F64_OE;
};
static inline void
spa_type_audio_format_map(struct spa_type_map *map, struct spa_type_audio_format *type)
{
if (type->ENCODED == 0) {
type->UNKNOWN = 0;
type->ENCODED = spa_type_map_get_id(map, SPA_TYPE_AUDIO_FORMAT__ENCODED);
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);
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"));
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"));
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_AUDIO_RAW_UTILS_H__ */

129
spa/include/spa/param/audio/raw.h
View file

@ -26,41 +26,100 @@ extern "C" {
#include <endian.h>
#define SPA_TYPE__AudioFormat SPA_TYPE_ENUM_BASE "AudioFormat"
#define SPA_TYPE_AUDIO_FORMAT_BASE SPA_TYPE__AudioFormat ":"
enum spa_audio_format {
SPA_AUDIO_FORMAT_UNKNOWN,
SPA_AUDIO_FORMAT_ENCODED,
SPA_AUDIO_FORMAT_S8,
SPA_AUDIO_FORMAT_U8,
SPA_AUDIO_FORMAT_S16_LE,
SPA_AUDIO_FORMAT_S16_BE,
SPA_AUDIO_FORMAT_U16_LE,
SPA_AUDIO_FORMAT_U16_BE,
SPA_AUDIO_FORMAT_S24_32_LE,
SPA_AUDIO_FORMAT_S24_32_BE,
SPA_AUDIO_FORMAT_U24_32_LE,
SPA_AUDIO_FORMAT_U24_32_BE,
SPA_AUDIO_FORMAT_S32_LE,
SPA_AUDIO_FORMAT_S32_BE,
SPA_AUDIO_FORMAT_U32_LE,
SPA_AUDIO_FORMAT_U32_BE,
SPA_AUDIO_FORMAT_S24_LE,
SPA_AUDIO_FORMAT_S24_BE,
SPA_AUDIO_FORMAT_U24_LE,
SPA_AUDIO_FORMAT_U24_BE,
SPA_AUDIO_FORMAT_S20_LE,
SPA_AUDIO_FORMAT_S20_BE,
SPA_AUDIO_FORMAT_U20_LE,
SPA_AUDIO_FORMAT_U20_BE,
SPA_AUDIO_FORMAT_S18_LE,
SPA_AUDIO_FORMAT_S18_BE,
SPA_AUDIO_FORMAT_U18_LE,
SPA_AUDIO_FORMAT_U18_BE,
SPA_AUDIO_FORMAT_F32_LE,
SPA_AUDIO_FORMAT_F32_BE,
SPA_AUDIO_FORMAT_F64_LE,
SPA_AUDIO_FORMAT_F64_BE,
#define SPA_TYPE_AUDIO_FORMAT__UNKNOWN SPA_TYPE_AUDIO_FORMAT_BASE "UNKNOWN"
#define SPA_TYPE_AUDIO_FORMAT__ENCODED SPA_TYPE_AUDIO_FORMAT_BASE "ENCODED"
#define SPA_TYPE_AUDIO_FORMAT__S8 SPA_TYPE_AUDIO_FORMAT_BASE "S8"
#define SPA_TYPE_AUDIO_FORMAT__U8 SPA_TYPE_AUDIO_FORMAT_BASE "U8"
#define SPA_TYPE_AUDIO_FORMAT__S16LE SPA_TYPE_AUDIO_FORMAT_BASE "S16LE"
#define SPA_TYPE_AUDIO_FORMAT__S16BE SPA_TYPE_AUDIO_FORMAT_BASE "S16BE"
#define SPA_TYPE_AUDIO_FORMAT__U16LE SPA_TYPE_AUDIO_FORMAT_BASE "U16LE"
#define SPA_TYPE_AUDIO_FORMAT__U16BE SPA_TYPE_AUDIO_FORMAT_BASE "U16BE"
#define SPA_TYPE_AUDIO_FORMAT__S24_32LE SPA_TYPE_AUDIO_FORMAT_BASE "S24_32LE"
#define SPA_TYPE_AUDIO_FORMAT__S24_32BE SPA_TYPE_AUDIO_FORMAT_BASE "S24_32BE"
#define SPA_TYPE_AUDIO_FORMAT__U24_32LE SPA_TYPE_AUDIO_FORMAT_BASE "U24_32LE"
#define SPA_TYPE_AUDIO_FORMAT__U24_32BE SPA_TYPE_AUDIO_FORMAT_BASE "U24_32BE"
#define SPA_TYPE_AUDIO_FORMAT__S32LE SPA_TYPE_AUDIO_FORMAT_BASE "S32LE"
#define SPA_TYPE_AUDIO_FORMAT__S32BE SPA_TYPE_AUDIO_FORMAT_BASE "S32BE"
#define SPA_TYPE_AUDIO_FORMAT__U32LE SPA_TYPE_AUDIO_FORMAT_BASE "U32LE"
#define SPA_TYPE_AUDIO_FORMAT__U32BE SPA_TYPE_AUDIO_FORMAT_BASE "U32BE"
#define SPA_TYPE_AUDIO_FORMAT__S24LE SPA_TYPE_AUDIO_FORMAT_BASE "S24LE"
#define SPA_TYPE_AUDIO_FORMAT__S24BE SPA_TYPE_AUDIO_FORMAT_BASE "S24BE"
#define SPA_TYPE_AUDIO_FORMAT__U24LE SPA_TYPE_AUDIO_FORMAT_BASE "U24LE"
#define SPA_TYPE_AUDIO_FORMAT__U24BE SPA_TYPE_AUDIO_FORMAT_BASE "U24BE"
#define SPA_TYPE_AUDIO_FORMAT__S20LE SPA_TYPE_AUDIO_FORMAT_BASE "S20LE"
#define SPA_TYPE_AUDIO_FORMAT__S20BE SPA_TYPE_AUDIO_FORMAT_BASE "S20BE"
#define SPA_TYPE_AUDIO_FORMAT__U20LE SPA_TYPE_AUDIO_FORMAT_BASE "U20LE"
#define SPA_TYPE_AUDIO_FORMAT__U20BE SPA_TYPE_AUDIO_FORMAT_BASE "U20BE"
#define SPA_TYPE_AUDIO_FORMAT__S18LE SPA_TYPE_AUDIO_FORMAT_BASE "S18LE"
#define SPA_TYPE_AUDIO_FORMAT__S18BE SPA_TYPE_AUDIO_FORMAT_BASE "S18BE"
#define SPA_TYPE_AUDIO_FORMAT__U18LE SPA_TYPE_AUDIO_FORMAT_BASE "U18LE"
#define SPA_TYPE_AUDIO_FORMAT__U18BE SPA_TYPE_AUDIO_FORMAT_BASE "U18BE"
#define SPA_TYPE_AUDIO_FORMAT__F32LE SPA_TYPE_AUDIO_FORMAT_BASE "F32LE"
#define SPA_TYPE_AUDIO_FORMAT__F32BE SPA_TYPE_AUDIO_FORMAT_BASE "F32BE"
#define SPA_TYPE_AUDIO_FORMAT__F64LE SPA_TYPE_AUDIO_FORMAT_BASE "F64LE"
#define SPA_TYPE_AUDIO_FORMAT__F64BE SPA_TYPE_AUDIO_FORMAT_BASE "F64BE"
#if __BYTE_ORDER == __BIG_ENDIAN
SPA_AUDIO_FORMAT_S16 = SPA_AUDIO_FORMAT_S16_BE,
SPA_AUDIO_FORMAT_U16 = SPA_AUDIO_FORMAT_U16_BE,
SPA_AUDIO_FORMAT_S24_32 = SPA_AUDIO_FORMAT_S24_32_BE,
SPA_AUDIO_FORMAT_U24_32 = SPA_AUDIO_FORMAT_U24_32_BE,
SPA_AUDIO_FORMAT_S32 = SPA_AUDIO_FORMAT_S32_BE,
SPA_AUDIO_FORMAT_U32 = SPA_AUDIO_FORMAT_U32_BE,
SPA_AUDIO_FORMAT_S24 = SPA_AUDIO_FORMAT_S24_BE,
SPA_AUDIO_FORMAT_U24 = SPA_AUDIO_FORMAT_U24_BE,
SPA_AUDIO_FORMAT_S20 = SPA_AUDIO_FORMAT_S20_BE,
SPA_AUDIO_FORMAT_U20 = SPA_AUDIO_FORMAT_U20_BE,
SPA_AUDIO_FORMAT_S18 = SPA_AUDIO_FORMAT_S18_BE,
SPA_AUDIO_FORMAT_U18 = SPA_AUDIO_FORMAT_U18_BE,
SPA_AUDIO_FORMAT_F32 = SPA_AUDIO_FORMAT_F32_BE,
SPA_AUDIO_FORMAT_F64 = SPA_AUDIO_FORMAT_F64_BE,
SPA_AUDIO_FORMAT_S16_OE = SPA_AUDIO_FORMAT_S16_LE,
SPA_AUDIO_FORMAT_U16_OE = SPA_AUDIO_FORMAT_U16_LE,
SPA_AUDIO_FORMAT_S24_32_OE = SPA_AUDIO_FORMAT_S24_32_LE,
SPA_AUDIO_FORMAT_U24_32_OE = SPA_AUDIO_FORMAT_U24_32_LE,
SPA_AUDIO_FORMAT_S32_OE = SPA_AUDIO_FORMAT_S32_LE,
SPA_AUDIO_FORMAT_U32_OE = SPA_AUDIO_FORMAT_U32_LE,
SPA_AUDIO_FORMAT_S24_OE = SPA_AUDIO_FORMAT_S24_LE,
SPA_AUDIO_FORMAT_U24_OE = SPA_AUDIO_FORMAT_U24_LE,
SPA_AUDIO_FORMAT_S20_OE = SPA_AUDIO_FORMAT_S20_LE,
SPA_AUDIO_FORMAT_U20_OE = SPA_AUDIO_FORMAT_U20_LE,
SPA_AUDIO_FORMAT_S18_OE = SPA_AUDIO_FORMAT_S18_LE,
SPA_AUDIO_FORMAT_U18_OE = SPA_AUDIO_FORMAT_U18_LE,
SPA_AUDIO_FORMAT_F32_OE = SPA_AUDIO_FORMAT_F32_LE,
SPA_AUDIO_FORMAT_F64_OE = SPA_AUDIO_FORMAT_F64_LE,
#elif __BYTE_ORDER == __LITTLE_ENDIAN
SPA_AUDIO_FORMAT_S16 = SPA_AUDIO_FORMAT_S16_LE,
SPA_AUDIO_FORMAT_U16 = SPA_AUDIO_FORMAT_U16_LE,
SPA_AUDIO_FORMAT_S24_32 = SPA_AUDIO_FORMAT_S24_32_LE,
SPA_AUDIO_FORMAT_U24_32 = SPA_AUDIO_FORMAT_U24_32_LE,
SPA_AUDIO_FORMAT_S32 = SPA_AUDIO_FORMAT_S32_LE,
SPA_AUDIO_FORMAT_U32 = SPA_AUDIO_FORMAT_U32_LE,
SPA_AUDIO_FORMAT_S24 = SPA_AUDIO_FORMAT_S24_LE,
SPA_AUDIO_FORMAT_U24 = SPA_AUDIO_FORMAT_U24_LE,
SPA_AUDIO_FORMAT_S20 = SPA_AUDIO_FORMAT_S20_LE,
SPA_AUDIO_FORMAT_U20 = SPA_AUDIO_FORMAT_U20_LE,
SPA_AUDIO_FORMAT_S18 = SPA_AUDIO_FORMAT_S18_LE,
SPA_AUDIO_FORMAT_U18 = SPA_AUDIO_FORMAT_U18_LE,
SPA_AUDIO_FORMAT_F32 = SPA_AUDIO_FORMAT_F32_LE,
SPA_AUDIO_FORMAT_F64 = SPA_AUDIO_FORMAT_F64_LE,
SPA_AUDIO_FORMAT_S16_OE = SPA_AUDIO_FORMAT_S16_BE,
SPA_AUDIO_FORMAT_U16_OE = SPA_AUDIO_FORMAT_U16_BE,
SPA_AUDIO_FORMAT_S24_32_OE = SPA_AUDIO_FORMAT_S24_32_BE,
SPA_AUDIO_FORMAT_U24_32_OE = SPA_AUDIO_FORMAT_U24_32_BE,
SPA_AUDIO_FORMAT_S32_OE = SPA_AUDIO_FORMAT_S32_BE,
SPA_AUDIO_FORMAT_U32_OE = SPA_AUDIO_FORMAT_U32_BE,
SPA_AUDIO_FORMAT_S24_OE = SPA_AUDIO_FORMAT_S24_BE,
SPA_AUDIO_FORMAT_U24_OE = SPA_AUDIO_FORMAT_U24_BE,
SPA_AUDIO_FORMAT_S20_OE = SPA_AUDIO_FORMAT_S20_BE,
SPA_AUDIO_FORMAT_U20_OE = SPA_AUDIO_FORMAT_U20_BE,
SPA_AUDIO_FORMAT_S18_OE = SPA_AUDIO_FORMAT_S18_BE,
SPA_AUDIO_FORMAT_U18_OE = SPA_AUDIO_FORMAT_U18_BE,
SPA_AUDIO_FORMAT_F32_OE = SPA_AUDIO_FORMAT_F32_BE,
SPA_AUDIO_FORMAT_F64_OE = SPA_AUDIO_FORMAT_F64_BE,
#endif
};
/** Extra audio flags */
enum spa_audio_flags {
@ -77,7 +136,7 @@ enum spa_audio_layout {
/** Audio information description */
struct spa_audio_info_raw {
uint32_t format; /*< format, one of SPA_TYPE__AudioFormat */
enum spa_audio_format format; /*< format, one of enum spa_audio_format */
enum spa_audio_flags flags; /*< extra flags */
enum spa_audio_layout layout; /*< sample layout */
uint32_t rate; /*< sample rate */

58
spa/include/spa/param/buffers-types.h Normal file
View file

@ -0,0 +1,58 @@
/* 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_PARAM_BUFFERS_TYPES_H__
#define __SPA_PARAM_BUFFERS_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/param/param-types.h>
#define SPA_TYPE_PARAM__Buffers SPA_TYPE_PARAM_BASE "Buffers"
#define SPA_TYPE_PARAM_BUFFERS_BASE SPA_TYPE_PARAM__Buffers ":"
#define SPA_TYPE_PARAM_BUFFERS__buffers SPA_TYPE_PARAM_BUFFERS_BASE "buffers"
#define SPA_TYPE_PARAM_BUFFERS__blocks SPA_TYPE_PARAM_BUFFERS_BASE "blocks"
#define SPA_TYPE_PARAM__BlockInfo SPA_TYPE_PARAM_BASE "BlockInfo"
#define SPA_TYPE_PARAM_BLOCK_INFO_BASE SPA_TYPE_PARAM__BlockInfo ":"
static const struct spa_type_info spa_type_param_buffers_items[] = {
{ SPA_PARAM_BUFFERS_buffers, SPA_TYPE_PARAM_BUFFERS_BASE "buffers", SPA_POD_TYPE_INT, },
{ SPA_PARAM_BUFFERS_blocks, SPA_TYPE_PARAM_BUFFERS_BASE "blocks", SPA_POD_TYPE_INT, },
{ SPA_PARAM_BUFFERS_size, SPA_TYPE_PARAM_BLOCK_INFO_BASE "size", SPA_POD_TYPE_INT, },
{ SPA_PARAM_BUFFERS_stride, SPA_TYPE_PARAM_BLOCK_INFO_BASE "stride", SPA_POD_TYPE_INT, },
{ SPA_PARAM_BUFFERS_align, SPA_TYPE_PARAM_BLOCK_INFO_BASE "align", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
static const struct spa_type_info spa_type_param_buffers[] = {
{ SPA_ID_OBJECT_ParamBuffers, SPA_TYPE_PARAM__Buffers, SPA_POD_TYPE_OBJECT,
spa_type_param_buffers_items },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_BUFFERS_TYPES_H__ */

45
spa/include/spa/param/buffers.h
View file

@ -25,47 +25,16 @@ extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
#define SPA_TYPE_PARAM__Buffers SPA_TYPE_PARAM_BASE "Buffers"
#define SPA_TYPE_PARAM_BUFFERS_BASE SPA_TYPE_PARAM__Buffers ":"
#define SPA_TYPE_PARAM_BUFFERS__buffers SPA_TYPE_PARAM_BUFFERS_BASE "buffers"
#define SPA_TYPE_PARAM_BUFFERS__blocks SPA_TYPE_PARAM_BUFFERS_BASE "blocks"
#define SPA_TYPE_PARAM__BlockInfo SPA_TYPE_PARAM_BASE "BlockInfo"
#define SPA_TYPE_PARAM_BLOCK_INFO_BASE SPA_TYPE_PARAM__BlockInfo ":"
#define SPA_TYPE_PARAM_BLOCK_INFO__size SPA_TYPE_PARAM_BLOCK_INFO_BASE "size"
#define SPA_TYPE_PARAM_BLOCK_INFO__stride SPA_TYPE_PARAM_BLOCK_INFO_BASE "stride"
#define SPA_TYPE_PARAM_BLOCK_INFO__align SPA_TYPE_PARAM_BLOCK_INFO_BASE "align"
struct spa_type_param_buffers {
uint32_t Buffers;
uint32_t buffers;
uint32_t blocks;
uint32_t BlockInfo;
uint32_t size;
uint32_t stride;
uint32_t align;
/** properties for SPA_ID_OBJECT_ParamBuffers */
enum spa_param_buffers {
SPA_PARAM_BUFFERS_buffers, /**< number of buffers */
SPA_PARAM_BUFFERS_blocks, /**< number of data blocks per buffer */
SPA_PARAM_BUFFERS_size, /**< size of a data block memory */
SPA_PARAM_BUFFERS_stride, /**< stride of data block memory */
SPA_PARAM_BUFFERS_align, /**< alignment of data block memory */
};
static inline void
spa_type_param_buffers_map(struct spa_type_map *map,
struct spa_type_param_buffers *type)
{
if (type->Buffers == 0) {
type->Buffers = spa_type_map_get_id(map, SPA_TYPE_PARAM__Buffers);
type->buffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_BUFFERS__buffers);
type->blocks = spa_type_map_get_id(map, SPA_TYPE_PARAM_BUFFERS__blocks);
type->BlockInfo = spa_type_map_get_id(map, SPA_TYPE_PARAM__BlockInfo);
type->size = spa_type_map_get_id(map, SPA_TYPE_PARAM_BLOCK_INFO__size);
type->stride = spa_type_map_get_id(map, SPA_TYPE_PARAM_BLOCK_INFO__stride);
type->align = spa_type_map_get_id(map, SPA_TYPE_PARAM_BLOCK_INFO__align);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif

109
spa/include/spa/param/format-types.h Normal file
View file

@ -0,0 +1,109 @@
/* 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_PARAM_FORMAT_TYPES_H__
#define __SPA_PARAM_FORMAT_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/format.h>
#include <spa/param/param-types.h>
#define SPA_TYPE__Format SPA_TYPE_PARAM_BASE "Format"
#define SPA_TYPE_FORMAT_BASE SPA_TYPE__Format ":"
#define SPA_TYPE__MediaType SPA_TYPE_ENUM_BASE "MediaType"
#define SPA_TYPE_MEDIA_TYPE_BASE SPA_TYPE__MediaType ":"
#include <spa/param/audio/format-types.h>
#include <spa/param/video/format-types.h>
static const struct spa_type_info spa_type_media_type[] = {
{ SPA_MEDIA_TYPE_audio, SPA_TYPE_MEDIA_TYPE_BASE "audio", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_TYPE_video, SPA_TYPE_MEDIA_TYPE_BASE "video", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_TYPE_image, SPA_TYPE_MEDIA_TYPE_BASE "image", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_TYPE_binary, SPA_TYPE_MEDIA_TYPE_BASE "binary", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_TYPE_stream, SPA_TYPE_MEDIA_TYPE_BASE "stream", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#define SPA_TYPE__MediaSubtype SPA_TYPE_ENUM_BASE "MediaSubtype"
#define SPA_TYPE_MEDIA_SUBTYPE_BASE SPA_TYPE__MediaSubtype ":"
static const struct spa_type_info spa_type_media_subtype[] = {
/* generic subtypes */
{ SPA_MEDIA_SUBTYPE_raw, SPA_TYPE_MEDIA_SUBTYPE_BASE "raw", SPA_POD_TYPE_INT, },
/* audio subtypes */
{ SPA_MEDIA_SUBTYPE_mp3, SPA_TYPE_MEDIA_SUBTYPE_BASE "mp3", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_aac, SPA_TYPE_MEDIA_SUBTYPE_BASE "aac", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_vorbis, SPA_TYPE_MEDIA_SUBTYPE_BASE "vorbis", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_wma, SPA_TYPE_MEDIA_SUBTYPE_BASE "wma", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_ra, SPA_TYPE_MEDIA_SUBTYPE_BASE "ra", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_sbc, SPA_TYPE_MEDIA_SUBTYPE_BASE "sbc", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_adpcm, SPA_TYPE_MEDIA_SUBTYPE_BASE "adpcm", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_g723, SPA_TYPE_MEDIA_SUBTYPE_BASE "g723", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_g726, SPA_TYPE_MEDIA_SUBTYPE_BASE "g726", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_g729, SPA_TYPE_MEDIA_SUBTYPE_BASE "g729", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_amr, SPA_TYPE_MEDIA_SUBTYPE_BASE "amr", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_gsm, SPA_TYPE_MEDIA_SUBTYPE_BASE "gsm", SPA_POD_TYPE_INT, },
/* video subtypes */
{ SPA_MEDIA_SUBTYPE_h264, SPA_TYPE_MEDIA_SUBTYPE_BASE "h264", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_mjpg, SPA_TYPE_MEDIA_SUBTYPE_BASE "mjpg", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_dv, SPA_TYPE_MEDIA_SUBTYPE_BASE "dv", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_mpegts, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpegts", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_h263, SPA_TYPE_MEDIA_SUBTYPE_BASE "h263", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_mpeg1, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg1", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_mpeg2, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg2", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_mpeg4, SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg4", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_xvid, SPA_TYPE_MEDIA_SUBTYPE_BASE "xvid", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_vc1, SPA_TYPE_MEDIA_SUBTYPE_BASE "vc1", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_vp8, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp8", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_vp9, SPA_TYPE_MEDIA_SUBTYPE_BASE "vp9", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_jpeg, SPA_TYPE_MEDIA_SUBTYPE_BASE "jpeg", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_bayer, SPA_TYPE_MEDIA_SUBTYPE_BASE "bayer", SPA_POD_TYPE_INT, },
{ SPA_MEDIA_SUBTYPE_midi, SPA_TYPE_MEDIA_SUBTYPE_BASE "midi", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
static const struct spa_type_info spa_type_format[] = {
{ SPA_ID_OBJECT_Format, SPA_TYPE__Format, SPA_POD_TYPE_OBJECT, },
{ 0, NULL, },
};
static inline const struct spa_type_info *
spa_type_format_get_ids(uint32_t media_type, uint32_t media_subtype)
{
switch (media_type) {
case SPA_MEDIA_TYPE_audio:
return spa_type_format_audio_ids;
case SPA_MEDIA_TYPE_video:
return spa_type_format_video_ids;
default:
return NULL;
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_FORMAT_TYPES_H__ */

145
spa/include/spa/param/format-utils.h
View file

@ -1,145 +0,0 @@
/* 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_PARAM_FORMAT_UTILS_H__
#define __SPA_PARAM_FORMAT_UTILS_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
#include <spa/param/format.h>
#include <spa/pod/parser.h>
#include <spa/support/type-map.h>
struct spa_type_media_type {
uint32_t audio;
uint32_t video;
uint32_t image;
uint32_t binary;
uint32_t stream;
};
static inline void
spa_type_media_type_map(struct spa_type_map *map, struct spa_type_media_type *type)
{
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);
type->binary = spa_type_map_get_id(map, SPA_TYPE_MEDIA_TYPE__binary);
type->stream = spa_type_map_get_id(map, SPA_TYPE_MEDIA_TYPE__stream);
}
}
struct spa_type_media_subtype {
uint32_t raw;
};
static inline void
spa_type_media_subtype_map(struct spa_type_map *map, struct spa_type_media_subtype *type)
{
if (type->raw == 0) {
type->raw = spa_type_map_get_id(map, SPA_TYPE_MEDIA_SUBTYPE__raw);
}
}
struct spa_type_media_subtype_video {
uint32_t h264;
uint32_t mjpg;
uint32_t dv;
uint32_t mpegts;
uint32_t h263;
uint32_t mpeg1;
uint32_t mpeg2;
uint32_t mpeg4;
uint32_t xvid;
uint32_t vc1;
uint32_t vp8;
uint32_t vp9;
uint32_t jpeg;
uint32_t bayer;
};
static inline void
spa_type_media_subtype_video_map(struct spa_type_map *map,
struct spa_type_media_subtype_video *type)
{
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);
}
}
struct spa_type_media_subtype_audio {
uint32_t mp3;
uint32_t aac;
uint32_t vorbis;
uint32_t wma;
uint32_t ra;
uint32_t sbc;
uint32_t adpcm;
uint32_t g723;
uint32_t g726;
uint32_t g729;
uint32_t amr;
uint32_t gsm;
uint32_t midi;
};
static inline void
spa_type_media_subtype_audio_map(struct spa_type_map *map,
struct spa_type_media_subtype_audio *type)
{
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);
type->midi = spa_type_map_get_id(map, SPA_TYPE_MEDIA_SUBTYPE__midi);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __PARAM_SPA_FORMAT_UTILS_H__ */

88
spa/include/spa/param/format.h
View file

@ -26,54 +26,58 @@ extern "C" {
#include <spa/param/param.h>
#define SPA_TYPE__Format SPA_TYPE_PARAM_BASE "Format"
#define SPA_TYPE_FORMAT_BASE SPA_TYPE__Format ":"
/** media type for SPA_ID_OBJECT_Format */
enum spa_media_type {
SPA_MEDIA_TYPE_audio,
SPA_MEDIA_TYPE_video,
SPA_MEDIA_TYPE_image,
SPA_MEDIA_TYPE_binary,
SPA_MEDIA_TYPE_stream,
};
#define SPA_TYPE__MediaType SPA_TYPE_ENUM_BASE "MediaType"
#define SPA_TYPE_MEDIA_TYPE_BASE SPA_TYPE__MediaType ":"
/** media subtype for SPA_ID_OBJECT_Format */
enum spa_media_subtype {
SPA_MEDIA_SUBTYPE_BASE_Generic,
SPA_MEDIA_SUBTYPE_raw,
#define SPA_TYPE_MEDIA_TYPE__audio SPA_TYPE_MEDIA_TYPE_BASE "audio"
#define SPA_TYPE_MEDIA_TYPE__video SPA_TYPE_MEDIA_TYPE_BASE "video"
#define SPA_TYPE_MEDIA_TYPE__image SPA_TYPE_MEDIA_TYPE_BASE "image"
#define SPA_TYPE_MEDIA_TYPE__binary SPA_TYPE_MEDIA_TYPE_BASE "binary"
#define SPA_TYPE_MEDIA_TYPE__stream SPA_TYPE_MEDIA_TYPE_BASE "stream"
SPA_MEDIA_SUBTYPE_BASE_Audio = 0x10000,
SPA_MEDIA_SUBTYPE_mp3,
SPA_MEDIA_SUBTYPE_aac,
SPA_MEDIA_SUBTYPE_vorbis,
SPA_MEDIA_SUBTYPE_wma,
SPA_MEDIA_SUBTYPE_ra,
SPA_MEDIA_SUBTYPE_sbc,
SPA_MEDIA_SUBTYPE_adpcm,
SPA_MEDIA_SUBTYPE_g723,
SPA_MEDIA_SUBTYPE_g726,
SPA_MEDIA_SUBTYPE_g729,
SPA_MEDIA_SUBTYPE_amr,
SPA_MEDIA_SUBTYPE_gsm,
#define SPA_TYPE__MediaSubtype SPA_TYPE_ENUM_BASE "MediaSubtype"
#define SPA_TYPE_MEDIA_SUBTYPE_BASE SPA_TYPE__MediaSubtype ":"
SPA_MEDIA_SUBTYPE_BASE_Video = 0x20000,
SPA_MEDIA_SUBTYPE_h264,
SPA_MEDIA_SUBTYPE_mjpg,
SPA_MEDIA_SUBTYPE_dv,
SPA_MEDIA_SUBTYPE_mpegts,
SPA_MEDIA_SUBTYPE_h263,
SPA_MEDIA_SUBTYPE_mpeg1,
SPA_MEDIA_SUBTYPE_mpeg2,
SPA_MEDIA_SUBTYPE_mpeg4,
SPA_MEDIA_SUBTYPE_xvid,
SPA_MEDIA_SUBTYPE_vc1,
SPA_MEDIA_SUBTYPE_vp8,
SPA_MEDIA_SUBTYPE_vp9,
SPA_MEDIA_SUBTYPE_jpeg,
SPA_MEDIA_SUBTYPE_bayer,
/* generic subtypes */
#define SPA_TYPE_MEDIA_SUBTYPE__raw SPA_TYPE_MEDIA_SUBTYPE_BASE "raw"
SPA_MEDIA_SUBTYPE_BASE_Image = 0x30000,
/* video subtypes */
#define SPA_TYPE_MEDIA_SUBTYPE__h264 SPA_TYPE_MEDIA_SUBTYPE_BASE "h264"
#define SPA_TYPE_MEDIA_SUBTYPE__mjpg SPA_TYPE_MEDIA_SUBTYPE_BASE "mjpg"
#define SPA_TYPE_MEDIA_SUBTYPE__dv SPA_TYPE_MEDIA_SUBTYPE_BASE "dv"
#define SPA_TYPE_MEDIA_SUBTYPE__mpegts SPA_TYPE_MEDIA_SUBTYPE_BASE "mpegts"
#define SPA_TYPE_MEDIA_SUBTYPE__h263 SPA_TYPE_MEDIA_SUBTYPE_BASE "h263"
#define SPA_TYPE_MEDIA_SUBTYPE__mpeg1 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg1"
#define SPA_TYPE_MEDIA_SUBTYPE__mpeg2 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg2"
#define SPA_TYPE_MEDIA_SUBTYPE__mpeg4 SPA_TYPE_MEDIA_SUBTYPE_BASE "mpeg4"
#define SPA_TYPE_MEDIA_SUBTYPE__xvid SPA_TYPE_MEDIA_SUBTYPE_BASE "xvid"
#define SPA_TYPE_MEDIA_SUBTYPE__vc1 SPA_TYPE_MEDIA_SUBTYPE_BASE "vc1"
#define SPA_TYPE_MEDIA_SUBTYPE__vp8 SPA_TYPE_MEDIA_SUBTYPE_BASE "vp8"
#define SPA_TYPE_MEDIA_SUBTYPE__vp9 SPA_TYPE_MEDIA_SUBTYPE_BASE "vp9"
#define SPA_TYPE_MEDIA_SUBTYPE__jpeg SPA_TYPE_MEDIA_SUBTYPE_BASE "jpeg"
#define SPA_TYPE_MEDIA_SUBTYPE__bayer SPA_TYPE_MEDIA_SUBTYPE_BASE "bayer"
SPA_MEDIA_SUBTYPE_BASE_Binary = 0x40000,
SPA_MEDIA_SUBTYPE_BASE_Stream = 0x50000,
SPA_MEDIA_SUBTYPE_midi,
};
/* audio subtypes */
#define SPA_TYPE_MEDIA_SUBTYPE__mp3 SPA_TYPE_MEDIA_SUBTYPE_BASE "mp3"
#define SPA_TYPE_MEDIA_SUBTYPE__aac SPA_TYPE_MEDIA_SUBTYPE_BASE "aac"
#define SPA_TYPE_MEDIA_SUBTYPE__vorbis SPA_TYPE_MEDIA_SUBTYPE_BASE "vorbis"
#define SPA_TYPE_MEDIA_SUBTYPE__wma SPA_TYPE_MEDIA_SUBTYPE_BASE "wma"
#define SPA_TYPE_MEDIA_SUBTYPE__ra SPA_TYPE_MEDIA_SUBTYPE_BASE "ra"
#define SPA_TYPE_MEDIA_SUBTYPE__sbc SPA_TYPE_MEDIA_SUBTYPE_BASE "sbc"
#define SPA_TYPE_MEDIA_SUBTYPE__adpcm SPA_TYPE_MEDIA_SUBTYPE_BASE "adpcm"
#define SPA_TYPE_MEDIA_SUBTYPE__g723 SPA_TYPE_MEDIA_SUBTYPE_BASE "g723"
#define SPA_TYPE_MEDIA_SUBTYPE__g726 SPA_TYPE_MEDIA_SUBTYPE_BASE "g726"
#define SPA_TYPE_MEDIA_SUBTYPE__g729 SPA_TYPE_MEDIA_SUBTYPE_BASE "g729"
#define SPA_TYPE_MEDIA_SUBTYPE__amr SPA_TYPE_MEDIA_SUBTYPE_BASE "amr"
#define SPA_TYPE_MEDIA_SUBTYPE__gsm SPA_TYPE_MEDIA_SUBTYPE_BASE "gsm"
#define SPA_TYPE_MEDIA_SUBTYPE__midi SPA_TYPE_MEDIA_SUBTYPE_BASE "midi"
#ifdef __cplusplus
} /* extern "C" */

101
spa/include/spa/param/io-types.h Normal file
View file

@ -0,0 +1,101 @@
/* 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_PARAM_IO_H__
#define __SPA_PARAM_IO_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
/** type ID of property, uniquely identifies the io area for a port */
#define SPA_TYPE_PARAM_IO__id SPA_TYPE_PARAM_IO_BASE "id"
/** size of the io area for a port */
#define SPA_TYPE_PARAM_IO__size SPA_TYPE_PARAM_IO_BASE "size"
/** enumerate buffer io areas */
#define SPA_TYPE_PARAM_ID_IO__Buffers SPA_TYPE_PARAM_ID_IO_BASE "Buffers"
/* an io area to exchange buffers */
#define SPA_TYPE_PARAM_IO__Buffers SPA_TYPE_PARAM_IO_BASE "Buffers"
/** enumerate Control io areas */
#define SPA_TYPE_PARAM_ID_IO__Control SPA_TYPE_PARAM_ID_IO_BASE "Control"
/* an io area to exchange control information */
#define SPA_TYPE_PARAM_IO__Control SPA_TYPE_PARAM_IO_BASE "Control"
/** enumerate input or output properties */
#define SPA_TYPE_PARAM_ID_IO__Props SPA_TYPE_PARAM_ID_IO_BASE "Props"
#define SPA_TYPE_PARAM_ID_IO_PROPS_BASE SPA_TYPE_PARAM_ID_IO__Props ":"
/** enumerate input property io areas */
#define SPA_TYPE_PARAM_ID_IO_PROPS__In SPA_TYPE_PARAM_ID_IO_PROPS_BASE "In"
/** enumerate output property io areas */
#define SPA_TYPE_PARAM_ID_IO_PROPS__Out SPA_TYPE_PARAM_ID_IO_PROPS_BASE "Out"
/* an io area to exchange properties. Contents can include
* SPA_TYPE_PARAM__PropInfo */
#define SPA_TYPE_PARAM_IO__Prop SPA_TYPE_PARAM_IO_BASE "Prop"
#define SPA_TYPE_PARAM_IO_PROP_BASE SPA_TYPE_PARAM_IO__Prop ":"
/** enumerate clock io areas */
#define SPA_TYPE_PARAM_ID_IO__Clock SPA_TYPE_PARAM_ID_IO_BASE "Clock"
/* an io area to exchange clock information */
#define SPA_TYPE_PARAM_IO__Clock SPA_TYPE_PARAM_IO_BASE "Clock"
struct spa_type_param_io {
uint32_t id; /**< id to configure the io area */
uint32_t size; /**< size of io area */
uint32_t idBuffers; /**< id to enumerate buffer io */
uint32_t Buffers; /**< object type of buffer io area */
uint32_t idControl; /**< id to enumerate control io */
uint32_t Control; /**< object type of Control area */
uint32_t idPropsIn; /**< id to enumerate input properties io */
uint32_t idPropsOut; /**< id to enumerate output properties io */
uint32_t Prop; /**< object type of property area */
uint32_t idClock; /**< id to enumerate clock io */
uint32_t Clock; /**< object type of clock io area */
};
static inline void
spa_type_param_io_map(struct spa_type_map *map,
struct spa_type_param_io *type)
{
if (type->id == 0) {
type->id = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__id);
type->size = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__size);
type->idBuffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Buffers);
type->Buffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Buffers);
type->idControl = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Control);
type->Control = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Control);
type->idPropsIn = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO_PROPS__In);
type->idPropsOut = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO_PROPS__Out);
type->Prop = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Prop);
type->idClock = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Clock);
type->Clock = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Clock);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_IO_H__ */

69
spa/include/spa/param/io.h
View file

@ -26,74 +26,13 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
/** type ID of property, uniquely identifies the io area for a port */
#define SPA_TYPE_PARAM_IO__id SPA_TYPE_PARAM_IO_BASE "id"
/** size of the io area for a port */
#define SPA_TYPE_PARAM_IO__size SPA_TYPE_PARAM_IO_BASE "size"
/** enumerate buffer io areas */
#define SPA_TYPE_PARAM_ID_IO__Buffers SPA_TYPE_PARAM_ID_IO_BASE "Buffers"
/* an io area to exchange buffers */
#define SPA_TYPE_PARAM_IO__Buffers SPA_TYPE_PARAM_IO_BASE "Buffers"
/** enumerate Control io areas */
#define SPA_TYPE_PARAM_ID_IO__Control SPA_TYPE_PARAM_ID_IO_BASE "Control"
/* an io area to exchange control information */
#define SPA_TYPE_PARAM_IO__Control SPA_TYPE_PARAM_IO_BASE "Control"
/** enumerate input or output properties */
#define SPA_TYPE_PARAM_ID_IO__Props SPA_TYPE_PARAM_ID_IO_BASE "Props"
#define SPA_TYPE_PARAM_ID_IO_PROPS_BASE SPA_TYPE_PARAM_ID_IO__Props ":"
/** enumerate input property io areas */
#define SPA_TYPE_PARAM_ID_IO_PROPS__In SPA_TYPE_PARAM_ID_IO_PROPS_BASE "In"
/** enumerate output property io areas */
#define SPA_TYPE_PARAM_ID_IO_PROPS__Out SPA_TYPE_PARAM_ID_IO_PROPS_BASE "Out"
/* an io area to exchange properties. Contents can include
* SPA_TYPE_PARAM__PropInfo */
#define SPA_TYPE_PARAM_IO__Prop SPA_TYPE_PARAM_IO_BASE "Prop"
#define SPA_TYPE_PARAM_IO_PROP_BASE SPA_TYPE_PARAM_IO__Prop ":"
/** enumerate clock io areas */
#define SPA_TYPE_PARAM_ID_IO__Clock SPA_TYPE_PARAM_ID_IO_BASE "Clock"
/* an io area to exchange clock information */
#define SPA_TYPE_PARAM_IO__Clock SPA_TYPE_PARAM_IO_BASE "Clock"
struct spa_type_param_io {
uint32_t id; /**< id to configure the io area */
uint32_t size; /**< size of io area */
uint32_t idBuffers; /**< id to enumerate buffer io */
uint32_t Buffers; /**< object type of buffer io area */
uint32_t idControl; /**< id to enumerate control io */
uint32_t Control; /**< object type of Control area */
uint32_t idPropsIn; /**< id to enumerate input properties io */
uint32_t idPropsOut; /**< id to enumerate output properties io */
uint32_t Prop; /**< object type of property area */
uint32_t idClock; /**< id to enumerate clock io */
uint32_t Clock; /**< object type of clock io area */
/** properties for SPA_ID_OBJECT_ParamIO */
enum spa_param_io {
SPA_PARAM_IO_id, /**< type ID, uniquely identifies the io area */
SPA_PARAM_IO_size, /**< size of the io area */
};
static inline void
spa_type_param_io_map(struct spa_type_map *map,
struct spa_type_param_io *type)
{
if (type->id == 0) {
type->id = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__id);
type->size = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__size);
type->idBuffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Buffers);
type->Buffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Buffers);
type->idControl = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Control);
type->Control = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Control);
type->idPropsIn = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO_PROPS__In);
type->idPropsOut = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO_PROPS__Out);
type->Prop = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Prop);
type->idClock = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID_IO__Clock);
type->Clock = spa_type_map_get_id(map, SPA_TYPE_PARAM_IO__Clock);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif

66
spa/include/spa/param/meta-types.h Normal file
View file

@ -0,0 +1,66 @@
/* 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_PARAM_META_H__
#define __SPA_PARAM_META_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <fcntl.h> /* for off_t */
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
#define SPA_TYPE_PARAM__Meta SPA_TYPE_PARAM_BASE "Meta"
#define SPA_TYPE_PARAM_META_BASE SPA_TYPE_PARAM__Meta ":"
#define SPA_TYPE_PARAM_META__type SPA_TYPE_PARAM_META_BASE "type"
#define SPA_TYPE_PARAM_META__size SPA_TYPE_PARAM_META_BASE "size"
struct spa_type_param_meta {
uint32_t Meta;
uint32_t type;
uint32_t size;
};
static inline void
spa_type_param_meta_map(struct spa_type_map *map,
struct spa_type_param_meta *type)
{
if (type->Meta == 0) {
size_t i;
#define OFF(n) offsetof(struct spa_type_param_meta, n)
static struct { off_t offset; const char *type; } tab[] = {
{ OFF(Meta), SPA_TYPE_PARAM__Meta },
{ OFF(type), SPA_TYPE_PARAM_META__type },
{ OFF(size), SPA_TYPE_PARAM_META__size },
};
#undef OFF
for (i = 0; i < SPA_N_ELEMENTS(tab); i++)
*SPA_MEMBER(type, tab[i].offset, uint32_t) = spa_type_map_get_id(map, tab[i].type);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_META_H__ */

34
spa/include/spa/param/meta.h
View file

@ -24,41 +24,15 @@
extern "C" {
#endif
#include <fcntl.h> /* for off_t */
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
#define SPA_TYPE_PARAM__Meta SPA_TYPE_PARAM_BASE "Meta"
#define SPA_TYPE_PARAM_META_BASE SPA_TYPE_PARAM__Meta ":"
#define SPA_TYPE_PARAM_META__type SPA_TYPE_PARAM_META_BASE "type"
#define SPA_TYPE_PARAM_META__size SPA_TYPE_PARAM_META_BASE "size"
struct spa_type_param_meta {
uint32_t Meta;
uint32_t type;
uint32_t size;
/** properties for SPA_ID_OBJECT_ParamMeta */
enum spa_param_meta {
SPA_PARAM_META_type, /**< the metadata, one of enum spa_meta_type */
SPA_PARAM_META_size, /**< the expected maximum size the meta */
};
static inline void
spa_type_param_meta_map(struct spa_type_map *map,
struct spa_type_param_meta *type)
{
if (type->Meta == 0) {
size_t i;
#define OFF(n) offsetof(struct spa_type_param_meta, n)
static struct { off_t offset; const char *type; } tab[] = {
{ OFF(Meta), SPA_TYPE_PARAM__Meta },
{ OFF(type), SPA_TYPE_PARAM_META__type },
{ OFF(size), SPA_TYPE_PARAM_META__size },
};
#undef OFF
for (i = 0; i < SPA_N_ELEMENTS(tab); i++)
*SPA_MEMBER(type, tab[i].offset, uint32_t) = spa_type_map_get_id(map, tab[i].type);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif

92
spa/include/spa/param/param-types.h Normal file
View file

@ -0,0 +1,92 @@
/* Simple Plugin API
* Copyright (C) 2017 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_PARAM_TYPES_H__
#define __SPA_PARAM_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/pod/pod.h>
/* base for parameter objects */
#define SPA_TYPE__Param SPA_TYPE_POD_OBJECT_BASE "Param"
#define SPA_TYPE_PARAM_BASE SPA_TYPE__Param ":"
/* base for parameter object enumerations */
#define SPA_TYPE__ParamId SPA_TYPE_ENUM_BASE "ParamId"
#define SPA_TYPE_PARAM_ID_BASE SPA_TYPE__ParamId ":"
/** List of supported parameters */
#define SPA_TYPE_PARAM_ID__List SPA_TYPE_PARAM_ID_BASE "List"
/* object with supported parameter id */
#define SPA_TYPE_PARAM__List SPA_TYPE_PARAM_BASE "List"
#define SPA_TYPE_PARAM_LIST_BASE SPA_TYPE_PARAM__List ":"
#define SPA_TYPE_PARAM_LIST__id SPA_TYPE_PARAM_LIST_BASE "id"
/** Enum Property info */
#define SPA_TYPE_PARAM_ID__PropInfo SPA_TYPE_PARAM_ID_BASE "PropInfo"
#define SPA_TYPE_PARAM__PropInfo SPA_TYPE_PARAM_BASE "PropInfo"
#define SPA_TYPE_PARAM_PROP_INFO_BASE SPA_TYPE_PARAM__PropInfo ":"
/** associated id of the property */
#define SPA_TYPE_PARAM_PROP_INFO__id SPA_TYPE_PARAM_PROP_INFO_BASE "id"
/** name of property */
#define SPA_TYPE_PARAM_PROP_INFO__name SPA_TYPE_PARAM_PROP_INFO_BASE "name"
/** associated type and range/enums of property */
#define SPA_TYPE_PARAM_PROP_INFO__type SPA_TYPE_PARAM_PROP_INFO_BASE "type"
/** associated labels of property if any, this is a struct with pairs of values,
* the first one is of the type of the property, the second one is a string with
* a user readable label for the value. */
#define SPA_TYPE_PARAM_PROP_INFO__labels SPA_TYPE_PARAM_PROP_INFO_BASE "labels"
/** Property parameter id, deals with SPA_TYPE__Props */
#define SPA_TYPE_PARAM_ID__Props SPA_TYPE_PARAM_ID_BASE "Props"
/** The available formats */
#define SPA_TYPE_PARAM_ID__EnumFormat SPA_TYPE_PARAM_ID_BASE "EnumFormat"
/** The current format */
#define SPA_TYPE_PARAM_ID__Format SPA_TYPE_PARAM_ID_BASE "Format"
/** The supported buffer sizes */
#define SPA_TYPE_PARAM_ID__Buffers SPA_TYPE_PARAM_ID_BASE "Buffers"
/** The supported metadata */
#define SPA_TYPE_PARAM_ID__Meta SPA_TYPE_PARAM_ID_BASE "Meta"
/** The supported io areas */
#define SPA_TYPE_PARAM_ID__IO SPA_TYPE_PARAM_ID_BASE "IO"
#define SPA_TYPE_PARAM_ID_IO_BASE SPA_TYPE_PARAM_ID__IO ":"
/** Base for parameters that describe IO areas to exchange data,
* control and properties with a node.
*/
#define SPA_TYPE_PARAM__IO SPA_TYPE_PARAM_BASE "IO"
#define SPA_TYPE_PARAM_IO_BASE SPA_TYPE_PARAM__IO ":"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_TYPES_H__ */

99
spa/include/spa/param/param.h
View file

@ -25,105 +25,12 @@ extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/pod/pod.h>
#include <spa/support/type-map.h>
/* base for parameter objects */
#define SPA_TYPE__Param SPA_TYPE_POD_OBJECT_BASE "Param"
#define SPA_TYPE_PARAM_BASE SPA_TYPE__Param ":"
/* base for parameter object enumerations */
#define SPA_TYPE__ParamId SPA_TYPE_ENUM_BASE "ParamId"
#define SPA_TYPE_PARAM_ID_BASE SPA_TYPE__ParamId ":"
/** List of supported parameters */
#define SPA_TYPE_PARAM_ID__List SPA_TYPE_PARAM_ID_BASE "List"
/* object with supported parameter id */
#define SPA_TYPE_PARAM__List SPA_TYPE_PARAM_BASE "List"
#define SPA_TYPE_PARAM_LIST_BASE SPA_TYPE_PARAM__List ":"
#define SPA_TYPE_PARAM_LIST__id SPA_TYPE_PARAM_LIST_BASE "id"
/** Enum Property info */
#define SPA_TYPE_PARAM_ID__PropInfo SPA_TYPE_PARAM_ID_BASE "PropInfo"
#define SPA_TYPE_PARAM__PropInfo SPA_TYPE_PARAM_BASE "PropInfo"
#define SPA_TYPE_PARAM_PROP_INFO_BASE SPA_TYPE_PARAM__PropInfo ":"
/** associated id of the property */
#define SPA_TYPE_PARAM_PROP_INFO__id SPA_TYPE_PARAM_PROP_INFO_BASE "id"
/** name of property */
#define SPA_TYPE_PARAM_PROP_INFO__name SPA_TYPE_PARAM_PROP_INFO_BASE "name"
/** associated type and range/enums of property */
#define SPA_TYPE_PARAM_PROP_INFO__type SPA_TYPE_PARAM_PROP_INFO_BASE "type"
/** associated labels of property if any, this is a struct with pairs of values,
* the first one is of the type of the property, the second one is a string with
* a user readable label for the value. */
#define SPA_TYPE_PARAM_PROP_INFO__labels SPA_TYPE_PARAM_PROP_INFO_BASE "labels"
/** Property parameter id, deals with SPA_TYPE__Props */
#define SPA_TYPE_PARAM_ID__Props SPA_TYPE_PARAM_ID_BASE "Props"
/** The available formats */
#define SPA_TYPE_PARAM_ID__EnumFormat SPA_TYPE_PARAM_ID_BASE "EnumFormat"
/** The current format */
#define SPA_TYPE_PARAM_ID__Format SPA_TYPE_PARAM_ID_BASE "Format"
/** The supported buffer sizes */
#define SPA_TYPE_PARAM_ID__Buffers SPA_TYPE_PARAM_ID_BASE "Buffers"
/** The supported metadata */
#define SPA_TYPE_PARAM_ID__Meta SPA_TYPE_PARAM_ID_BASE "Meta"
/** The supported io areas */
#define SPA_TYPE_PARAM_ID__IO SPA_TYPE_PARAM_ID_BASE "IO"
#define SPA_TYPE_PARAM_ID_IO_BASE SPA_TYPE_PARAM_ID__IO ":"
/** Base for parameters that describe IO areas to exchange data,
* control and properties with a node.
*/
#define SPA_TYPE_PARAM__IO SPA_TYPE_PARAM_BASE "IO"
#define SPA_TYPE_PARAM_IO_BASE SPA_TYPE_PARAM__IO ":"
struct spa_type_param {
uint32_t idList; /**< id of the list param */
uint32_t List; /**< list object type */
uint32_t listId; /**< id in the list object */
uint32_t idPropInfo; /**< id to enumerate property info */
uint32_t PropInfo; /**< property info object */
uint32_t propId; /**< property id */
uint32_t propName; /**< property name */
uint32_t propType; /**< property type */
uint32_t propLabels; /**< property labels */
uint32_t idProps; /**< id to enumerate properties */
uint32_t idEnumFormat; /**< id to enumerate formats */
uint32_t idFormat; /**< id to get/set format parameter */
uint32_t idBuffers; /**< id to enumerate buffer requirements */
uint32_t idMeta; /**< id to enumerate supported metadata */
/** Properties for SPA_ID_OBJECT_ParamList */
enum spa_param_list {
SPA_PARAM_LIST_id, /**< id of the supported list param */
};
static inline void
spa_type_param_map(struct spa_type_map *map,
struct spa_type_param *type)
{
if (type->idList == 0) {
type->idList = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__List);
type->List = spa_type_map_get_id(map, SPA_TYPE_PARAM__List);
type->listId = spa_type_map_get_id(map, SPA_TYPE_PARAM_LIST__id);
type->idPropInfo = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__PropInfo);
type->PropInfo = spa_type_map_get_id(map, SPA_TYPE_PARAM__PropInfo);
type->propId = spa_type_map_get_id(map, SPA_TYPE_PARAM_PROP_INFO__id);
type->propName = spa_type_map_get_id(map, SPA_TYPE_PARAM_PROP_INFO__name);
type->propType = spa_type_map_get_id(map, SPA_TYPE_PARAM_PROP_INFO__type);
type->propLabels = spa_type_map_get_id(map, SPA_TYPE_PARAM_PROP_INFO__labels);
type->idProps = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__Props);
type->idEnumFormat = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__EnumFormat);
type->idFormat = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__Format);
type->idBuffers = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__Buffers);
type->idMeta = spa_type_map_get_id(map, SPA_TYPE_PARAM_ID__Meta);
}
}
#ifdef __cplusplus
} /* extern "C" */

70
spa/include/spa/param/props-types.h Normal file
View file

@ -0,0 +1,70 @@
/* 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_PARAM_PROPS_TYPES_H__
#define __SPA_PARAM_PROPS_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/param.h>
#define SPA_TYPE__Props SPA_TYPE_PARAM_BASE "Props"
#define SPA_TYPE_PROPS_BASE SPA_TYPE__Props ":"
/** an unknown property */
#define SPA_TYPE_PROPS__unknown SPA_TYPE_PROPS_BASE "unknown"
/** Common property ids */
#define SPA_TYPE_PROPS__device SPA_TYPE_PROPS_BASE "device"
#define SPA_TYPE_PROPS__deviceName SPA_TYPE_PROPS_BASE "deviceName"
#define SPA_TYPE_PROPS__deviceFd SPA_TYPE_PROPS_BASE "deviceFd"
#define SPA_TYPE_PROPS__card SPA_TYPE_PROPS_BASE "card"
#define SPA_TYPE_PROPS__cardName SPA_TYPE_PROPS_BASE "cardName"
#define SPA_TYPE_PROPS__minLatency SPA_TYPE_PROPS_BASE "minLatency"
#define SPA_TYPE_PROPS__maxLatency SPA_TYPE_PROPS_BASE "maxLatency"
#define SPA_TYPE_PROPS__periods SPA_TYPE_PROPS_BASE "periods"
#define SPA_TYPE_PROPS__periodSize SPA_TYPE_PROPS_BASE "periodSize"
#define SPA_TYPE_PROPS__periodEvent SPA_TYPE_PROPS_BASE "periodEvent"
#define SPA_TYPE_PROPS__live SPA_TYPE_PROPS_BASE "live"
#define SPA_TYPE_PROPS__waveType SPA_TYPE_PROPS_BASE "waveType"
#define SPA_TYPE_PROPS__frequency SPA_TYPE_PROPS_BASE "frequency"
#define SPA_TYPE_PROPS__volume SPA_TYPE_PROPS_BASE "volume"
#define SPA_TYPE_PROPS__mute SPA_TYPE_PROPS_BASE "mute"
#define SPA_TYPE_PROPS__patternType SPA_TYPE_PROPS_BASE "patternType"
#define SPA_TYPE_PROPS__ditherType SPA_TYPE_PROPS_BASE "ditherType"
#define SPA_TYPE_PROPS__truncate SPA_TYPE_PROPS_BASE "truncate"
#define SPA_TYPE_PROPS__brightness SPA_TYPE_PROPS_BASE "brightness"
#define SPA_TYPE_PROPS__contrast SPA_TYPE_PROPS_BASE "contrast"
#define SPA_TYPE_PROPS__saturation SPA_TYPE_PROPS_BASE "saturation"
#define SPA_TYPE_PROPS__hue SPA_TYPE_PROPS_BASE "hue"
#define SPA_TYPE_PROPS__gamma SPA_TYPE_PROPS_BASE "gamma"
#define SPA_TYPE_PROPS__exposure SPA_TYPE_PROPS_BASE "exposure"
#define SPA_TYPE_PROPS__gain SPA_TYPE_PROPS_BASE "gain"
#define SPA_TYPE_PROPS__sharpness SPA_TYPE_PROPS_BASE "sharpness"
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_PROPS_TYPES_H__ */

76
spa/include/spa/param/props.h
View file

@ -26,42 +26,56 @@ extern "C" {
#include <spa/param/param.h>
#define SPA_TYPE__Props SPA_TYPE_PARAM_BASE "Props"
#define SPA_TYPE_PROPS_BASE SPA_TYPE__Props ":"
/** properties of SPA_ID_OBJECT_PropInfo */
enum spa_prop_info {
SPA_PROP_INFO_id, /**< associated id of the property */
SPA_PROP_INFO_name, /**< name of the property */
SPA_PROP_INFO_type, /**< type and range/enums of property */
SPA_PROP_INFO_labels, /**< labels of property if any, this is a
* struct with pairs of values, the first one
* is of the type of the property, the second
* one is a string with a user readable label
* for the value. */
};
/** an unknown property */
#define SPA_TYPE_PROPS__unknown SPA_TYPE_PROPS_BASE "unknown"
/** predefined properties for SPA_ID_OBJECT_Props */
enum spa_prop {
SPA_PROP_BASE_GENERIC = 0x0,
/** Common property ids */
#define SPA_TYPE_PROPS__device SPA_TYPE_PROPS_BASE "device"
#define SPA_TYPE_PROPS__deviceName SPA_TYPE_PROPS_BASE "deviceName"
#define SPA_TYPE_PROPS__deviceFd SPA_TYPE_PROPS_BASE "deviceFd"
#define SPA_TYPE_PROPS__card SPA_TYPE_PROPS_BASE "card"
#define SPA_TYPE_PROPS__cardName SPA_TYPE_PROPS_BASE "cardName"
SPA_PROP_unknown, /**< an unknown property */
#define SPA_TYPE_PROPS__minLatency SPA_TYPE_PROPS_BASE "minLatency"
#define SPA_TYPE_PROPS__maxLatency SPA_TYPE_PROPS_BASE "maxLatency"
#define SPA_TYPE_PROPS__periods SPA_TYPE_PROPS_BASE "periods"
#define SPA_TYPE_PROPS__periodSize SPA_TYPE_PROPS_BASE "periodSize"
#define SPA_TYPE_PROPS__periodEvent SPA_TYPE_PROPS_BASE "periodEvent"
SPA_PROP_device,
SPA_PROP_deviceName,
SPA_PROP_deviceFd,
SPA_PROP_card,
SPA_PROP_cardName,
#define SPA_TYPE_PROPS__live SPA_TYPE_PROPS_BASE "live"
#define SPA_TYPE_PROPS__waveType SPA_TYPE_PROPS_BASE "waveType"
#define SPA_TYPE_PROPS__frequency SPA_TYPE_PROPS_BASE "frequency"
#define SPA_TYPE_PROPS__volume SPA_TYPE_PROPS_BASE "volume"
#define SPA_TYPE_PROPS__mute SPA_TYPE_PROPS_BASE "mute"
#define SPA_TYPE_PROPS__patternType SPA_TYPE_PROPS_BASE "patternType"
#define SPA_TYPE_PROPS__ditherType SPA_TYPE_PROPS_BASE "ditherType"
#define SPA_TYPE_PROPS__truncate SPA_TYPE_PROPS_BASE "truncate"
SPA_PROP_minLatency,
SPA_PROP_maxLatency,
SPA_PROP_periods,
SPA_PROP_periodSize,
SPA_PROP_periodEvent,
SPA_PROP_live,
#define SPA_TYPE_PROPS__brightness SPA_TYPE_PROPS_BASE "brightness"
#define SPA_TYPE_PROPS__contrast SPA_TYPE_PROPS_BASE "contrast"
#define SPA_TYPE_PROPS__saturation SPA_TYPE_PROPS_BASE "saturation"
#define SPA_TYPE_PROPS__hue SPA_TYPE_PROPS_BASE "hue"
#define SPA_TYPE_PROPS__gamma SPA_TYPE_PROPS_BASE "gamma"
#define SPA_TYPE_PROPS__exposure SPA_TYPE_PROPS_BASE "exposure"
#define SPA_TYPE_PROPS__gain SPA_TYPE_PROPS_BASE "gain"
#define SPA_TYPE_PROPS__sharpness SPA_TYPE_PROPS_BASE "sharpness"
SPA_PROP_waveType,
SPA_PROP_frequency,
SPA_PROP_volume,
SPA_PROP_mute,
SPA_PROP_patternType,
SPA_PROP_ditherType,
SPA_PROP_truncate,
SPA_PROP_brightness,
SPA_PROP_contrast,
SPA_PROP_saturation,
SPA_PROP_hue,
SPA_PROP_gamma,
SPA_PROP_exposure,
SPA_PROP_gain,
SPA_PROP_sharpness,
SPA_PROP_BASE_CUSTOM = 0x10000,
};
#ifdef __cplusplus
} /* extern "C" */

29
spa/include/spa/param/video-padding.h
View file

@ -26,8 +26,8 @@ extern "C" {
#include <spa/utils/defs.h>
#include <spa/param/param.h>
#include <spa/support/type-map.h>
#if 0
#define SPA_TYPE_PARAM__VideoPadding SPA_TYPE_PARAM_BASE "VideoPadding"
#define SPA_TYPE_PARAM_VIDEO_PADDING_BASE SPA_TYPE_PARAM__VideoPadding ":"
@ -39,32 +39,7 @@ extern "C" {
#define SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign1 SPA_TYPE_PARAM_VIDEO_PADDING_BASE "strideAlign1"
#define SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign2 SPA_TYPE_PARAM_VIDEO_PADDING_BASE "strideAlign2"
#define SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign3 SPA_TYPE_PARAM_VIDEO_PADDING_BASE "strideAlign3"
struct spa_type_param_video_padding {
uint32_t VideoPadding;
uint32_t top;
uint32_t bottom;
uint32_t left;
uint32_t right;
uint32_t strideAlign[4];
};
static inline void
spa_type_param_video_padding_map(struct spa_type_map *map,
struct spa_type_param_video_padding *type)
{
if (type->VideoPadding == 0) {
type->VideoPadding = spa_type_map_get_id(map, SPA_TYPE_PARAM__VideoPadding);
type->top = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__top);
type->bottom = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__bottom);
type->left = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__left);
type->right = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__right);
type->strideAlign[0] = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign0);
type->strideAlign[1] = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign1);
type->strideAlign[2] = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign2);
type->strideAlign[3] = spa_type_map_get_id(map, SPA_TYPE_PARAM_VIDEO_PADDING__strideAlign3);
}
}
#endif
#ifdef __cplusplus
} /* extern "C" */

60
spa/include/spa/param/video/format-types.h Normal file
View file

@ -0,0 +1,60 @@
/* 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_PARAM_VIDEO_FORMAT_TYPES_H__
#define __SPA_PARAM_VIDEO_FORMAT_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/video/format.h>
#include <spa/param/video/raw-types.h>
#define SPA_TYPE__FormatVideo SPA_TYPE_FORMAT_BASE "Video"
#define SPA_TYPE_FORMAT_VIDEO_BASE SPA_TYPE__FormatVideo ":"
static const struct spa_type_info spa_type_format_video_ids[] = {
{ SPA_FORMAT_VIDEO_format, SPA_TYPE_FORMAT_VIDEO_BASE "format", SPA_POD_TYPE_ID,
spa_type_video_format, },
{ SPA_FORMAT_VIDEO_size, SPA_TYPE_FORMAT_VIDEO_BASE "size", SPA_POD_TYPE_RECTANGLE, },
{ SPA_FORMAT_VIDEO_framerate, SPA_TYPE_FORMAT_VIDEO_BASE "framerate", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_maxFramerate, SPA_TYPE_FORMAT_VIDEO_BASE "maxFramerate", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_views, SPA_TYPE_FORMAT_VIDEO_BASE "views", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_interlaceMode, SPA_TYPE_FORMAT_VIDEO_BASE "interlaceMode", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_pixelAspectRatio, SPA_TYPE_FORMAT_VIDEO_BASE "pixelAspectRatio", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_multiviewMode, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewMode", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_multiviewFlags, SPA_TYPE_FORMAT_VIDEO_BASE "multiviewFlags", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_chromaSite, SPA_TYPE_FORMAT_VIDEO_BASE "chromaSite", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_colorRange, SPA_TYPE_FORMAT_VIDEO_BASE "colorRange", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_colorMatrix, SPA_TYPE_FORMAT_VIDEO_BASE "colorMatrix", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_transferFunction, SPA_TYPE_FORMAT_VIDEO_BASE "transferFunction", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_colorPrimaries, SPA_TYPE_FORMAT_VIDEO_BASE "colorPrimaries", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_profile, SPA_TYPE_FORMAT_VIDEO_BASE "profile", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_level, SPA_TYPE_FORMAT_VIDEO_BASE "level", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_streamFormat, SPA_TYPE_FORMAT_VIDEO_BASE "streamFormat", SPA_POD_TYPE_INT, },
{ SPA_FORMAT_VIDEO_alignment, SPA_TYPE_FORMAT_VIDEO_BASE "alignment", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_PARAM_VIDEO_FORMAT_TYPES_H */

100
spa/include/spa/param/video/format-utils.h
View file

@ -24,98 +24,50 @@
extern "C" {
#endif
#include <spa/param/param.h>
#include <spa/param/format-utils.h>
#include <spa/pod/parser.h>
#include <spa/param/video/format.h>
#include <spa/param/video/raw-utils.h>
struct spa_type_format_video {
uint32_t format;
uint32_t size;
uint32_t framerate;
uint32_t max_framerate;
uint32_t views;
uint32_t interlace_mode;
uint32_t pixel_aspect_ratio;
uint32_t multiview_mode;
uint32_t multiview_flags;
uint32_t chroma_site;
uint32_t color_range;
uint32_t color_matrix;
uint32_t transfer_function;
uint32_t color_primaries;
uint32_t profile;
uint32_t level;
uint32_t stream_format;
uint32_t alignment;
};
static inline void
spa_type_format_video_map(struct spa_type_map *map, struct spa_type_format_video *type)
{
if (type->format == 0) {
type->format = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__format);
type->size = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__size);
type->framerate = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__framerate);
type->max_framerate = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__maxFramerate);
type->views = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__views);
type->interlace_mode = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__interlaceMode);
type->pixel_aspect_ratio = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__pixelAspectRatio);
type->multiview_mode = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__multiviewMode);
type->multiview_flags = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__multiviewFlags);
type->chroma_site = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__chromaSite);
type->color_range = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__colorRange);
type->color_matrix = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__colorMatrix);
type->transfer_function = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__transferFunction);
type->color_primaries = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__colorPrimaries);
type->profile = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__profile);
type->level = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__level);
type->stream_format = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__streamFormat);
type->alignment = spa_type_map_get_id(map, SPA_TYPE_FORMAT_VIDEO__alignment);
}
}
static inline int
spa_format_video_raw_parse(const struct spa_pod *format,
struct spa_video_info_raw *info, struct spa_type_format_video *type)
struct spa_video_info_raw *info)
{
return spa_pod_object_parse(format,
":",type->format, "I", &info->format,
":",type->size, "R", &info->size,
":",type->framerate, "F", &info->framerate,
":",type->max_framerate, "?F", &info->max_framerate,
":",type->views, "?i", &info->views,
":",type->interlace_mode, "?i", &info->interlace_mode,
":",type->pixel_aspect_ratio, "?F", &info->pixel_aspect_ratio,
":",type->multiview_mode, "?i", &info->multiview_mode,
":",type->multiview_flags, "?i", &info->multiview_flags,
":",type->chroma_site, "?i", &info->chroma_site,
":",type->color_range, "?i", &info->color_range,
":",type->color_matrix, "?i", &info->color_matrix,
":",type->transfer_function, "?i", &info->transfer_function,
":",type->color_primaries, "?i", &info->color_primaries, NULL);
":", SPA_FORMAT_VIDEO_format, "I", &info->format,
":", SPA_FORMAT_VIDEO_size, "R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate,
":", SPA_FORMAT_VIDEO_views, "?i", &info->views,
":", SPA_FORMAT_VIDEO_interlaceMode, "?i", &info->interlace_mode,
":", SPA_FORMAT_VIDEO_pixelAspectRatio, "?F", &info->pixel_aspect_ratio,
":", SPA_FORMAT_VIDEO_multiviewMode, "?i", &info->multiview_mode,
":", SPA_FORMAT_VIDEO_multiviewFlags, "?i", &info->multiview_flags,
":", SPA_FORMAT_VIDEO_chromaSite, "?i", &info->chroma_site,
":", SPA_FORMAT_VIDEO_colorRange, "?i", &info->color_range,
":", SPA_FORMAT_VIDEO_colorMatrix, "?i", &info->color_matrix,
":", SPA_FORMAT_VIDEO_transferFunction, "?i", &info->transfer_function,
":", SPA_FORMAT_VIDEO_colorPrimaries, "?i", &info->color_primaries, NULL);
}
static inline int
spa_format_video_h264_parse(const struct spa_pod *format,
struct spa_video_info_h264 *info, struct spa_type_format_video *type)
struct spa_video_info_h264 *info)
{
return spa_pod_object_parse(format,
":",type->size, "?R", &info->size,
":",type->framerate, "?F", &info->framerate,
":",type->max_framerate, "?F", &info->max_framerate,
":",type->stream_format, "?i", &info->stream_format,
":",type->alignment, "?i", &info->alignment, NULL);
":", SPA_FORMAT_VIDEO_size, "?R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "?F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate,
":", SPA_FORMAT_VIDEO_streamFormat, "?i", &info->stream_format,
":", SPA_FORMAT_VIDEO_alignment, "?i", &info->alignment, NULL);
}
static inline int
spa_format_video_mjpg_parse(const struct spa_pod *format,
struct spa_video_info_mjpg *info, struct spa_type_format_video *type)
struct spa_video_info_mjpg *info)
{
return spa_pod_object_parse(format,
":",type->size, "?R", &info->size,
":",type->framerate, "?F", &info->framerate,
":",type->max_framerate, "?F", &info->max_framerate, NULL);
":", SPA_FORMAT_VIDEO_size, "?R", &info->size,
":", SPA_FORMAT_VIDEO_framerate, "?F", &info->framerate,
":", SPA_FORMAT_VIDEO_maxFramerate, "?F", &info->max_framerate, NULL);
}
#ifdef __cplusplus

25
spa/include/spa/param/video/format.h
View file

@ -24,10 +24,32 @@
extern "C" {
#endif
#include <spa/param/format-utils.h>
#include <spa/param/video/raw.h>
#include <spa/param/video/encoded.h>
/** properties for audio SPA_ID_OBJECT_Format */
enum spa_format_video {
SPA_FORMAT_VIDEO_format,
SPA_FORMAT_VIDEO_size,
SPA_FORMAT_VIDEO_framerate,
SPA_FORMAT_VIDEO_maxFramerate,
SPA_FORMAT_VIDEO_views,
SPA_FORMAT_VIDEO_interlaceMode,
SPA_FORMAT_VIDEO_pixelAspectRatio,
SPA_FORMAT_VIDEO_multiviewMode,
SPA_FORMAT_VIDEO_multiviewFlags,
SPA_FORMAT_VIDEO_chromaSite,
SPA_FORMAT_VIDEO_colorRange,
SPA_FORMAT_VIDEO_colorMatrix,
SPA_FORMAT_VIDEO_transferFunction,
SPA_FORMAT_VIDEO_colorPrimaries,
SPA_FORMAT_VIDEO_profile,
SPA_FORMAT_VIDEO_level,
SPA_FORMAT_VIDEO_streamFormat,
SPA_FORMAT_VIDEO_alignment,
};
#if 0
#define SPA_TYPE_FORMAT__Video SPA_TYPE_FORMAT_BASE "Video"
#define SPA_TYPE_FORMAT_VIDEO_BASE SPA_TYPE_FORMAT__Video ":"
@ -49,6 +71,7 @@ extern "C" {
#define SPA_TYPE_FORMAT_VIDEO__level SPA_TYPE_FORMAT_VIDEO_BASE "level"
#define SPA_TYPE_FORMAT_VIDEO__streamFormat SPA_TYPE_FORMAT_VIDEO_BASE "stream-format"
#define SPA_TYPE_FORMAT_VIDEO__alignment SPA_TYPE_FORMAT_VIDEO_BASE "alignment"
#endif
struct spa_video_info {
uint32_t media_type;

117
spa/include/spa/param/video/raw-types.h Normal file
View file

@ -0,0 +1,117 @@
/* 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_VIDEO_RAW_TYPES_H__
#define __SPA_VIDEO_RAW_TYPES_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/param/video/raw.h>
#define SPA_TYPE__VideoFormat SPA_TYPE_ENUM_BASE "VideoFormat"
#define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":"
static const struct spa_type_info spa_type_video_format[] = {
{ SPA_VIDEO_FORMAT_ENCODED, SPA_TYPE_VIDEO_FORMAT_BASE "encoded", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I420, SPA_TYPE_VIDEO_FORMAT_BASE "I420", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_YV12, SPA_TYPE_VIDEO_FORMAT_BASE "YV12", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_YUY2, SPA_TYPE_VIDEO_FORMAT_BASE "YUY2", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_UYVY, SPA_TYPE_VIDEO_FORMAT_BASE "UYVY", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_AYUV, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGBx, SPA_TYPE_VIDEO_FORMAT_BASE "RGBx", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_BGRx, SPA_TYPE_VIDEO_FORMAT_BASE "BGRx", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_xRGB, SPA_TYPE_VIDEO_FORMAT_BASE "xRGB", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_xBGR, SPA_TYPE_VIDEO_FORMAT_BASE "xBGR", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGBA, SPA_TYPE_VIDEO_FORMAT_BASE "RGBA", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_BGRA, SPA_TYPE_VIDEO_FORMAT_BASE "BGRA", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_ARGB, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_ABGR, SPA_TYPE_VIDEO_FORMAT_BASE "ABGR", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGB, SPA_TYPE_VIDEO_FORMAT_BASE "RGB", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_BGR, SPA_TYPE_VIDEO_FORMAT_BASE "BGR", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y41B, SPA_TYPE_VIDEO_FORMAT_BASE "Y41B", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y42B, SPA_TYPE_VIDEO_FORMAT_BASE "Y42B", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_YVYU, SPA_TYPE_VIDEO_FORMAT_BASE "YVYU", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y444, SPA_TYPE_VIDEO_FORMAT_BASE "Y444", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_v210, SPA_TYPE_VIDEO_FORMAT_BASE "v210", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_v216, SPA_TYPE_VIDEO_FORMAT_BASE "v216", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV12, SPA_TYPE_VIDEO_FORMAT_BASE "NV12", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV21, SPA_TYPE_VIDEO_FORMAT_BASE "NV21", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GRAY8, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY8", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GRAY16_BE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GRAY16_LE, SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_v308, SPA_TYPE_VIDEO_FORMAT_BASE "v308", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGB16, SPA_TYPE_VIDEO_FORMAT_BASE "RGB16", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_BGR16, SPA_TYPE_VIDEO_FORMAT_BASE "BGR16", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGB15, SPA_TYPE_VIDEO_FORMAT_BASE "RGB15", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_BGR15, SPA_TYPE_VIDEO_FORMAT_BASE "BGR15", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_UYVP, SPA_TYPE_VIDEO_FORMAT_BASE "UYVP", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A420, SPA_TYPE_VIDEO_FORMAT_BASE "A420", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_RGB8P, SPA_TYPE_VIDEO_FORMAT_BASE "RGB8P", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_YUV9, SPA_TYPE_VIDEO_FORMAT_BASE "YUV9", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_YVU9, SPA_TYPE_VIDEO_FORMAT_BASE "YVU9", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_IYU1, SPA_TYPE_VIDEO_FORMAT_BASE "IYU1", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_ARGB64, SPA_TYPE_VIDEO_FORMAT_BASE "ARGB64", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_AYUV64, SPA_TYPE_VIDEO_FORMAT_BASE "AYUV64", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_r210, SPA_TYPE_VIDEO_FORMAT_BASE "r210", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBR, SPA_TYPE_VIDEO_FORMAT_BASE "GBR", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBR_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBR_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV16, SPA_TYPE_VIDEO_FORMAT_BASE "NV16", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV24, SPA_TYPE_VIDEO_FORMAT_BASE "NV24", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV12_64Z32, SPA_TYPE_VIDEO_FORMAT_BASE "NV12_64Z32", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A420_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A420_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A420_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A422_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A422_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A422_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A444_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_A444_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "A444_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_NV61, SPA_TYPE_VIDEO_FORMAT_BASE "NV61", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_P010_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_P010_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "P010_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_IYU2, SPA_TYPE_VIDEO_FORMAT_BASE "IYU2", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_VYUY, SPA_TYPE_VIDEO_FORMAT_BASE "VYUY", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBRA, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBRA_10BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBRA_10LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBR_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBR_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBRA_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_GBRA_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I420_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I420_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I420_12LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I422_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_I422_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "I422_12LE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y444_12BE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12BE", SPA_POD_TYPE_INT, },
{ SPA_VIDEO_FORMAT_Y444_12LE, SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12LE", SPA_POD_TYPE_INT, },
{ 0, NULL, },
};
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_VIDEO_RAW_TYPES_H__ */

200
spa/include/spa/param/video/raw-utils.h
View file

@ -1,200 +0,0 @@
/* 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_VIDEO_RAW_UTILS_H__
#define __SPA_VIDEO_RAW_UTILS_H__
#ifdef __cplusplus
extern "C" {
#endif
#include <spa/support/type-map.h>
#include <spa/param/video/raw.h>
struct spa_type_video_format {
uint32_t UNKNOWN;
uint32_t ENCODED;
uint32_t I420;
uint32_t YV12;
uint32_t YUY2;
uint32_t UYVY;
uint32_t AYUV;
uint32_t RGBx;
uint32_t BGRx;
uint32_t xRGB;
uint32_t xBGR;
uint32_t RGBA;
uint32_t BGRA;
uint32_t ARGB;
uint32_t ABGR;
uint32_t RGB;
uint32_t BGR;
uint32_t Y41B;
uint32_t Y42B;
uint32_t YVYU;
uint32_t Y444;
uint32_t v210;
uint32_t v216;
uint32_t NV12;
uint32_t NV21;
uint32_t GRAY8;
uint32_t GRAY16_BE;
uint32_t GRAY16_LE;
uint32_t v308;
uint32_t RGB16;
uint32_t BGR16;
uint32_t RGB15;
uint32_t BGR15;
uint32_t UYVP;
uint32_t A420;
uint32_t RGB8P;
uint32_t YUV9;
uint32_t YVU9;
uint32_t IYU1;
uint32_t ARGB64;
uint32_t AYUV64;
uint32_t r210;
uint32_t I420_10BE;
uint32_t I420_10LE;
uint32_t I422_10BE;
uint32_t I422_10LE;
uint32_t Y444_10BE;
uint32_t Y444_10LE;
uint32_t GBR;
uint32_t GBR_10BE;
uint32_t GBR_10LE;
uint32_t NV16;
uint32_t NV24;
uint32_t NV12_64Z32;
uint32_t A420_10BE;
uint32_t A420_10LE;
uint32_t A422_10BE;
uint32_t A422_10LE;
uint32_t A444_10BE;
uint32_t A444_10LE;
uint32_t NV61;
uint32_t P010_10BE;
uint32_t P010_10LE;
uint32_t IYU2;
uint32_t VYUY;
uint32_t GBRA;
uint32_t GBRA_10BE;
uint32_t GBRA_10LE;
uint32_t GBR_12BE;
uint32_t GBR_12LE;
uint32_t GBRA_12BE;
uint32_t GBRA_12LE;
uint32_t I420_12BE;
uint32_t I420_12LE;
uint32_t I422_12BE;
uint32_t I422_12LE;
uint32_t Y444_12BE;
uint32_t Y444_12LE;
};
static inline void
spa_type_video_format_map(struct spa_type_map *map, struct spa_type_video_format *type)
{
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);
type->GBRA = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBRA);
type->GBRA_10BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBRA_10BE);
type->GBRA_10LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBRA_10LE);
type->GBR_12BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBR_12BE);
type->GBR_12LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBR_12LE);
type->GBRA_12BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBRA_12BE);
type->GBRA_12LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__GBRA_12LE);
type->I420_12BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__I420_12BE);
type->I420_12LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__I420_12LE);
type->I422_12BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__I422_12BE);
type->I422_12LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__I422_12LE);
type->Y444_12BE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__Y444_12BE);
type->Y444_12LE = spa_type_map_get_id(map, SPA_TYPE_VIDEO_FORMAT__Y444_12LE);
}
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* __SPA_VIDEO_RAW_UTILS_H__ */

163
spa/include/spa/param/video/raw.h
View file

@ -24,6 +24,7 @@
extern "C" {
#endif
#include <spa/utils/defs.h>
#include <spa/param/video/chroma.h>
#include <spa/param/video/color.h>
#include <spa/param/video/multiview.h>
@ -31,86 +32,86 @@ extern "C" {
#define SPA_VIDEO_MAX_PLANES 4
#define SPA_VIDEO_MAX_COMPONENTS 4
#define SPA_TYPE__VideoFormat SPA_TYPE_ENUM_BASE "VideoFormat"
#define SPA_TYPE_VIDEO_FORMAT_BASE SPA_TYPE__VideoFormat ":"
#define SPA_TYPE_VIDEO_FORMAT__ENCODED SPA_TYPE_VIDEO_FORMAT_BASE "encoded"
#define SPA_TYPE_VIDEO_FORMAT__I420 SPA_TYPE_VIDEO_FORMAT_BASE "I420"
#define SPA_TYPE_VIDEO_FORMAT__YV12 SPA_TYPE_VIDEO_FORMAT_BASE "YV12"
#define SPA_TYPE_VIDEO_FORMAT__YUY2 SPA_TYPE_VIDEO_FORMAT_BASE "YUY2"
#define SPA_TYPE_VIDEO_FORMAT__UYVY SPA_TYPE_VIDEO_FORMAT_BASE "UYVY"
#define SPA_TYPE_VIDEO_FORMAT__AYUV SPA_TYPE_VIDEO_FORMAT_BASE "AYUV"
#define SPA_TYPE_VIDEO_FORMAT__RGBx SPA_TYPE_VIDEO_FORMAT_BASE "RGBx"
#define SPA_TYPE_VIDEO_FORMAT__BGRx SPA_TYPE_VIDEO_FORMAT_BASE "BGRx"
#define SPA_TYPE_VIDEO_FORMAT__xRGB SPA_TYPE_VIDEO_FORMAT_BASE "xRGB"
#define SPA_TYPE_VIDEO_FORMAT__xBGR SPA_TYPE_VIDEO_FORMAT_BASE "xBGR"
#define SPA_TYPE_VIDEO_FORMAT__RGBA SPA_TYPE_VIDEO_FORMAT_BASE "RGBA"
#define SPA_TYPE_VIDEO_FORMAT__BGRA SPA_TYPE_VIDEO_FORMAT_BASE "BGRA"
#define SPA_TYPE_VIDEO_FORMAT__ARGB SPA_TYPE_VIDEO_FORMAT_BASE "ARGB"
#define SPA_TYPE_VIDEO_FORMAT__ABGR SPA_TYPE_VIDEO_FORMAT_BASE "ABGR"
#define SPA_TYPE_VIDEO_FORMAT__RGB SPA_TYPE_VIDEO_FORMAT_BASE "RGB"
#define SPA_TYPE_VIDEO_FORMAT__BGR SPA_TYPE_VIDEO_FORMAT_BASE "BGR"
#define SPA_TYPE_VIDEO_FORMAT__Y41B SPA_TYPE_VIDEO_FORMAT_BASE "Y41B"
#define SPA_TYPE_VIDEO_FORMAT__Y42B SPA_TYPE_VIDEO_FORMAT_BASE "Y42B"
#define SPA_TYPE_VIDEO_FORMAT__YVYU SPA_TYPE_VIDEO_FORMAT_BASE "YVYU"
#define SPA_TYPE_VIDEO_FORMAT__Y444 SPA_TYPE_VIDEO_FORMAT_BASE "Y444"
#define SPA_TYPE_VIDEO_FORMAT__v210 SPA_TYPE_VIDEO_FORMAT_BASE "v210"
#define SPA_TYPE_VIDEO_FORMAT__v216 SPA_TYPE_VIDEO_FORMAT_BASE "v216"
#define SPA_TYPE_VIDEO_FORMAT__NV12 SPA_TYPE_VIDEO_FORMAT_BASE "NV12"
#define SPA_TYPE_VIDEO_FORMAT__NV21 SPA_TYPE_VIDEO_FORMAT_BASE "NV21"
#define SPA_TYPE_VIDEO_FORMAT__GRAY8 SPA_TYPE_VIDEO_FORMAT_BASE "GRAY8"
#define SPA_TYPE_VIDEO_FORMAT__GRAY16_BE SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_BE"
#define SPA_TYPE_VIDEO_FORMAT__GRAY16_LE SPA_TYPE_VIDEO_FORMAT_BASE "GRAY16_LE"
#define SPA_TYPE_VIDEO_FORMAT__v308 SPA_TYPE_VIDEO_FORMAT_BASE "v308"
#define SPA_TYPE_VIDEO_FORMAT__RGB16 SPA_TYPE_VIDEO_FORMAT_BASE "RGB16"
#define SPA_TYPE_VIDEO_FORMAT__BGR16 SPA_TYPE_VIDEO_FORMAT_BASE "BGR16"
#define SPA_TYPE_VIDEO_FORMAT__RGB15 SPA_TYPE_VIDEO_FORMAT_BASE "RGB15"
#define SPA_TYPE_VIDEO_FORMAT__BGR15 SPA_TYPE_VIDEO_FORMAT_BASE "BGR15"
#define SPA_TYPE_VIDEO_FORMAT__UYVP SPA_TYPE_VIDEO_FORMAT_BASE "UYVP"
#define SPA_TYPE_VIDEO_FORMAT__A420 SPA_TYPE_VIDEO_FORMAT_BASE "A420"
#define SPA_TYPE_VIDEO_FORMAT__RGB8P SPA_TYPE_VIDEO_FORMAT_BASE "RGB8P"
#define SPA_TYPE_VIDEO_FORMAT__YUV9 SPA_TYPE_VIDEO_FORMAT_BASE "YUV9"
#define SPA_TYPE_VIDEO_FORMAT__YVU9 SPA_TYPE_VIDEO_FORMAT_BASE "YVU9"
#define SPA_TYPE_VIDEO_FORMAT__IYU1 SPA_TYPE_VIDEO_FORMAT_BASE "IYU1"
#define SPA_TYPE_VIDEO_FORMAT__ARGB64 SPA_TYPE_VIDEO_FORMAT_BASE "ARGB64"
#define SPA_TYPE_VIDEO_FORMAT__AYUV64 SPA_TYPE_VIDEO_FORMAT_BASE "AYUV64"
#define SPA_TYPE_VIDEO_FORMAT__r210 SPA_TYPE_VIDEO_FORMAT_BASE "r210"
#define SPA_TYPE_VIDEO_FORMAT__I420_10BE SPA_TYPE_VIDEO_FORMAT_BASE "I420_10BE"
#define SPA_TYPE_VIDEO_FORMAT__I420_10LE SPA_TYPE_VIDEO_FORMAT_BASE "I420_10LE"
#define SPA_TYPE_VIDEO_FORMAT__I422_10BE SPA_TYPE_VIDEO_FORMAT_BASE "I422_10BE"
#define SPA_TYPE_VIDEO_FORMAT__I422_10LE SPA_TYPE_VIDEO_FORMAT_BASE "I422_10LE"
#define SPA_TYPE_VIDEO_FORMAT__Y444_10BE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10BE"
#define SPA_TYPE_VIDEO_FORMAT__Y444_10LE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_10LE"
#define SPA_TYPE_VIDEO_FORMAT__GBR SPA_TYPE_VIDEO_FORMAT_BASE "GBR"
#define SPA_TYPE_VIDEO_FORMAT__GBR_10BE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10BE"
#define SPA_TYPE_VIDEO_FORMAT__GBR_10LE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_10LE"
#define SPA_TYPE_VIDEO_FORMAT__NV16 SPA_TYPE_VIDEO_FORMAT_BASE "NV16"
#define SPA_TYPE_VIDEO_FORMAT__NV24 SPA_TYPE_VIDEO_FORMAT_BASE "NV24"
#define SPA_TYPE_VIDEO_FORMAT__NV12_64Z32 SPA_TYPE_VIDEO_FORMAT_BASE "NV12_64Z32"
#define SPA_TYPE_VIDEO_FORMAT__A420_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A420_10BE"
#define SPA_TYPE_VIDEO_FORMAT__A420_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A420_10LE"
#define SPA_TYPE_VIDEO_FORMAT__A422_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A422_10BE"
#define SPA_TYPE_VIDEO_FORMAT__A422_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A422_10LE"
#define SPA_TYPE_VIDEO_FORMAT__A444_10BE SPA_TYPE_VIDEO_FORMAT_BASE "A444_10BE"
#define SPA_TYPE_VIDEO_FORMAT__A444_10LE SPA_TYPE_VIDEO_FORMAT_BASE "A444_10LE"
#define SPA_TYPE_VIDEO_FORMAT__NV61 SPA_TYPE_VIDEO_FORMAT_BASE "NV61"
#define SPA_TYPE_VIDEO_FORMAT__P010_10BE SPA_TYPE_VIDEO_FORMAT_BASE "P010_10BE"
#define SPA_TYPE_VIDEO_FORMAT__P010_10LE SPA_TYPE_VIDEO_FORMAT_BASE "P010_10LE"
#define SPA_TYPE_VIDEO_FORMAT__IYU2 SPA_TYPE_VIDEO_FORMAT_BASE "IYU2"
#define SPA_TYPE_VIDEO_FORMAT__VYUY SPA_TYPE_VIDEO_FORMAT_BASE "VYUY"
#define SPA_TYPE_VIDEO_FORMAT__GBRA SPA_TYPE_VIDEO_FORMAT_BASE "GBRA"
#define SPA_TYPE_VIDEO_FORMAT__GBRA_10BE SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10BE"
#define SPA_TYPE_VIDEO_FORMAT__GBRA_10LE SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_10LE"
#define SPA_TYPE_VIDEO_FORMAT__GBR_12BE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12BE"
#define SPA_TYPE_VIDEO_FORMAT__GBR_12LE SPA_TYPE_VIDEO_FORMAT_BASE "GBR_12LE"
#define SPA_TYPE_VIDEO_FORMAT__GBRA_12BE SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12BE"
#define SPA_TYPE_VIDEO_FORMAT__GBRA_12LE SPA_TYPE_VIDEO_FORMAT_BASE "GBRA_12LE"
#define SPA_TYPE_VIDEO_FORMAT__I420_12BE SPA_TYPE_VIDEO_FORMAT_BASE "I420_12BE"
#define SPA_TYPE_VIDEO_FORMAT__I420_12LE SPA_TYPE_VIDEO_FORMAT_BASE "I420_12LE"
#define SPA_TYPE_VIDEO_FORMAT__I422_12BE SPA_TYPE_VIDEO_FORMAT_BASE "I422_12BE"
#define SPA_TYPE_VIDEO_FORMAT__I422_12LE SPA_TYPE_VIDEO_FORMAT_BASE "I422_12LE"
#define SPA_TYPE_VIDEO_FORMAT__Y444_12BE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12BE"
#define SPA_TYPE_VIDEO_FORMAT__Y444_12LE SPA_TYPE_VIDEO_FORMAT_BASE "Y444_12LE"
enum spa_video_format {
SPA_VIDEO_FORMAT_UNKNOWN,
SPA_VIDEO_FORMAT_ENCODED,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YV12,
SPA_VIDEO_FORMAT_YUY2,
SPA_VIDEO_FORMAT_UYVY,
SPA_VIDEO_FORMAT_AYUV,
SPA_VIDEO_FORMAT_RGBx,
SPA_VIDEO_FORMAT_BGRx,
SPA_VIDEO_FORMAT_xRGB,
SPA_VIDEO_FORMAT_xBGR,
SPA_VIDEO_FORMAT_RGBA,
SPA_VIDEO_FORMAT_BGRA,
SPA_VIDEO_FORMAT_ARGB,
SPA_VIDEO_FORMAT_ABGR,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_BGR,
SPA_VIDEO_FORMAT_Y41B,
SPA_VIDEO_FORMAT_Y42B,
SPA_VIDEO_FORMAT_YVYU,
SPA_VIDEO_FORMAT_Y444,
SPA_VIDEO_FORMAT_v210,
SPA_VIDEO_FORMAT_v216,
SPA_VIDEO_FORMAT_NV12,
SPA_VIDEO_FORMAT_NV21,
SPA_VIDEO_FORMAT_GRAY8,
SPA_VIDEO_FORMAT_GRAY16_BE,
SPA_VIDEO_FORMAT_GRAY16_LE,
SPA_VIDEO_FORMAT_v308,
SPA_VIDEO_FORMAT_RGB16,
SPA_VIDEO_FORMAT_BGR16,
SPA_VIDEO_FORMAT_RGB15,
SPA_VIDEO_FORMAT_BGR15,
SPA_VIDEO_FORMAT_UYVP,
SPA_VIDEO_FORMAT_A420,
SPA_VIDEO_FORMAT_RGB8P,
SPA_VIDEO_FORMAT_YUV9,
SPA_VIDEO_FORMAT_YVU9,
SPA_VIDEO_FORMAT_IYU1,
SPA_VIDEO_FORMAT_ARGB64,
SPA_VIDEO_FORMAT_AYUV64,
SPA_VIDEO_FORMAT_r210,
SPA_VIDEO_FORMAT_I420_10BE,
SPA_VIDEO_FORMAT_I420_10LE,
SPA_VIDEO_FORMAT_I422_10BE,
SPA_VIDEO_FORMAT_I422_10LE,
SPA_VIDEO_FORMAT_Y444_10BE,
SPA_VIDEO_FORMAT_Y444_10LE,
SPA_VIDEO_FORMAT_GBR,
SPA_VIDEO_FORMAT_GBR_10BE,
SPA_VIDEO_FORMAT_GBR_10LE,
SPA_VIDEO_FORMAT_NV16,
SPA_VIDEO_FORMAT_NV24,
SPA_VIDEO_FORMAT_NV12_64Z32,
SPA_VIDEO_FORMAT_A420_10BE,
SPA_VIDEO_FORMAT_A420_10LE,
SPA_VIDEO_FORMAT_A422_10BE,
SPA_VIDEO_FORMAT_A422_10LE,
SPA_VIDEO_FORMAT_A444_10BE,
SPA_VIDEO_FORMAT_A444_10LE,
SPA_VIDEO_FORMAT_NV61,
SPA_VIDEO_FORMAT_P010_10BE,
SPA_VIDEO_FORMAT_P010_10LE,
SPA_VIDEO_FORMAT_IYU2,
SPA_VIDEO_FORMAT_VYUY,
SPA_VIDEO_FORMAT_GBRA,
SPA_VIDEO_FORMAT_GBRA_10BE,
SPA_VIDEO_FORMAT_GBRA_10LE,
SPA_VIDEO_FORMAT_GBR_12BE,
SPA_VIDEO_FORMAT_GBR_12LE,
SPA_VIDEO_FORMAT_GBRA_12BE,
SPA_VIDEO_FORMAT_GBRA_12LE,
SPA_VIDEO_FORMAT_I420_12BE,
SPA_VIDEO_FORMAT_I420_12LE,
SPA_VIDEO_FORMAT_I422_12BE,
SPA_VIDEO_FORMAT_I422_12LE,
SPA_VIDEO_FORMAT_Y444_12BE,
SPA_VIDEO_FORMAT_Y444_12LE,
};
/**
* spa_video_flags:
@ -174,7 +175,7 @@ enum spa_video_interlace_mode {
* @color_primaries: color primaries. used to convert between R'G'B' and CIE XYZ
*/
struct spa_video_info_raw {
uint32_t format;
enum spa_video_format format;
struct spa_rectangle size;
struct spa_fraction framerate;
struct spa_fraction max_framerate;