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

types: more work on types

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

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

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

16
spa/lib/debug.c
View file

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

56
spa/lib/mapper.c
View file

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

6
spa/lib/mapper.h
View file

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

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

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