mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

format: make formats as uri

Browse source
This commit is contained in:
Wim Taymans 2017-03-21 13:36:22 +01:00
parent 6f0a12462b
commit ff62c1b9ce
11 changed files with 476 additions and 222 deletions
Download patch file Download diff file Expand all files Collapse all files

77
pinos/gst/gstpinosformat.c
View file

@ -17,6 +17,7 @@
* Boston, MA 02110-1301, USA.
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <gst/gst.h>
@ -43,6 +44,7 @@ static SpaMediaSubtypesVideo media_subtypes_video = { 0, };
static SpaMediaSubtypesAudio media_subtypes_audio = { 0, };
static SpaPropVideo prop_video = { 0, };
static SpaPropAudio prop_audio = { 0, };
static SpaVideoFormats video_formats = { 0, };
static void
ensure_types (void)
@ -53,6 +55,7 @@ ensure_types (void)
spa_media_subtypes_audio_map (spa_id_map_get_default (), &media_subtypes_audio);
spa_prop_video_map (spa_id_map_get_default (), &prop_video);
spa_prop_audio_map (spa_id_map_get_default (), &prop_audio);
spa_video_formats_map (spa_id_map_get_default (), &video_formats);
}
static const MediaType media_type_map[] = {
@ -63,6 +66,74 @@ static const MediaType media_type_map[] = {
{ NULL, }
};
static const uint32_t *video_format_map[] = {
&video_formats.UNKNOWN,
&video_formats.ENCODED,
&video_formats.I420,
&video_formats.YV12,
&video_formats.YUY2,
&video_formats.UYVY,
&video_formats.AYUV,
&video_formats.RGBx,
&video_formats.BGRx,
&video_formats.xRGB,
&video_formats.xBGR,
&video_formats.RGBA,
&video_formats.BGRA,
&video_formats.ARGB,
&video_formats.ABGR,
&video_formats.RGB,
&video_formats.BGR,
&video_formats.Y41B,
&video_formats.Y42B,
&video_formats.YVYU,
&video_formats.Y444,
&video_formats.v210,
&video_formats.v216,
&video_formats.NV12,
&video_formats.NV21,
&video_formats.GRAY8,
&video_formats.GRAY16_BE,
&video_formats.GRAY16_LE,
&video_formats.v308,
&video_formats.RGB16,
&video_formats.BGR16,
&video_formats.RGB15,
&video_formats.BGR15,
&video_formats.UYVP,
&video_formats.A420,
&video_formats.RGB8P,
&video_formats.YUV9,
&video_formats.YVU9,
&video_formats.IYU1,
&video_formats.ARGB64,
&video_formats.AYUV64,
&video_formats.r210,
&video_formats.I420_10BE,
&video_formats.I420_10LE,
&video_formats.I422_10BE,
&video_formats.I422_10LE,
&video_formats.Y444_10BE,
&video_formats.Y444_10LE,
&video_formats.GBR,
&video_formats.GBR_10BE,
&video_formats.GBR_10LE,
&video_formats.NV16,
&video_formats.NV24,
&video_formats.NV12_64Z32,
&video_formats.A420_10BE,
&video_formats.A420_10LE,
&video_formats.A422_10BE,
&video_formats.A422_10LE,
&video_formats.A444_10BE,
&video_formats.A444_10LE,
&video_formats.NV61,
&video_formats.P010_10BE,
&video_formats.P010_10LE,
&video_formats.IYU2,
&video_formats.VYUY,
};
typedef struct {
SpaPODBuilder b;
const MediaType *type;
@ -251,7 +322,7 @@ handle_video_fields (ConvertData *d)
prop_video.format,
get_range_type (value) | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_int (&d->b, gst_video_format_from_string (v));
spa_pod_builder_uri (&d->b, *video_format_map[gst_video_format_from_string (v)]);
}
if (i > 1)
SPA_POD_BUILDER_DEREF (&d->b, f.ref, SpaPODProp)->body.flags |= SPA_POD_PROP_FLAG_UNSET;
@ -480,8 +551,10 @@ gst_caps_from_format (const SpaFormat *format)
return NULL;
if (media_subtype == media_subtypes.raw) {
const char * str = spa_id_map_get_uri (spa_id_map_get_default (), f.info.raw.format);
res = gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, gst_video_format_to_string (f.info.raw.format),
"format", G_TYPE_STRING, strstr (str, "#") + 1,
"width", G_TYPE_INT, f.info.raw.size.width,
"height", G_TYPE_INT, f.info.raw.size.height,
"framerate", GST_TYPE_FRACTION, f.info.raw.framerate.num, f.info.raw.framerate.denom,

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

@ -27,83 +27,222 @@ extern "C" {
typedef struct _SpaVideoInfoRaw SpaVideoInfoRaw;
#include <spa/props.h>
#include <spa/id-map.h>
#include <spa/video/chroma.h>
#include <spa/video/color.h>
#include <spa/video/multiview.h>
#include <endian.h>
#define SPA_VIDEO_MAX_PLANES 4
#define SPA_VIDEO_MAX_COMPONENTS 4
typedef enum {
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,
} SpaVideoFormat;
#define SPA_VIDEO_FORMAT_URI "http://spaplug.in/ns/video-format"
#define SPA_VIDEO_FORMAT_PREFIX SPA_VIDEO_FORMAT_URI "#"
#define SPA_VIDEO_FORMAT__ENCODED SPA_VIDEO_FORMAT_PREFIX "encoded"
#define SPA_VIDEO_FORMAT__I420 SPA_VIDEO_FORMAT_PREFIX "I420"
#define SPA_VIDEO_FORMAT__YV12 SPA_VIDEO_FORMAT_PREFIX "YV12"
#define SPA_VIDEO_FORMAT__YUY2 SPA_VIDEO_FORMAT_PREFIX "YUY2"
#define SPA_VIDEO_FORMAT__UYVY SPA_VIDEO_FORMAT_PREFIX "UYVY"
#define SPA_VIDEO_FORMAT__AYUV SPA_VIDEO_FORMAT_PREFIX "AYUV"
#define SPA_VIDEO_FORMAT__RGBx SPA_VIDEO_FORMAT_PREFIX "RGBx"
#define SPA_VIDEO_FORMAT__BGRx SPA_VIDEO_FORMAT_PREFIX "BGRx"
#define SPA_VIDEO_FORMAT__xRGB SPA_VIDEO_FORMAT_PREFIX "xRGB"
#define SPA_VIDEO_FORMAT__xBGR SPA_VIDEO_FORMAT_PREFIX "xBGR"
#define SPA_VIDEO_FORMAT__RGBA SPA_VIDEO_FORMAT_PREFIX "RGBA"
#define SPA_VIDEO_FORMAT__BGRA SPA_VIDEO_FORMAT_PREFIX "BGRA"
#define SPA_VIDEO_FORMAT__ARGB SPA_VIDEO_FORMAT_PREFIX "ARGB"
#define SPA_VIDEO_FORMAT__ABGR SPA_VIDEO_FORMAT_PREFIX "ABGR"
#define SPA_VIDEO_FORMAT__RGB SPA_VIDEO_FORMAT_PREFIX "RGB"
#define SPA_VIDEO_FORMAT__BGR SPA_VIDEO_FORMAT_PREFIX "BGR"
#define SPA_VIDEO_FORMAT__Y41B SPA_VIDEO_FORMAT_PREFIX "Y41B"
#define SPA_VIDEO_FORMAT__Y42B SPA_VIDEO_FORMAT_PREFIX "Y42B"
#define SPA_VIDEO_FORMAT__YVYU SPA_VIDEO_FORMAT_PREFIX "YVYU"
#define SPA_VIDEO_FORMAT__Y444 SPA_VIDEO_FORMAT_PREFIX "Y444"
#define SPA_VIDEO_FORMAT__v210 SPA_VIDEO_FORMAT_PREFIX "v210"
#define SPA_VIDEO_FORMAT__v216 SPA_VIDEO_FORMAT_PREFIX "v216"
#define SPA_VIDEO_FORMAT__NV12 SPA_VIDEO_FORMAT_PREFIX "NV12"
#define SPA_VIDEO_FORMAT__NV21 SPA_VIDEO_FORMAT_PREFIX "NV21"
#define SPA_VIDEO_FORMAT__GRAY8 SPA_VIDEO_FORMAT_PREFIX "GRAY8"
#define SPA_VIDEO_FORMAT__GRAY16_BE SPA_VIDEO_FORMAT_PREFIX "GRAY16_BE"
#define SPA_VIDEO_FORMAT__GRAY16_LE SPA_VIDEO_FORMAT_PREFIX "GRAY16_LE"
#define SPA_VIDEO_FORMAT__v308 SPA_VIDEO_FORMAT_PREFIX "v308"
#define SPA_VIDEO_FORMAT__RGB16 SPA_VIDEO_FORMAT_PREFIX "RGB16"
#define SPA_VIDEO_FORMAT__BGR16 SPA_VIDEO_FORMAT_PREFIX "BGR16"
#define SPA_VIDEO_FORMAT__RGB15 SPA_VIDEO_FORMAT_PREFIX "RGB15"
#define SPA_VIDEO_FORMAT__BGR15 SPA_VIDEO_FORMAT_PREFIX "BGR15"
#define SPA_VIDEO_FORMAT__UYVP SPA_VIDEO_FORMAT_PREFIX "UYVP"
#define SPA_VIDEO_FORMAT__A420 SPA_VIDEO_FORMAT_PREFIX "A420"
#define SPA_VIDEO_FORMAT__RGB8P SPA_VIDEO_FORMAT_PREFIX "RGB8P"
#define SPA_VIDEO_FORMAT__YUV9 SPA_VIDEO_FORMAT_PREFIX "YUV9"
#define SPA_VIDEO_FORMAT__YVU9 SPA_VIDEO_FORMAT_PREFIX "YVU9"
#define SPA_VIDEO_FORMAT__IYU1 SPA_VIDEO_FORMAT_PREFIX "IYU1"
#define SPA_VIDEO_FORMAT__ARGB64 SPA_VIDEO_FORMAT_PREFIX "ARGB64"
#define SPA_VIDEO_FORMAT__AYUV64 SPA_VIDEO_FORMAT_PREFIX "AYUV64"
#define SPA_VIDEO_FORMAT__r210 SPA_VIDEO_FORMAT_PREFIX "r210"
#define SPA_VIDEO_FORMAT__I420_10BE SPA_VIDEO_FORMAT_PREFIX "I420_10BE"
#define SPA_VIDEO_FORMAT__I420_10LE SPA_VIDEO_FORMAT_PREFIX "I420_10LE"
#define SPA_VIDEO_FORMAT__I422_10BE SPA_VIDEO_FORMAT_PREFIX "I422_10BE"
#define SPA_VIDEO_FORMAT__I422_10LE SPA_VIDEO_FORMAT_PREFIX "I422_10LE"
#define SPA_VIDEO_FORMAT__Y444_10BE SPA_VIDEO_FORMAT_PREFIX "Y444_10BE"
#define SPA_VIDEO_FORMAT__Y444_10LE SPA_VIDEO_FORMAT_PREFIX "Y444_10LE"
#define SPA_VIDEO_FORMAT__GBR SPA_VIDEO_FORMAT_PREFIX "GBR"
#define SPA_VIDEO_FORMAT__GBR_10BE SPA_VIDEO_FORMAT_PREFIX "GBR_10BE"
#define SPA_VIDEO_FORMAT__GBR_10LE SPA_VIDEO_FORMAT_PREFIX "GBR_10LE"
#define SPA_VIDEO_FORMAT__NV16 SPA_VIDEO_FORMAT_PREFIX "NV16"
#define SPA_VIDEO_FORMAT__NV24 SPA_VIDEO_FORMAT_PREFIX "NV24"
#define SPA_VIDEO_FORMAT__NV12_64Z32 SPA_VIDEO_FORMAT_PREFIX "NV12_64Z32"
#define SPA_VIDEO_FORMAT__A420_10BE SPA_VIDEO_FORMAT_PREFIX "A420_10BE"
#define SPA_VIDEO_FORMAT__A420_10LE SPA_VIDEO_FORMAT_PREFIX "A420_10LE"
#define SPA_VIDEO_FORMAT__A422_10BE SPA_VIDEO_FORMAT_PREFIX "A422_10BE"
#define SPA_VIDEO_FORMAT__A422_10LE SPA_VIDEO_FORMAT_PREFIX "A422_10LE"
#define SPA_VIDEO_FORMAT__A444_10BE SPA_VIDEO_FORMAT_PREFIX "A444_10BE"
#define SPA_VIDEO_FORMAT__A444_10LE SPA_VIDEO_FORMAT_PREFIX "A444_10LE"
#define SPA_VIDEO_FORMAT__NV61 SPA_VIDEO_FORMAT_PREFIX "NV61"
#define SPA_VIDEO_FORMAT__P010_10BE SPA_VIDEO_FORMAT_PREFIX "P010_10BE"
#define SPA_VIDEO_FORMAT__P010_10LE SPA_VIDEO_FORMAT_PREFIX "P010_10LE"
#define SPA_VIDEO_FORMAT__IYU2 SPA_VIDEO_FORMAT_PREFIX "IYU2"
#define SPA_VIDEO_FORMAT__VYUY SPA_VIDEO_FORMAT_PREFIX "VYUY"
typedef struct
{
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;
} SpaVideoFormats;
static inline void
spa_video_formats_map (SpaIDMap *map, SpaVideoFormats *types)
{
if (types->ENCODED == 0) {
types->UNKNOWN = 0;
types->ENCODED = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ENCODED);
types->I420 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420);
types->YV12 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YV12);
types->YUY2 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YUY2);
types->UYVY = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__UYVY);
types->AYUV = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__AYUV);
types->RGBx = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGBx);
types->BGRx = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGRx);
types->xRGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__xRGB);
types->xBGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__xBGR);
types->RGBA = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGBA);
types->BGRA = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGRA);
types->ARGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ARGB);
types->ABGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ABGR);
types->RGB = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB);
types->BGR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR);
types->Y41B = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y41B);
types->Y42B = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y42B);
types->YVYU = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YVYU);
types->Y444 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444);
types->v210 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v210);
types->v216 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v216);
types->NV12 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV12);
types->NV21 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV21);
types->GRAY8 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY8);
types->GRAY16_BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY16_BE);
types->GRAY16_LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GRAY16_LE);
types->v308 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__v308);
types->RGB16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB16);
types->BGR16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR16);
types->RGB15 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB15);
types->BGR15 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__BGR15);
types->UYVP = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__UYVP);
types->A420 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420);
types->RGB8P = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__RGB8P);
types->YUV9 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YUV9);
types->YVU9 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__YVU9);
types->IYU1 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__IYU1);
types->ARGB64 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__ARGB64);
types->AYUV64 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__AYUV64);
types->r210 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__r210);
types->I420_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420_10BE);
types->I420_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I420_10LE);
types->I422_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I422_10BE);
types->I422_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__I422_10LE);
types->Y444_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444_10BE);
types->Y444_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__Y444_10LE);
types->GBR = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR);
types->GBR_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR_10BE);
types->GBR_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__GBR_10LE);
types->NV16 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV16);
types->NV24 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV24);
types->NV12_64Z32 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV12_64Z32);
types->A420_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420_10BE);
types->A420_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A420_10LE);
types->A422_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A422_10BE);
types->A422_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A422_10LE);
types->A444_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A444_10BE);
types->A444_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__A444_10LE);
types->NV61 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__NV61);
types->P010_10BE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__P010_10BE);
types->P010_10LE = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__P010_10LE);
types->IYU2 = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__IYU2);
types->VYUY = spa_id_map_get_id (map, SPA_VIDEO_FORMAT__VYUY);
}
}
/**
* SpaVideoFlags:
@ -167,7 +306,7 @@ typedef enum {
* @color_primaries: color primaries. used to convert between R'G'B' and CIE XYZ
*/
struct _SpaVideoInfoRaw {
SpaVideoFormat format;
uint32_t format;
SpaRectangle size;
SpaFraction framerate;
SpaFraction max_framerate;

12
spa/lib/debug.c
View file

@ -322,8 +322,18 @@ print_format_value (uint32_t size, uint32_t type, void *body)
fprintf (stderr, "%s", *(int32_t *) body ? "true" : "false");
break;
case SPA_POD_TYPE_URI:
fprintf (stderr, "%"PRIi32, *(int32_t *) body);
{
const char *str = spa_id_map_get_uri (spa_id_map_get_default(), *(int32_t*)body);
if (str) {
const char *h = strstr (str, "#");
if (h)
str = h + 1;
} else {
str = "unknown";
}
fprintf (stderr, "%s", str);
break;
}
case SPA_POD_TYPE_INT:
fprintf (stderr, "%"PRIi32, *(int32_t *) body);
break;

3
spa/lib/mapper.c
View file

@ -61,7 +61,8 @@ id_map_get_uri (SpaIDMap *map, uint32_t id)
if (id < this->n_uris)
return this->uris[id];
return 0;
return NULL;
}
static IDMap default_id_map = {

1
spa/lib/props.c
View file

@ -31,6 +31,7 @@ compare_value (SpaPODType type, const void *r1, const void *r2)
case SPA_POD_TYPE_INVALID:
return 0;
case SPA_POD_TYPE_BOOL:
case SPA_POD_TYPE_URI:
return *(int32_t*)r1 == *(uint32_t*)r2;
case SPA_POD_TYPE_INT:
return *(int32_t*)r1 - *(int32_t*)r2;

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

@ -50,7 +50,7 @@ spa_format_video_parse (const SpaFormat *format,
if (info->media_subtype == media_subtypes.raw)
spa_format_query (format,
prop_video.format, SPA_POD_TYPE_INT, &info->info.raw.format,
prop_video.format, SPA_POD_TYPE_URI, &info->info.raw.format,
prop_video.size, SPA_POD_TYPE_RECTANGLE, &info->info.raw.size,
prop_video.framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.framerate,
prop_video.max_framerate, SPA_POD_TYPE_FRACTION, &info->info.raw.max_framerate,

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

@ -69,6 +69,7 @@ typedef struct {
SpaMediaSubtypes media_subtypes;
SpaMediaSubtypesVideo media_subtypes_video;
SpaPropVideo prop_video;
SpaVideoFormats video_formats;
} URI;
typedef struct {
@ -579,7 +580,7 @@ spa_v4l2_source_node_port_get_format (SpaNode *node,
if (state->current_format.media_subtype == this->uri.media_subtypes.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_INT, state->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, state->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &state->current_format.info.raw.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &state->current_format.info.raw.framerate),
0);
@ -972,6 +973,7 @@ v4l2_source_init (const SpaHandleFactory *factory,
spa_media_subtypes_map (this->map, &this->uri.media_subtypes);
spa_media_subtypes_video_map (this->map, &this->uri.media_subtypes_video);
spa_prop_video_map (this->map, &this->uri.prop_video);
spa_video_formats_map (this->map, &this->uri.video_formats);
this->node = v4l2source_node;
this->clock = v4l2source_clock;

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

@ -164,7 +164,7 @@ spa_v4l2_close (SpaV4l2Source *this)
typedef struct {
uint32_t fourcc;
SpaVideoFormat format;
off_t format_offset;
off_t media_type_offset;
off_t media_subtype_offset;
} FormatInfo;
@ -188,114 +188,143 @@ typedef struct {
#define VC1 offsetof(URI, media_subtypes_video.vc1)
#define VP8 offsetof(URI, media_subtypes_video.vp8)
#define FORMAT_UNKNOWN offsetof(URI, video_formats.UNKNOWN)
#define FORMAT_ENCODED offsetof(URI, video_formats.ENCODED)
#define FORMAT_RGB15 offsetof(URI, video_formats.RGB15)
#define FORMAT_BGR15 offsetof(URI, video_formats.BGR15)
#define FORMAT_RGB16 offsetof(URI, video_formats.RGB16)
#define FORMAT_BGR offsetof(URI, video_formats.BGR)
#define FORMAT_RGB offsetof(URI, video_formats.RGB)
#define FORMAT_BGRA offsetof(URI, video_formats.BGRA)
#define FORMAT_BGRx offsetof(URI, video_formats.BGRx)
#define FORMAT_ARGB offsetof(URI, video_formats.ARGB)
#define FORMAT_xRGB offsetof(URI, video_formats.xRGB)
#define FORMAT_GRAY8 offsetof(URI, video_formats.GRAY8)
#define FORMAT_GRAY16_LE offsetof(URI, video_formats.GRAY16_LE)
#define FORMAT_GRAY16_BE offsetof(URI, video_formats.GRAY16_BE)
#define FORMAT_YVU9 offsetof(URI, video_formats.YVU9)
#define FORMAT_YV12 offsetof(URI, video_formats.YV12)
#define FORMAT_YUY2 offsetof(URI, video_formats.YUY2)
#define FORMAT_YVYU offsetof(URI, video_formats.YVYU)
#define FORMAT_UYVY offsetof(URI, video_formats.UYVY)
#define FORMAT_Y42B offsetof(URI, video_formats.Y42B)
#define FORMAT_Y41B offsetof(URI, video_formats.Y41B)
#define FORMAT_YUV9 offsetof(URI, video_formats.YUV9)
#define FORMAT_I420 offsetof(URI, video_formats.I420)
#define FORMAT_NV12 offsetof(URI, video_formats.NV12)
#define FORMAT_NV12_64Z32 offsetof(URI, video_formats.NV12_64Z32)
#define FORMAT_NV21 offsetof(URI, video_formats.NV21)
#define FORMAT_NV16 offsetof(URI, video_formats.NV16)
#define FORMAT_NV61 offsetof(URI, video_formats.NV61)
#define FORMAT_NV24 offsetof(URI, video_formats.NV24)
static const FormatInfo format_info[] =
{
/* RGB formats */
{ V4L2_PIX_FMT_RGB332, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB555, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB555, SPA_VIDEO_FORMAT_RGB15, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB555X, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB555X, SPA_VIDEO_FORMAT_BGR15, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB565, SPA_VIDEO_FORMAT_RGB16, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB565X, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR666, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR24, SPA_VIDEO_FORMAT_BGR, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB24, SPA_VIDEO_FORMAT_RGB, VIDEO, RAW },
{ V4L2_PIX_FMT_ABGR32, SPA_VIDEO_FORMAT_BGRA, VIDEO, RAW },
{ V4L2_PIX_FMT_XBGR32, SPA_VIDEO_FORMAT_BGRx, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB32, SPA_VIDEO_FORMAT_ARGB, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB32, SPA_VIDEO_FORMAT_xRGB, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB332, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB555, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB555, FORMAT_RGB15, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB555X, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB555X, FORMAT_BGR15, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB565, FORMAT_RGB16, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB565X, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR666, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR24, FORMAT_BGR, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB24, FORMAT_RGB, VIDEO, RAW },
{ V4L2_PIX_FMT_ABGR32, FORMAT_BGRA, VIDEO, RAW },
{ V4L2_PIX_FMT_XBGR32, FORMAT_BGRx, VIDEO, RAW },
{ V4L2_PIX_FMT_ARGB32, FORMAT_ARGB, VIDEO, RAW },
{ V4L2_PIX_FMT_XRGB32, FORMAT_xRGB, VIDEO, RAW },
/* Deprecated Packed RGB Image Formats (alpha ambiguity) */
{ V4L2_PIX_FMT_RGB444, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB555, SPA_VIDEO_FORMAT_RGB15, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB555X, SPA_VIDEO_FORMAT_BGR15, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR32, SPA_VIDEO_FORMAT_BGRx, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB32, SPA_VIDEO_FORMAT_xRGB, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB444, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB555, FORMAT_RGB15, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB555X, FORMAT_BGR15, VIDEO, RAW },
{ V4L2_PIX_FMT_BGR32, FORMAT_BGRx, VIDEO, RAW },
{ V4L2_PIX_FMT_RGB32, FORMAT_xRGB, VIDEO, RAW },
/* Grey formats */
{ V4L2_PIX_FMT_GREY, SPA_VIDEO_FORMAT_GRAY8, VIDEO, RAW },
{ V4L2_PIX_FMT_Y4, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y6, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y10, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y12, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y16, SPA_VIDEO_FORMAT_GRAY16_LE, VIDEO, RAW },
{ V4L2_PIX_FMT_Y16_BE, SPA_VIDEO_FORMAT_GRAY16_BE, VIDEO, RAW },
{ V4L2_PIX_FMT_Y10BPACK, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_GREY, FORMAT_GRAY8, VIDEO, RAW },
{ V4L2_PIX_FMT_Y4, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y6, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y10, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y12, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_Y16, FORMAT_GRAY16_LE, VIDEO, RAW },
{ V4L2_PIX_FMT_Y16_BE, FORMAT_GRAY16_BE, VIDEO, RAW },
{ V4L2_PIX_FMT_Y10BPACK, FORMAT_UNKNOWN, VIDEO, RAW },
/* Palette formats */
{ V4L2_PIX_FMT_PAL8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_PAL8, FORMAT_UNKNOWN, VIDEO, RAW },
/* Chrominance formats */
{ V4L2_PIX_FMT_UV8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_UV8, FORMAT_UNKNOWN, VIDEO, RAW },
/* Luminance+Chrominance formats */
{ V4L2_PIX_FMT_YVU410, SPA_VIDEO_FORMAT_YVU9, VIDEO, RAW },
{ V4L2_PIX_FMT_YVU420, SPA_VIDEO_FORMAT_YV12, VIDEO, RAW },
{ V4L2_PIX_FMT_YVU420M, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUYV, SPA_VIDEO_FORMAT_YUY2, VIDEO, RAW },
{ V4L2_PIX_FMT_YYUV, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YVYU, SPA_VIDEO_FORMAT_YVYU, VIDEO, RAW },
{ V4L2_PIX_FMT_UYVY, SPA_VIDEO_FORMAT_UYVY, VIDEO, RAW },
{ V4L2_PIX_FMT_VYUY, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV422P, SPA_VIDEO_FORMAT_Y42B, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV411P, SPA_VIDEO_FORMAT_Y41B, VIDEO, RAW },
{ V4L2_PIX_FMT_Y41P, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV444, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV555, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV565, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV32, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV410, SPA_VIDEO_FORMAT_YUV9, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV420, SPA_VIDEO_FORMAT_I420, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV420M, SPA_VIDEO_FORMAT_I420, VIDEO, RAW },
{ V4L2_PIX_FMT_HI240, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_HM12, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_M420, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YVU410, FORMAT_YVU9, VIDEO, RAW },
{ V4L2_PIX_FMT_YVU420, FORMAT_YV12, VIDEO, RAW },
{ V4L2_PIX_FMT_YVU420M, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUYV, FORMAT_YUY2, VIDEO, RAW },
{ V4L2_PIX_FMT_YYUV, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YVYU, FORMAT_YVYU, VIDEO, RAW },
{ V4L2_PIX_FMT_UYVY, FORMAT_UYVY, VIDEO, RAW },
{ V4L2_PIX_FMT_VYUY, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV422P, FORMAT_Y42B, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV411P, FORMAT_Y41B, VIDEO, RAW },
{ V4L2_PIX_FMT_Y41P, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV444, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV555, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV565, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV32, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV410, FORMAT_YUV9, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV420, FORMAT_I420, VIDEO, RAW },
{ V4L2_PIX_FMT_YUV420M, FORMAT_I420, VIDEO, RAW },
{ V4L2_PIX_FMT_HI240, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_HM12, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_M420, FORMAT_UNKNOWN, VIDEO, RAW },
/* two planes -- one Y, one Cr + Cb interleaved */
{ V4L2_PIX_FMT_NV12, SPA_VIDEO_FORMAT_NV12, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12M, SPA_VIDEO_FORMAT_NV12, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12MT, SPA_VIDEO_FORMAT_NV12_64Z32, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12MT_16X16, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_NV21, SPA_VIDEO_FORMAT_NV21, VIDEO, RAW },
{ V4L2_PIX_FMT_NV21M, SPA_VIDEO_FORMAT_NV21, VIDEO, RAW },
{ V4L2_PIX_FMT_NV16, SPA_VIDEO_FORMAT_NV16, VIDEO, RAW },
{ V4L2_PIX_FMT_NV16M, SPA_VIDEO_FORMAT_NV16, VIDEO, RAW },
{ V4L2_PIX_FMT_NV61, SPA_VIDEO_FORMAT_NV61, VIDEO, RAW },
{ V4L2_PIX_FMT_NV61M, SPA_VIDEO_FORMAT_NV61, VIDEO, RAW },
{ V4L2_PIX_FMT_NV24, SPA_VIDEO_FORMAT_NV24, VIDEO, RAW },
{ V4L2_PIX_FMT_NV42, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12, FORMAT_NV12, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12M, FORMAT_NV12, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12MT, FORMAT_NV12_64Z32, VIDEO, RAW },
{ V4L2_PIX_FMT_NV12MT_16X16, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_NV21, FORMAT_NV21, VIDEO, RAW },
{ V4L2_PIX_FMT_NV21M, FORMAT_NV21, VIDEO, RAW },
{ V4L2_PIX_FMT_NV16, FORMAT_NV16, VIDEO, RAW },
{ V4L2_PIX_FMT_NV16M, FORMAT_NV16, VIDEO, RAW },
{ V4L2_PIX_FMT_NV61, FORMAT_NV61, VIDEO, RAW },
{ V4L2_PIX_FMT_NV61M, FORMAT_NV61, VIDEO, RAW },
{ V4L2_PIX_FMT_NV24, FORMAT_NV24, VIDEO, RAW },
{ V4L2_PIX_FMT_NV42, FORMAT_UNKNOWN, VIDEO, RAW },
/* Bayer formats - see http://www.siliconimaging.com/RGB%20Bayer.htm */
{ V4L2_PIX_FMT_SBGGR8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SGBRG8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SGRBG8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SRGGB8, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SBGGR8, FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SGBRG8, FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SGRBG8, FORMAT_UNKNOWN, VIDEO, BAYER },
{ V4L2_PIX_FMT_SRGGB8, FORMAT_UNKNOWN, VIDEO, BAYER },
/* compressed formats */
{ V4L2_PIX_FMT_MJPEG, SPA_VIDEO_FORMAT_ENCODED, VIDEO, MJPG },
{ V4L2_PIX_FMT_JPEG, SPA_VIDEO_FORMAT_ENCODED, IMAGE, JPEG },
{ V4L2_PIX_FMT_PJPG, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_DV, SPA_VIDEO_FORMAT_ENCODED, VIDEO, DV },
{ V4L2_PIX_FMT_MPEG, SPA_VIDEO_FORMAT_ENCODED, VIDEO, MPEGTS },
{ V4L2_PIX_FMT_H264, SPA_VIDEO_FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H264_NO_SC, SPA_VIDEO_FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H264_MVC, SPA_VIDEO_FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H263, SPA_VIDEO_FORMAT_ENCODED, VIDEO, H263 },
{ V4L2_PIX_FMT_MPEG1, SPA_VIDEO_FORMAT_ENCODED, VIDEO, MPEG1 },
{ V4L2_PIX_FMT_MPEG2, SPA_VIDEO_FORMAT_ENCODED, VIDEO, MPEG2 },
{ V4L2_PIX_FMT_MPEG4, SPA_VIDEO_FORMAT_ENCODED, VIDEO, MPEG4 },
{ V4L2_PIX_FMT_XVID, SPA_VIDEO_FORMAT_ENCODED, VIDEO, XVID },
{ V4L2_PIX_FMT_VC1_ANNEX_G, SPA_VIDEO_FORMAT_ENCODED, VIDEO, VC1 },
{ V4L2_PIX_FMT_VC1_ANNEX_L, SPA_VIDEO_FORMAT_ENCODED, VIDEO, VC1 },
{ V4L2_PIX_FMT_VP8, SPA_VIDEO_FORMAT_ENCODED, VIDEO, VP8 },
{ V4L2_PIX_FMT_MJPEG, FORMAT_ENCODED, VIDEO, MJPG },
{ V4L2_PIX_FMT_JPEG, FORMAT_ENCODED, IMAGE, JPEG },
{ V4L2_PIX_FMT_PJPG, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_DV, FORMAT_ENCODED, VIDEO, DV },
{ V4L2_PIX_FMT_MPEG, FORMAT_ENCODED, VIDEO, MPEGTS },
{ V4L2_PIX_FMT_H264, FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H264_NO_SC, FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H264_MVC, FORMAT_ENCODED, VIDEO, H264 },
{ V4L2_PIX_FMT_H263, FORMAT_ENCODED, VIDEO, H263 },
{ V4L2_PIX_FMT_MPEG1, FORMAT_ENCODED, VIDEO, MPEG1 },
{ V4L2_PIX_FMT_MPEG2, FORMAT_ENCODED, VIDEO, MPEG2 },
{ V4L2_PIX_FMT_MPEG4, FORMAT_ENCODED, VIDEO, MPEG4 },
{ V4L2_PIX_FMT_XVID, FORMAT_ENCODED, VIDEO, XVID },
{ V4L2_PIX_FMT_VC1_ANNEX_G, FORMAT_ENCODED, VIDEO, VC1 },
{ V4L2_PIX_FMT_VC1_ANNEX_L, FORMAT_ENCODED, VIDEO, VC1 },
{ V4L2_PIX_FMT_VP8, FORMAT_ENCODED, VIDEO, VP8 },
/* Vendor-specific formats */
{ V4L2_PIX_FMT_WNVA, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_SN9C10X, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_PWC1, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_PWC2, SPA_VIDEO_FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_WNVA, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_SN9C10X, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_PWC1, FORMAT_UNKNOWN, VIDEO, RAW },
{ V4L2_PIX_FMT_PWC2, FORMAT_UNKNOWN, VIDEO, RAW },
};
static const FormatInfo *
@ -328,7 +357,7 @@ static const FormatInfo *
find_format_info_by_media_type (URI *uri,
uint32_t type,
uint32_t subtype,
SpaVideoFormat format,
uint32_t format,
int startidx)
{
int i;
@ -338,20 +367,20 @@ find_format_info_by_media_type (URI *uri,
media_type = *SPA_MEMBER (uri, format_info[i].media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (uri, format_info[i].media_subtype_offset, uint32_t);
media_format = format_info[i].format;
media_format = *SPA_MEMBER (uri, format_info[i].format_offset, uint32_t);
if ((media_type == type) &&
(media_subtype == subtype) &&
(format == SPA_VIDEO_FORMAT_UNKNOWN || media_format == format))
(format == 0 || media_format == format))
return &format_info[i];
}
return NULL;
}
static SpaVideoFormat
static uint32_t
enum_filter_format (URI *uri, const SpaFormat *filter, uint32_t index)
{
SpaVideoFormat video_format = SPA_VIDEO_FORMAT_UNKNOWN;
uint32_t video_format = 0;
if ((filter->body.media_type.value == uri->media_types.video ||
filter->body.media_type.value == uri->media_types.image)) {
@ -361,10 +390,10 @@ enum_filter_format (URI *uri, const SpaFormat *filter, uint32_t index)
const uint32_t *values;
if (!(p = spa_format_find_prop (filter, uri->prop_video.format)))
return SPA_VIDEO_FORMAT_UNKNOWN;
return uri->video_formats.UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_INT)
return SPA_VIDEO_FORMAT_UNKNOWN;
if (p->body.value.type != SPA_POD_TYPE_URI)
return uri->video_formats.UNKNOWN;
values = SPA_POD_BODY_CONST (&p->body.value);
n_values = SPA_POD_PROP_N_VALUES (p);
@ -378,7 +407,7 @@ enum_filter_format (URI *uri, const SpaFormat *filter, uint32_t index)
}
} else {
if (index == 0)
video_format = SPA_VIDEO_FORMAT_ENCODED;
video_format = uri->video_formats.ENCODED;
}
}
return video_format;
@ -484,7 +513,7 @@ spa_v4l2_enum_format (SpaV4l2Source *this,
SpaPODFrame f[2];
SpaPODProp *prop;
SpaPODBuilder b = { state->format_buffer, sizeof (state->format_buffer), };
uint32_t media_type, media_subtype;
uint32_t media_type, media_subtype, video_format;
if (spa_v4l2_open (this) < 0)
return SPA_RESULT_ERROR;
@ -509,10 +538,8 @@ next_fmtdesc:
while (state->next_fmtdesc) {
if (filter) {
SpaVideoFormat video_format;
video_format = enum_filter_format (&this->uri, filter, state->fmtdesc.index);
if (video_format == SPA_VIDEO_FORMAT_UNKNOWN)
if (video_format == this->uri.video_formats.UNKNOWN)
return SPA_RESULT_ENUM_END;
info = find_format_info_by_media_type (&this->uri,
@ -633,6 +660,7 @@ have_size:
media_type = *SPA_MEMBER (&this->uri, info->media_type_offset, uint32_t);
media_subtype = *SPA_MEMBER (&this->uri, info->media_subtype_offset, uint32_t);
video_format = *SPA_MEMBER (&this->uri, info->format_offset, uint32_t);
spa_pod_builder_push_format (&b, &f[0],
media_type,
@ -640,7 +668,7 @@ have_size:
if (media_subtype == this->uri.media_subtypes.raw) {
spa_pod_builder_add (&b,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_INT, info->format),
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, video_format),
0);
}
spa_pod_builder_add (&b,
@ -765,7 +793,7 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only)
struct v4l2_format reqfmt, fmt;
struct v4l2_streamparm streamparm;
const FormatInfo *info = NULL;
SpaVideoFormat video_format;
uint32_t video_format;
SpaRectangle *size = NULL;
SpaFraction *framerate = NULL;
SpaPODBuilder b = { NULL };
@ -783,17 +811,17 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaVideoInfo *format, bool try_only)
}
else if (format->media_subtype == this->uri.media_subtypes_video.mjpg ||
format->media_subtype == this->uri.media_subtypes_video.jpeg) {
video_format = SPA_VIDEO_FORMAT_ENCODED;
video_format = this->uri.video_formats.ENCODED;
size = &format->info.mjpg.size;
framerate = &format->info.mjpg.framerate;
}
else if (format->media_subtype == this->uri.media_subtypes_video.h264) {
video_format = SPA_VIDEO_FORMAT_ENCODED;
video_format = this->uri.video_formats.ENCODED;
size = &format->info.h264.size;
framerate = &format->info.h264.framerate;
}
else {
video_format = SPA_VIDEO_FORMAT_ENCODED;
video_format = this->uri.video_formats.ENCODED;
}
info = find_format_info_by_media_type (&this->uri,

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

@ -148,16 +148,14 @@ drawing_data_init (DrawingData *dd,
(format->media_subtype != this->uri.media_subtypes.raw))
return SPA_RESULT_NOT_IMPLEMENTED;
switch (format->info.raw.format) {
case SPA_VIDEO_FORMAT_RGB:
dd->draw_pixel = draw_pixel_rgb;
break;
case SPA_VIDEO_FORMAT_UYVY:
dd->draw_pixel = draw_pixel_uyvy;
break;
default:
return SPA_RESULT_NOT_IMPLEMENTED;
if (format->info.raw.format == this->uri.video_formats.RGB) {
dd->draw_pixel = draw_pixel_rgb;
}
else if (format->info.raw.format == this->uri.video_formats.UYVY) {
dd->draw_pixel = draw_pixel_uyvy;
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
dd->line = data;
dd->width = size->width;

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

@ -42,6 +42,7 @@ typedef struct {
SpaMediaTypes media_types;
SpaMediaSubtypes media_subtypes;
SpaPropVideo prop_video;
SpaVideoFormats video_formats;
} URI;
typedef struct _SpaVideoTestSrc SpaVideoTestSrc;
@ -454,10 +455,10 @@ next:
case 0:
spa_pod_builder_format (&b, &f[0],
this->uri.media_types.video, this->uri.media_subtypes.raw,
PROP_U_EN (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_INT, 3,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_RGB,
SPA_VIDEO_FORMAT_UYVY),
PROP_U_EN (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, 3,
this->uri.video_formats.RGB,
this->uri.video_formats.RGB,
this->uri.video_formats.UYVY),
PROP_U_MM (&f[1], this->uri.prop_video.size, SPA_POD_TYPE_RECTANGLE,
320, 240,
1, 1,
@ -529,16 +530,14 @@ spa_videotestsrc_node_port_set_format (SpaNode *node,
SpaPODBuilder b = { NULL };
SpaPODFrame f[2];
switch (raw_info->format) {
case SPA_VIDEO_FORMAT_RGB:
this->bpp = 3;
break;
case SPA_VIDEO_FORMAT_UYVY:
this->bpp = 2;
break;
default:
return SPA_RESULT_NOT_IMPLEMENTED;
if (raw_info->format == this->uri.video_formats.RGB) {
this->bpp = 3;
}
else if (raw_info->format == this->uri.video_formats.UYVY) {
this->bpp = 2;
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
this->info.maxbuffering = -1;
this->info.latency = 0;
@ -594,7 +593,7 @@ spa_videotestsrc_node_port_get_format (SpaNode *node,
spa_pod_builder_format (&b, &f[0],
this->uri.media_types.video, this->uri.media_subtypes.raw,
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_INT, this->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.format, SPA_POD_TYPE_URI, this->current_format.info.raw.format),
PROP (&f[1], this->uri.prop_video.size, -SPA_POD_TYPE_RECTANGLE, &this->current_format.info.raw.size),
PROP (&f[1], this->uri.prop_video.framerate, -SPA_POD_TYPE_FRACTION, &this->current_format.info.raw.framerate));
*format = SPA_POD_BUILDER_DEREF (&b, f[0].ref, SpaFormat);
@ -962,6 +961,7 @@ videotestsrc_init (const SpaHandleFactory *factory,
spa_media_types_fill (&this->uri.media_types, this->map);
spa_media_subtypes_map (this->map, &this->uri.media_subtypes);
spa_prop_video_map (this->map, &this->uri.prop_video);
spa_video_formats_map (this->map, &this->uri.video_formats);
this->node = videotestsrc_node;
this->clock = videotestsrc_clock;

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

@ -40,12 +40,12 @@
*/
spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
prop_video.format, SPA_PROP_TYPE_INT,
SPA_VIDEO_FORMAT_I420
prop_video.format, SPA_PROP_TYPE_URI,
video_formats.I420
SPA_POD_PROP_FLAG_UNSET |
SPA_PROP_RANGE_ENUM, 2,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2,
video_formats.I420,
video_formats.YUY2,
prop_video.size , SPA_PROP_TYPE_RECTANGLE,
320, 240,
SPA_POD_PROP_FLAG_UNSET |
@ -63,6 +63,7 @@ spa_build (SPA_MEDIA_TYPE_VIDEO, SPA_MEDIA_SUBTYPE_RAW,
static SpaMediaTypes media_types;
static SpaMediaSubtypes media_subtypes;
static SpaPropVideo prop_video;
static SpaVideoFormats video_formats;
static void
do_static_struct (void)
@ -101,9 +102,9 @@ do_static_struct (void)
{ { sizeof (test_format.props.format_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
{ prop_video.format, SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET,
{ sizeof (uint32_t), SPA_POD_TYPE_INT } }, },
{ SPA_VIDEO_FORMAT_I420,
{ SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2 } }, 0,
{ sizeof (uint32_t), SPA_POD_TYPE_URI } }, },
{ video_formats.I420,
{ video_formats.I420, video_formats.YUY2 } }, 0,
{ { sizeof (test_format.props.size_vals) + sizeof (SpaPODPropBody),
SPA_POD_TYPE_PROP } ,
@ -151,6 +152,7 @@ main (int argc, char *argv[])
spa_media_types_fill (&media_types, spa_id_map_get_default());
spa_media_subtypes_map (spa_id_map_get_default(), &media_subtypes);
spa_prop_video_map (spa_id_map_get_default(), &prop_video);
spa_video_formats_map (spa_id_map_get_default(), &video_formats);
spa_pod_builder_init (&b, buffer, sizeof (buffer));
@ -160,9 +162,9 @@ main (int argc, char *argv[])
spa_pod_builder_push_prop (&b, &frame[1],
prop_video.format,
SPA_POD_PROP_RANGE_ENUM | SPA_POD_PROP_FLAG_UNSET | SPA_POD_PROP_FLAG_READWRITE);
spa_pod_builder_int (&b, SPA_VIDEO_FORMAT_I420);
spa_pod_builder_int (&b, SPA_VIDEO_FORMAT_I420);
spa_pod_builder_int (&b, SPA_VIDEO_FORMAT_YUY2);
spa_pod_builder_uri (&b, video_formats.I420);
spa_pod_builder_uri (&b, video_formats.I420);
spa_pod_builder_uri (&b, video_formats.YUY2);
spa_pod_builder_pop (&b, &frame[1]);
SpaRectangle size_min_max[] = { { 1, 1 }, { INT32_MAX, INT32_MAX } };
@ -192,10 +194,10 @@ main (int argc, char *argv[])
SPA_POD_TYPE_PROP, &frame[1],
prop_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2,
SPA_POD_TYPE_URI, 3,
video_formats.I420,
video_formats.I420,
video_formats.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.size, SPA_POD_PROP_FLAG_UNSET |
@ -227,10 +229,10 @@ main (int argc, char *argv[])
SPA_POD_TYPE_PROP, &frame[1],
prop_video.format, SPA_POD_PROP_FLAG_UNSET |
SPA_POD_PROP_RANGE_ENUM,
SPA_POD_TYPE_INT, 3,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_I420,
SPA_VIDEO_FORMAT_YUY2,
SPA_POD_TYPE_URI, 3,
video_formats.I420,
video_formats.I420,
video_formats.YUY2,
-SPA_POD_TYPE_PROP, &frame[1],
SPA_POD_TYPE_PROP, &frame[1],
prop_video.size, SPA_POD_PROP_FLAG_UNSET |