mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-12-15 08:56:38 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

More hacking

Browse source 
Add spa based v4l2 pinos module
Add allocation params to port_alloc_buffers
Let the app do allocation for handles.
This commit is contained in:
Wim Taymans 2016-07-13 18:29:55 +02:00
parent 4c7cee6b28
commit 6ab8af91e0
41 changed files with 4733 additions and 351 deletions
Download patch file Download diff file Expand all files Collapse all files

14
spa/include/spa/buffer.h
View file

@ -25,6 +25,7 @@ extern "C" {
#endif
typedef struct _SpaBuffer SpaBuffer;
typedef struct _SpaBufferGroup SpaBufferGroup;
#include <spa/defs.h>
@ -37,6 +38,7 @@ typedef enum {
SPA_META_TYPE_INVALID = 0,
SPA_META_TYPE_HEADER,
SPA_META_TYPE_POINTER,
SPA_META_TYPE_VIDEO_CROP,
} SpaMetaType;
/**
@ -72,6 +74,18 @@ typedef struct {
void *ptr;
} SpaMetaPointer;
/**
* SpaMetaVideoCrop:
* @x:
* @y:
* @width:
* @height
*/
typedef struct {
int x, y;
int width, height;
} SpaMetaVideoCrop;
/**
* SpaMeta:
* @type: metadata type

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

@ -34,7 +34,7 @@ typedef struct _SpaEvent SpaEvent;
* @SPA_EVENT_TYPE_STARTED: emited when the START command completes
* @SPA_EVENT_TYPE_STOPPED: emited when the STOP command completes
* @SPA_EVENT_TYPE_CAN_PULL_OUTPUT: emited when an async node has output that can be pulled
* @SPA_EVENT_TYPE_CAN_PUSH_INTPUT: emited when more data can be pushed to an async node
* @SPA_EVENT_TYPE_CAN_PUSH_INPUT: emited when more data can be pushed to an async node
* @SPA_EVENT_TYPE_PULL_INPUT: emited when data needs to be provided on an input
* @SPA_EVENT_TYPE_ALLOC_OUTPUT: emited when an output buffer needs to be allocated
* @SPA_EVENT_TYPE_ADD_POLL: emited when a pollfd should be added
@ -49,7 +49,7 @@ typedef enum {
SPA_EVENT_TYPE_STARTED,
SPA_EVENT_TYPE_STOPPED,
SPA_EVENT_TYPE_CAN_PULL_OUTPUT,
SPA_EVENT_TYPE_CAN_PUSH_INTPUT,
SPA_EVENT_TYPE_CAN_PUSH_INPUT,
SPA_EVENT_TYPE_PULL_INPUT,
SPA_EVENT_TYPE_ALLOC_OUTPUT,
SPA_EVENT_TYPE_ADD_POLL,

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

@ -320,6 +320,8 @@ struct _SpaNode {
uint32_t n_buffers);
SpaResult (*port_alloc_buffers) (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers);

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

@ -78,20 +78,27 @@ struct _SpaHandleFactory {
* Extra information about the handles of this factory.
*/
const SpaProps * info;
/**
* SpaHandleFactory::size
*
* The size of handles from this factory
*/
const size_t size;
/**
* SpaHandleFactory::instantiate
* SpaHandleFactory::init
* @factory: a #SpaHandleFactory
* @handle: a pointer to hold the result
* @handle: a pointer to memory
*
* Make an instance of this factory.
* Initialize an instance of this factory. The caller should allocate
* memory at least SpaHandleFactory::size bytes and pass this as @handle.
*
* Returns: #SPA_RESULT_OK on success
* #SPA_RESULT_NOT_IMPLEMENTED when an instance can't be made
* #SPA_RESULT_INVALID_ARGUMENTS when factory or handle are %NULL
*/
SpaResult (*instantiate) (const SpaHandleFactory *factory,
SpaHandle **handle);
SpaResult (*init) (const SpaHandleFactory *factory,
SpaHandle *handle);
/**
* SpaHandle::enum_interface_info:
* @factory: a #SpaHandleFactory

51
spa/include/spa/port.h
View file

@ -25,6 +25,48 @@ extern "C" {
#endif
#include <spa/defs.h>
#include <spa/buffer.h>
/**
* SpaAllocParamType:
* @SPA_ALLOC_PARAM_TYPE_INVALID: invalid type, should be ignored
* @SPA_ALLOC_PARAM_TYPE_META_ENABLE: enable a certain metadata on buffers
* @SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING: do specialized video padding
*/
typedef enum {
SPA_ALLOC_PARAM_TYPE_INVALID,
SPA_ALLOC_PARAM_TYPE_BUFFERS,
SPA_ALLOC_PARAM_TYPE_META_ENABLE,
SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING,
} SpaAllocParamType;
typedef struct {
uint32_t type;
size_t size;
} SpaAllocParam;
typedef struct {
SpaAllocParam param;
size_t minsize;
size_t stride;
uint32_t min_buffers;
uint32_t max_buffers;
uint32_t align;
} SpaAllocParamBuffers;
typedef struct {
SpaAllocParam param;
SpaMetaType type;
} SpaAllocParamMetaEnable;
typedef struct {
SpaAllocParam param;
unsigned int padding_top;
unsigned int padding_bottom;
unsigned int padding_left;
unsigned int padding_right;
unsigned int stride_align[4];
} SpaAllocParamVideoPadding;
/**
* SpaPortInfoFlags:
@ -58,18 +100,17 @@ typedef enum {
* @maxbuffering: the maximum amount of bytes that the element will keep
* around internally
* @latency: latency on this port in nanoseconds
* @params: extra allocation parameters
* @n_params: number of elements in @params;
* @features: NULL terminated array of extra port features
*
*/
typedef struct {
SpaPortInfoFlags flags;
size_t minsize;
size_t stride;
uint32_t min_buffers;
uint32_t max_buffers;
uint32_t align;
unsigned int maxbuffering;
uint64_t latency;
SpaAllocParam **params;
uint32_t n_params;
const char **features;
} SpaPortInfo;

80
spa/lib/debug.c Normal file
View file

@ -0,0 +1,80 @@
/* 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.
*/
#include <stdio.h>
#include "spa/debug.h"
SpaResult
spa_debug_port_info (const SpaPortInfo *info)
{
int i;
if (info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
fprintf (stderr, "SpaPortInfo %p:\n", info);
fprintf (stderr, " flags: \t%08x\n", info->flags);
fprintf (stderr, " maxbuffering: \t%u\n", info->maxbuffering);
fprintf (stderr, " latency: \t%" PRIu64 "\n", info->latency);
fprintf (stderr, " n_params: \t%d\n", info->n_params);
for (i = 0; i < info->n_params; i++) {
SpaAllocParam *param = info->params[i];
fprintf (stderr, " param %d, type %d, size %zd:\n", i, param->type, param->size);
switch (param->type) {
case SPA_ALLOC_PARAM_TYPE_INVALID:
fprintf (stderr, " INVALID\n");
break;
case SPA_ALLOC_PARAM_TYPE_BUFFERS:
{
SpaAllocParamBuffers *p = (SpaAllocParamBuffers *)param;
fprintf (stderr, " SpaAllocParamBuffers:\n");
fprintf (stderr, " minsize: \t\t%zd\n", p->minsize);
fprintf (stderr, " stride: \t\t%zd\n", p->stride);
fprintf (stderr, " min_buffers: \t%d\n", p->min_buffers);
fprintf (stderr, " max_buffers: \t%d\n", p->max_buffers);
fprintf (stderr, " align: \t\t%d\n", p->align);
break;
}
case SPA_ALLOC_PARAM_TYPE_META_ENABLE:
{
SpaAllocParamMetaEnable *p = (SpaAllocParamMetaEnable *)param;
fprintf (stderr, " SpaAllocParamMetaEnable:\n");
fprintf (stderr, " type: \t%d\n", p->type);
break;
}
case SPA_ALLOC_PARAM_TYPE_VIDEO_PADDING:
{
SpaAllocParamVideoPadding *p = (SpaAllocParamVideoPadding *)param;
fprintf (stderr, " SpaAllocParamVideoPadding:\n");
fprintf (stderr, " padding_top: \t%d\n", p->padding_top);
fprintf (stderr, " padding_bottom: \t%d\n", p->padding_bottom);
fprintf (stderr, " padding_left: \t%d\n", p->padding_left);
fprintf (stderr, " padding_right: \t%d\n", p->padding_right);
fprintf (stderr, " stide_align: \t[%d, %d, %d, %d]\n",
p->stride_align[0], p->stride_align[1], p->stride_align[2], p->stride_align[3]);
break;
}
default:
fprintf (stderr, " UNKNOWN\n");
break;
}
}
return SPA_RESULT_OK;
}

1
spa/lib/meson.build
View file

@ -1,4 +1,5 @@
spalib_sources = ['audio-raw.c',
'debug.c',
'props.c',
'ringbuffer.c',
'video-raw.c']

4
spa/meson.build
View file

@ -4,6 +4,10 @@ alsa_dep = dependency('alsa')
v4l2_dep = dependency('libv4l2')
xv_dep = dependency('x11')
sdl_dep = dependency('sdl2')
avcodec_dep = dependency('libavcodec')
avformat_dep = dependency('libavformat')
avfilter_dep = dependency('libavfilter')
libva_dep = dependency('libva')
cc = meson.get_compiler('c')

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

@ -474,6 +474,8 @@ spa_alsa_sink_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_alsa_sink_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -572,13 +574,15 @@ spa_alsa_sink_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_alsa_sink_new (void)
static SpaResult
alsa_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaALSASink *this;
handle = calloc (1, sizeof (SpaALSASink));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_alsa_sink_get_interface;
this = (SpaALSASink *) handle;
@ -590,5 +594,35 @@ spa_alsa_sink_new (void)
this->info.flags = SPA_PORT_INFO_FLAG_NONE;
this->status.flags = SPA_PORT_STATUS_FLAG_NEED_INPUT;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo alsa_sink_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
alsa_sink_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &alsa_sink_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_alsa_sink_factory =
{ "alsa-sink",
NULL,
sizeof (SpaALSASink),
alsa_sink_init,
alsa_sink_enum_interface_info,
};

56
spa/plugins/alsa/alsa.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_alsa_sink_new (void);
static SpaResult
alsa_sink_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_alsa_sink_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo alsa_sink_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
alsa_sink_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &alsa_sink_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "alsa-sink",
NULL,
alsa_sink_instantiate,
alsa_sink_enum_interface_info,
},
};
extern const SpaHandleFactory spa_alsa_sink_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
if (factory == NULL)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
switch (index) {
case 0:
*factory = &spa_alsa_sink_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

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

@ -440,6 +440,8 @@ spa_audiomixer_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_audiomixer_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -733,13 +735,15 @@ spa_audiomixer_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_audiomixer_new (void)
static SpaResult
spa_audiomixer_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaAudioMixer *this;
handle = calloc (1, sizeof (SpaAudioMixer));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_audiomixer_get_interface;
this = (SpaAudioMixer *) handle;
@ -753,5 +757,34 @@ spa_audiomixer_new (void)
this->ports[0].info.flags = SPA_PORT_INFO_FLAG_CAN_GIVE_BUFFER |
SPA_PORT_INFO_FLAG_CAN_USE_BUFFER |
SPA_PORT_INFO_FLAG_NO_REF;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo audiomixer_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
audiomixer_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &audiomixer_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_audiomixer_factory =
{ "audiomixer",
NULL,
sizeof (SpaAudioMixer),
spa_audiomixer_init,
audiomixer_enum_interface_info,
};

58
spa/plugins/audiomixer/plugin.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_audiomixer_new (void);
static SpaResult
audiomixer_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_audiomixer_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo audiomixer_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
audiomixer_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &audiomixer_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "audiomixer",
NULL,
audiomixer_instantiate,
audiomixer_enum_interface_info,
},
};
extern const SpaHandleFactory spa_audiomixer_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (index) {
case 0:
*factory = &spa_audiomixer_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

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

@ -417,6 +417,8 @@ spa_audiotestsrc_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_audiotestsrc_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -520,13 +522,15 @@ spa_audiotestsrc_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_audiotestsrc_new (void)
static SpaResult
audiotestsrc_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaAudioTestSrc *this;
handle = calloc (1, sizeof (SpaAudioTestSrc));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_audiotestsrc_get_interface;
this = (SpaAudioTestSrc *) handle;
@ -540,5 +544,34 @@ spa_audiotestsrc_new (void)
SPA_PORT_INFO_FLAG_NO_REF;
this->status.flags = SPA_PORT_STATUS_FLAG_HAVE_OUTPUT;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo audiotestsrc_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
audiotestsrc_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &audiotestsrc_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_audiotestsrc_factory =
{ "audiotestsrc",
NULL,
sizeof (SpaAudioTestSrc),
audiotestsrc_init,
audiotestsrc_enum_interface_info,
};

58
spa/plugins/audiotestsrc/plugin.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_audiotestsrc_new (void);
static SpaResult
audiotestsrc_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_audiotestsrc_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo audiotestsrc_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
audiotestsrc_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &audiotestsrc_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "audiotestsrc",
NULL,
audiotestsrc_instantiate,
audiotestsrc_enum_interface_info,
},
};
extern const SpaHandleFactory spa_audiotestsrc_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (index) {
case 0:
*factory = &spa_audiotestsrc_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

529
spa/plugins/ffmpeg/ffmpeg-dec.c Normal file
View file

@ -0,0 +1,529 @@
/* Spa FFMpeg Decoder
* 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.
*/
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <spa/node.h>
#include <spa/video/format.h>
typedef struct _SpaFFMpegDec SpaFFMpegDec;
typedef struct {
SpaProps props;
} SpaFFMpegDecProps;
static void
reset_ffmpeg_dec_props (SpaFFMpegDecProps *props)
{
}
#define INPUT_PORT_ID 0
#define OUTPUT_PORT_ID 1
#define IS_VALID_PORT(id) ((id) < 2)
#define MAX_BUFFERS 32
typedef struct _FFMpegBuffer FFMpegBuffer;
struct _FFMpegBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaFFMpegDec *dec;
SpaBuffer *imported;
bool outstanding;
FFMpegBuffer *next;
};
typedef struct {
SpaVideoRawFormat raw_format[2];
SpaFormat *current_format;
bool have_buffers;
FFMpegBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
SpaPortStatus status;
} SpaFFMpegState;
struct _SpaFFMpegDec {
SpaHandle handle;
SpaFFMpegDecProps props[2];
SpaEventCallback event_cb;
void *user_data;
SpaFFMpegState state[2];
};
enum {
PROP_ID_LAST,
};
static const SpaPropInfo prop_info[] =
{
{ 0, },
};
static SpaResult
spa_ffmpeg_dec_node_get_props (SpaHandle *handle,
SpaProps **props)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
if (handle == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
*props = &this->props[0].props;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_set_props (SpaHandle *handle,
const SpaProps *props)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
SpaFFMpegDecProps *p = &this->props[1];
SpaResult res;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (props == NULL) {
reset_ffmpeg_dec_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
return res;
}
static SpaResult
spa_ffmpeg_dec_node_send_command (SpaHandle *handle,
SpaCommand *command)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
if (handle == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (command->type) {
case SPA_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
case SPA_COMMAND_START:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STARTED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STOPPED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_FLUSH:
case SPA_COMMAND_DRAIN:
case SPA_COMMAND_MARKER:
return SPA_RESULT_NOT_IMPLEMENTED;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_set_event_callback (SpaHandle *handle,
SpaEventCallback event,
void *user_data)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this->event_cb = event;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports)
*n_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0)
input_ids[0] = 0;
if (n_output_ports > 0)
output_ids[0] = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_add_port (SpaHandle *handle,
SpaDirection direction,
uint32_t *port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_dec_node_remove_port (SpaHandle *handle,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_dec_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
SpaFormat **format)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
SpaFFMpegState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
switch (index) {
case 0:
spa_video_raw_format_init (&state->raw_format[0]);
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = &state->raw_format[0].format;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_set_format (SpaHandle *handle,
uint32_t port_id,
bool test_only,
const SpaFormat *format)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
SpaFFMpegState *state;
SpaResult res;
SpaFormat *f, *tf;
size_t fs;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (format == NULL) {
state->current_format = NULL;
return SPA_RESULT_OK;
}
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
return res;
f = &state->raw_format[0].format;
tf = &state->raw_format[1].format;
fs = sizeof (SpaVideoRawFormat);
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!test_only) {
memcpy (tf, f, fs);
state->current_format = tf;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_get_format (SpaHandle *handle,
uint32_t port_id,
const SpaFormat **format)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
SpaFFMpegState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (state->current_format == NULL)
return SPA_RESULT_NO_FORMAT;
*format = state->current_format;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_get_info (SpaHandle *handle,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
if (handle == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*info = &this->state[port_id].info;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_get_props (SpaHandle *handle,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_dec_node_port_set_props (SpaHandle *handle,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_dec_node_port_get_status (SpaHandle *handle,
uint32_t port_id,
const SpaPortStatus **status)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
if (handle == NULL || status == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*status = &this->state[port_id].status;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_use_buffers (SpaHandle *handle,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_dec_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_dec_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
}
static SpaResult
spa_ffmpeg_dec_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
SpaOutputInfo *info)
{
SpaFFMpegDec *this = (SpaFFMpegDec *) handle;
SpaFFMpegState *state;
unsigned int i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < n_info; i++) {
if (info[i].port_id != OUTPUT_PORT_ID) {
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
}
state = &this->state[info[i].port_id];
if (state->current_format == NULL) {
info[i].status = SPA_RESULT_NO_FORMAT;
have_error = true;
continue;
}
info[i].status = SPA_RESULT_OK;
}
if (have_error)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static const SpaNode ffmpeg_dec_node = {
sizeof (SpaNode),
spa_ffmpeg_dec_node_get_props,
spa_ffmpeg_dec_node_set_props,
spa_ffmpeg_dec_node_send_command,
spa_ffmpeg_dec_node_set_event_callback,
spa_ffmpeg_dec_node_get_n_ports,
spa_ffmpeg_dec_node_get_port_ids,
spa_ffmpeg_dec_node_add_port,
spa_ffmpeg_dec_node_remove_port,
spa_ffmpeg_dec_node_port_enum_formats,
spa_ffmpeg_dec_node_port_set_format,
spa_ffmpeg_dec_node_port_get_format,
spa_ffmpeg_dec_node_port_get_info,
spa_ffmpeg_dec_node_port_get_props,
spa_ffmpeg_dec_node_port_set_props,
spa_ffmpeg_dec_node_port_use_buffers,
spa_ffmpeg_dec_node_port_alloc_buffers,
spa_ffmpeg_dec_node_port_get_status,
spa_ffmpeg_dec_node_port_push_input,
spa_ffmpeg_dec_node_port_pull_output,
};
static SpaResult
spa_ffmpeg_dec_get_interface (SpaHandle *handle,
uint32_t interface_id,
const void **interface)
{
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (interface_id) {
case SPA_INTERFACE_ID_NODE:
*interface = &ffmpeg_dec_node;
break;
default:
return SPA_RESULT_UNKNOWN_INTERFACE;
}
return SPA_RESULT_OK;
}
SpaResult
spa_ffmpeg_dec_init (SpaHandle *handle)
{
SpaFFMpegDec *this;
handle->get_interface = spa_ffmpeg_dec_get_interface;
this = (SpaFFMpegDec *) handle;
this->props[1].props.n_prop_info = PROP_ID_LAST;
this->props[1].props.prop_info = prop_info;
this->props[1].props.set_prop = spa_props_generic_set_prop;
this->props[1].props.get_prop = spa_props_generic_get_prop;
reset_ffmpeg_dec_props (&this->props[1]);
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return SPA_RESULT_OK;
}

529
spa/plugins/ffmpeg/ffmpeg-enc.c Normal file
View file

@ -0,0 +1,529 @@
/* Spa FFMpeg Encoder
* 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.
*/
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <spa/node.h>
#include <spa/video/format.h>
typedef struct _SpaFFMpegEnc SpaFFMpegEnc;
typedef struct {
SpaProps props;
} SpaFFMpegEncProps;
static void
reset_ffmpeg_enc_props (SpaFFMpegEncProps *props)
{
}
#define INPUT_PORT_ID 0
#define OUTPUT_PORT_ID 1
#define IS_VALID_PORT(id) ((id) < 2)
#define MAX_BUFFERS 32
typedef struct _FFMpegBuffer FFMpegBuffer;
struct _FFMpegBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaFFMpegEnc *enc;
SpaBuffer *imported;
bool outstanding;
FFMpegBuffer *next;
};
typedef struct {
SpaVideoRawFormat raw_format[2];
SpaFormat *current_format;
bool have_buffers;
FFMpegBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
SpaPortStatus status;
} SpaFFMpegState;
struct _SpaFFMpegEnc {
SpaHandle handle;
SpaFFMpegEncProps props[2];
SpaEventCallback event_cb;
void *user_data;
SpaFFMpegState state[2];
};
enum {
PROP_ID_LAST,
};
static const SpaPropInfo prop_info[] =
{
{ 0, },
};
static SpaResult
spa_ffmpeg_enc_node_get_props (SpaHandle *handle,
SpaProps **props)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
if (handle == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
*props = &this->props[0].props;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_set_props (SpaHandle *handle,
const SpaProps *props)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
SpaFFMpegEncProps *p = &this->props[1];
SpaResult res;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (props == NULL) {
reset_ffmpeg_enc_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
return res;
}
static SpaResult
spa_ffmpeg_enc_node_send_command (SpaHandle *handle,
SpaCommand *command)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
if (handle == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (command->type) {
case SPA_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
case SPA_COMMAND_START:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STARTED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STOPPED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_FLUSH:
case SPA_COMMAND_DRAIN:
case SPA_COMMAND_MARKER:
return SPA_RESULT_NOT_IMPLEMENTED;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_set_event_callback (SpaHandle *handle,
SpaEventCallback event,
void *user_data)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this->event_cb = event;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports)
*n_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0)
input_ids[0] = 0;
if (n_output_ports > 0)
output_ids[0] = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_add_port (SpaHandle *handle,
SpaDirection direction,
uint32_t *port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_enc_node_remove_port (SpaHandle *handle,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_enc_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
SpaFormat **format)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
SpaFFMpegState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
switch (index) {
case 0:
spa_video_raw_format_init (&state->raw_format[0]);
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = &state->raw_format[0].format;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_set_format (SpaHandle *handle,
uint32_t port_id,
bool test_only,
const SpaFormat *format)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
SpaFFMpegState *state;
SpaResult res;
SpaFormat *f, *tf;
size_t fs;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (format == NULL) {
state->current_format = NULL;
return SPA_RESULT_OK;
}
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
return res;
f = &state->raw_format[0].format;
tf = &state->raw_format[1].format;
fs = sizeof (SpaVideoRawFormat);
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!test_only) {
memcpy (tf, f, fs);
state->current_format = tf;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_get_format (SpaHandle *handle,
uint32_t port_id,
const SpaFormat **format)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
SpaFFMpegState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (state->current_format == NULL)
return SPA_RESULT_NO_FORMAT;
*format = state->current_format;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_get_info (SpaHandle *handle,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
if (handle == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*info = &this->state[port_id].info;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_get_props (SpaHandle *handle,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_enc_node_port_set_props (SpaHandle *handle,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_enc_node_port_get_status (SpaHandle *handle,
uint32_t port_id,
const SpaPortStatus **status)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
if (handle == NULL || status == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*status = &this->state[port_id].status;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_use_buffers (SpaHandle *handle,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_OK;
}
static SpaResult
spa_ffmpeg_enc_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_ffmpeg_enc_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
}
static SpaResult
spa_ffmpeg_enc_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
SpaOutputInfo *info)
{
SpaFFMpegEnc *this = (SpaFFMpegEnc *) handle;
SpaFFMpegState *state;
unsigned int i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < n_info; i++) {
if (info[i].port_id != OUTPUT_PORT_ID) {
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
}
state = &this->state[info[i].port_id];
if (state->current_format == NULL) {
info[i].status = SPA_RESULT_NO_FORMAT;
have_error = true;
continue;
}
info[i].status = SPA_RESULT_OK;
}
if (have_error)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static const SpaNode ffmpeg_enc_node = {
sizeof (SpaNode),
spa_ffmpeg_enc_node_get_props,
spa_ffmpeg_enc_node_set_props,
spa_ffmpeg_enc_node_send_command,
spa_ffmpeg_enc_node_set_event_callback,
spa_ffmpeg_enc_node_get_n_ports,
spa_ffmpeg_enc_node_get_port_ids,
spa_ffmpeg_enc_node_add_port,
spa_ffmpeg_enc_node_remove_port,
spa_ffmpeg_enc_node_port_enum_formats,
spa_ffmpeg_enc_node_port_set_format,
spa_ffmpeg_enc_node_port_get_format,
spa_ffmpeg_enc_node_port_get_info,
spa_ffmpeg_enc_node_port_get_props,
spa_ffmpeg_enc_node_port_set_props,
spa_ffmpeg_enc_node_port_use_buffers,
spa_ffmpeg_enc_node_port_alloc_buffers,
spa_ffmpeg_enc_node_port_get_status,
spa_ffmpeg_enc_node_port_push_input,
spa_ffmpeg_enc_node_port_pull_output,
};
static SpaResult
spa_ffmpeg_enc_get_interface (SpaHandle *handle,
uint32_t interface_id,
const void **interface)
{
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (interface_id) {
case SPA_INTERFACE_ID_NODE:
*interface = &ffmpeg_enc_node;
break;
default:
return SPA_RESULT_UNKNOWN_INTERFACE;
}
return SPA_RESULT_OK;
}
SpaResult
spa_ffmpeg_enc_init (SpaHandle *handle)
{
SpaFFMpegEnc *this;
handle->get_interface = spa_ffmpeg_enc_get_interface;
this = (SpaFFMpegEnc *) handle;
this->props[1].props.n_prop_info = PROP_ID_LAST;
this->props[1].props.prop_info = prop_info;
this->props[1].props.set_prop = spa_props_generic_set_prop;
this->props[1].props.get_prop = spa_props_generic_get_prop;
reset_ffmpeg_enc_props (&this->props[1]);
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return SPA_RESULT_OK;
}

109
spa/plugins/ffmpeg/ffmpeg.c Normal file
View file

@ -0,0 +1,109 @@
/* Spa V4l2 support
* 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.
*/
#include <stdio.h>
#include <spa/plugin.h>
#include <spa/node.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
SpaResult spa_ffmpeg_dec_init (SpaHandle *handle);
SpaResult spa_ffmpeg_enc_init (SpaHandle *handle);
static SpaResult
ffmpeg_dec_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return spa_ffmpeg_dec_init (handle);
}
static SpaResult
ffmpeg_enc_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return spa_ffmpeg_enc_init (handle);
}
static const SpaInterfaceInfo ffmpeg_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
ffmpeg_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &ffmpeg_interfaces[index];
return SPA_RESULT_OK;
}
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
static const AVCodec *c = NULL;
static int ci = 0;
static SpaHandleFactory f;
static char name[128];
av_register_all();
if (index == 0 || index < ci) {
c = av_codec_next (NULL);
ci = 0;
}
while (index > ci && c) {
c = av_codec_next (c);
ci++;
}
if (c == NULL)
return SPA_RESULT_ENUM_END;
if (av_codec_is_encoder (c)) {
snprintf (name, 128, "ffenc_%s", c->name);
f.init = ffmpeg_enc_init;
}
else {
snprintf (name, 128, "ffdec_%s", c->name);
f.init = ffmpeg_dec_init;
}
f.name = name;
f.info = NULL;
f.enum_interface_info = ffmpeg_enum_interface_info;
*factory = &f;
return SPA_RESULT_OK;
}

10
spa/plugins/ffmpeg/meson.build Normal file
View file

@ -0,0 +1,10 @@
ffmpeg_sources = ['ffmpeg.c',
'ffmpeg-dec.c',
'ffmpeg-enc.c']
ffmpeglib = shared_library('spa-ffmpeg',
ffmpeg_sources,
include_directories : inc,
dependencies : [ avcodec_dep, avformat_dep ],
link_with : spalib,
install : true)

530
spa/plugins/libva/libva-dec.c Normal file
View file

@ -0,0 +1,530 @@
/* Spa Libva Decoder
* 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.
*/
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <spa/node.h>
#include <spa/video/format.h>
typedef struct _SpaLibvaDec SpaLibvaDec;
typedef struct {
SpaProps props;
} SpaLibvaDecProps;
static void
reset_libva_dec_props (SpaLibvaDecProps *props)
{
}
#define INPUT_PORT_ID 0
#define OUTPUT_PORT_ID 1
#define IS_VALID_PORT(id) ((id) < 2)
#define MAX_BUFFERS 32
typedef struct _LibvaBuffer LibvaBuffer;
struct _LibvaBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaLibvaDec *dec;
SpaBuffer *imported;
bool outstanding;
LibvaBuffer *next;
};
typedef struct {
SpaVideoRawFormat raw_format[2];
SpaFormat *current_format;
bool have_buffers;
LibvaBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
SpaPortStatus status;
} SpaLibvaState;
struct _SpaLibvaDec {
SpaHandle handle;
SpaLibvaDecProps props[2];
SpaEventCallback event_cb;
void *user_data;
SpaLibvaState state[2];
};
enum {
PROP_ID_LAST,
};
static const SpaPropInfo prop_info[] =
{
{ 0, },
};
static SpaResult
spa_libva_dec_node_get_props (SpaHandle *handle,
SpaProps **props)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
if (handle == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
*props = &this->props[0].props;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_set_props (SpaHandle *handle,
const SpaProps *props)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaDecProps *p = &this->props[1];
SpaResult res;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (props == NULL) {
reset_libva_dec_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
return res;
}
static SpaResult
spa_libva_dec_node_send_command (SpaHandle *handle,
SpaCommand *command)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
if (handle == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (command->type) {
case SPA_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
case SPA_COMMAND_START:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STARTED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STOPPED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_FLUSH:
case SPA_COMMAND_DRAIN:
case SPA_COMMAND_MARKER:
return SPA_RESULT_NOT_IMPLEMENTED;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_set_event_callback (SpaHandle *handle,
SpaEventCallback event,
void *user_data)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this->event_cb = event;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports)
*n_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0)
input_ids[0] = 0;
if (n_output_ports > 0)
output_ids[0] = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_add_port (SpaHandle *handle,
SpaDirection direction,
uint32_t *port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_dec_node_remove_port (SpaHandle *handle,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_dec_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
SpaFormat **format)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
switch (index) {
case 0:
spa_video_raw_format_init (&state->raw_format[0]);
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = &state->raw_format[0].format;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_set_format (SpaHandle *handle,
uint32_t port_id,
bool test_only,
const SpaFormat *format)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaState *state;
SpaResult res;
SpaFormat *f, *tf;
size_t fs;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (format == NULL) {
state->current_format = NULL;
return SPA_RESULT_OK;
}
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
return res;
f = &state->raw_format[0].format;
tf = &state->raw_format[1].format;
fs = sizeof (SpaVideoRawFormat);
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!test_only) {
memcpy (tf, f, fs);
state->current_format = tf;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_get_format (SpaHandle *handle,
uint32_t port_id,
const SpaFormat **format)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (state->current_format == NULL)
return SPA_RESULT_NO_FORMAT;
*format = state->current_format;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_get_info (SpaHandle *handle,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
if (handle == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*info = &this->state[port_id].info;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_get_props (SpaHandle *handle,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_dec_node_port_set_props (SpaHandle *handle,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_dec_node_port_get_status (SpaHandle *handle,
uint32_t port_id,
const SpaPortStatus **status)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
if (handle == NULL || status == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*status = &this->state[port_id].status;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_use_buffers (SpaHandle *handle,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_dec_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_dec_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
}
static SpaResult
spa_libva_dec_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
SpaOutputInfo *info)
{
SpaLibvaDec *this = (SpaLibvaDec *) handle;
SpaLibvaState *state;
unsigned int i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < n_info; i++) {
if (info[i].port_id != OUTPUT_PORT_ID) {
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
}
state = &this->state[info[i].port_id];
if (state->current_format == NULL) {
info[i].status = SPA_RESULT_NO_FORMAT;
have_error = true;
continue;
}
info[i].status = SPA_RESULT_OK;
}
if (have_error)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static const SpaNode libva_dec_node = {
sizeof (SpaNode),
spa_libva_dec_node_get_props,
spa_libva_dec_node_set_props,
spa_libva_dec_node_send_command,
spa_libva_dec_node_set_event_callback,
spa_libva_dec_node_get_n_ports,
spa_libva_dec_node_get_port_ids,
spa_libva_dec_node_add_port,
spa_libva_dec_node_remove_port,
spa_libva_dec_node_port_enum_formats,
spa_libva_dec_node_port_set_format,
spa_libva_dec_node_port_get_format,
spa_libva_dec_node_port_get_info,
spa_libva_dec_node_port_get_props,
spa_libva_dec_node_port_set_props,
spa_libva_dec_node_port_use_buffers,
spa_libva_dec_node_port_alloc_buffers,
spa_libva_dec_node_port_get_status,
spa_libva_dec_node_port_push_input,
spa_libva_dec_node_port_pull_output,
};
static SpaResult
spa_libva_dec_get_interface (SpaHandle *handle,
uint32_t interface_id,
const void **interface)
{
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (interface_id) {
case SPA_INTERFACE_ID_NODE:
*interface = &libva_dec_node;
break;
default:
return SPA_RESULT_UNKNOWN_INTERFACE;
}
return SPA_RESULT_OK;
}
SpaHandle *
spa_libva_dec_new (void)
{
SpaHandle *handle;
SpaLibvaDec *this;
handle = calloc (1, sizeof (SpaLibvaDec));
handle->get_interface = spa_libva_dec_get_interface;
this = (SpaLibvaDec *) handle;
this->props[1].props.n_prop_info = PROP_ID_LAST;
this->props[1].props.prop_info = prop_info;
this->props[1].props.set_prop = spa_props_generic_set_prop;
this->props[1].props.get_prop = spa_props_generic_get_prop;
reset_libva_dec_props (&this->props[1]);
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return handle;
}

530
spa/plugins/libva/libva-enc.c Normal file
View file

@ -0,0 +1,530 @@
/* Spa Libva Encoder
* 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.
*/
#include <stddef.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <spa/node.h>
#include <spa/video/format.h>
typedef struct _SpaLibvaEnc SpaLibvaEnc;
typedef struct {
SpaProps props;
} SpaLibvaEncProps;
static void
reset_libva_enc_props (SpaLibvaEncProps *props)
{
}
#define INPUT_PORT_ID 0
#define OUTPUT_PORT_ID 1
#define IS_VALID_PORT(id) ((id) < 2)
#define MAX_BUFFERS 32
typedef struct _LibvaBuffer LibvaBuffer;
struct _LibvaBuffer {
SpaBuffer buffer;
SpaMeta metas[1];
SpaMetaHeader header;
SpaData datas[1];
SpaLibvaEnc *enc;
SpaBuffer *imported;
bool outstanding;
LibvaBuffer *next;
};
typedef struct {
SpaVideoRawFormat raw_format[2];
SpaFormat *current_format;
bool have_buffers;
LibvaBuffer buffers[MAX_BUFFERS];
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
SpaPortStatus status;
} SpaLibvaState;
struct _SpaLibvaEnc {
SpaHandle handle;
SpaLibvaEncProps props[2];
SpaEventCallback event_cb;
void *user_data;
SpaLibvaState state[2];
};
enum {
PROP_ID_LAST,
};
static const SpaPropInfo prop_info[] =
{
{ 0, },
};
static SpaResult
spa_libva_enc_node_get_props (SpaHandle *handle,
SpaProps **props)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
if (handle == NULL || props == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
memcpy (&this->props[0], &this->props[1], sizeof (this->props[1]));
*props = &this->props[0].props;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_set_props (SpaHandle *handle,
const SpaProps *props)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaEncProps *p = &this->props[1];
SpaResult res;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (props == NULL) {
reset_libva_enc_props (p);
return SPA_RESULT_OK;
}
res = spa_props_copy (props, &p->props);
return res;
}
static SpaResult
spa_libva_enc_node_send_command (SpaHandle *handle,
SpaCommand *command)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
if (handle == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (command->type) {
case SPA_COMMAND_INVALID:
return SPA_RESULT_INVALID_COMMAND;
case SPA_COMMAND_START:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STARTED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_STOP:
if (this->event_cb) {
SpaEvent event;
event.refcount = 1;
event.notify = NULL;
event.type = SPA_EVENT_TYPE_STOPPED;
event.port_id = -1;
event.data = NULL;
event.size = 0;
this->event_cb (handle, &event, this->user_data);
}
break;
case SPA_COMMAND_FLUSH:
case SPA_COMMAND_DRAIN:
case SPA_COMMAND_MARKER:
return SPA_RESULT_NOT_IMPLEMENTED;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_set_event_callback (SpaHandle *handle,
SpaEventCallback event,
void *user_data)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this->event_cb = event;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_get_n_ports (SpaHandle *handle,
unsigned int *n_input_ports,
unsigned int *max_input_ports,
unsigned int *n_output_ports,
unsigned int *max_output_ports)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports)
*n_input_ports = 1;
if (n_output_ports)
*n_output_ports = 1;
if (max_input_ports)
*max_input_ports = 1;
if (max_output_ports)
*max_output_ports = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_get_port_ids (SpaHandle *handle,
unsigned int n_input_ports,
uint32_t *input_ids,
unsigned int n_output_ports,
uint32_t *output_ids)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0)
input_ids[0] = 0;
if (n_output_ports > 0)
output_ids[0] = 1;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_add_port (SpaHandle *handle,
SpaDirection direction,
uint32_t *port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_enc_node_remove_port (SpaHandle *handle,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_enc_node_port_enum_formats (SpaHandle *handle,
uint32_t port_id,
unsigned int index,
SpaFormat **format)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
switch (index) {
case 0:
spa_video_raw_format_init (&state->raw_format[0]);
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = &state->raw_format[0].format;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_set_format (SpaHandle *handle,
uint32_t port_id,
bool test_only,
const SpaFormat *format)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaState *state;
SpaResult res;
SpaFormat *f, *tf;
size_t fs;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (format == NULL) {
state->current_format = NULL;
return SPA_RESULT_OK;
}
if (format->media_type == SPA_MEDIA_TYPE_VIDEO) {
if (format->media_subtype == SPA_MEDIA_SUBTYPE_RAW) {
if ((res = spa_video_raw_format_parse (format, &state->raw_format[0]) < 0))
return res;
f = &state->raw_format[0].format;
tf = &state->raw_format[1].format;
fs = sizeof (SpaVideoRawFormat);
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
} else
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!test_only) {
memcpy (tf, f, fs);
state->current_format = tf;
}
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_get_format (SpaHandle *handle,
uint32_t port_id,
const SpaFormat **format)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaState *state;
if (handle == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
state = &this->state[port_id];
if (state->current_format == NULL)
return SPA_RESULT_NO_FORMAT;
*format = state->current_format;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_get_info (SpaHandle *handle,
uint32_t port_id,
const SpaPortInfo **info)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
if (handle == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*info = &this->state[port_id].info;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_get_props (SpaHandle *handle,
uint32_t port_id,
SpaProps **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_enc_node_port_set_props (SpaHandle *handle,
uint32_t port_id,
const SpaProps *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_enc_node_port_get_status (SpaHandle *handle,
uint32_t port_id,
const SpaPortStatus **status)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
if (handle == NULL || status == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
*status = &this->state[port_id].status;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_use_buffers (SpaHandle *handle,
uint32_t port_id,
SpaBuffer **buffers,
uint32_t n_buffers)
{
if (handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_OK;
}
static SpaResult
spa_libva_enc_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static SpaResult
spa_libva_enc_node_port_push_input (SpaHandle *handle,
unsigned int n_info,
SpaInputInfo *info)
{
return SPA_RESULT_INVALID_PORT;
}
static SpaResult
spa_libva_enc_node_port_pull_output (SpaHandle *handle,
unsigned int n_info,
SpaOutputInfo *info)
{
SpaLibvaEnc *this = (SpaLibvaEnc *) handle;
SpaLibvaState *state;
unsigned int i;
bool have_error = false;
if (handle == NULL || n_info == 0 || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
for (i = 0; i < n_info; i++) {
if (info[i].port_id != OUTPUT_PORT_ID) {
info[i].status = SPA_RESULT_INVALID_PORT;
have_error = true;
continue;
}
state = &this->state[info[i].port_id];
if (state->current_format == NULL) {
info[i].status = SPA_RESULT_NO_FORMAT;
have_error = true;
continue;
}
info[i].status = SPA_RESULT_OK;
}
if (have_error)
return SPA_RESULT_ERROR;
return SPA_RESULT_OK;
}
static const SpaNode libva_enc_node = {
sizeof (SpaNode),
spa_libva_enc_node_get_props,
spa_libva_enc_node_set_props,
spa_libva_enc_node_send_command,
spa_libva_enc_node_set_event_callback,
spa_libva_enc_node_get_n_ports,
spa_libva_enc_node_get_port_ids,
spa_libva_enc_node_add_port,
spa_libva_enc_node_remove_port,
spa_libva_enc_node_port_enum_formats,
spa_libva_enc_node_port_set_format,
spa_libva_enc_node_port_get_format,
spa_libva_enc_node_port_get_info,
spa_libva_enc_node_port_get_props,
spa_libva_enc_node_port_set_props,
spa_libva_enc_node_port_use_buffers,
spa_libva_enc_node_port_alloc_buffers,
spa_libva_enc_node_port_get_status,
spa_libva_enc_node_port_push_input,
spa_libva_enc_node_port_pull_output,
};
static SpaResult
spa_libva_enc_get_interface (SpaHandle *handle,
uint32_t interface_id,
const void **interface)
{
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (interface_id) {
case SPA_INTERFACE_ID_NODE:
*interface = &libva_enc_node;
break;
default:
return SPA_RESULT_UNKNOWN_INTERFACE;
}
return SPA_RESULT_OK;
}
SpaHandle *
spa_libva_enc_new (void)
{
SpaHandle *handle;
SpaLibvaEnc *this;
handle = calloc (1, sizeof (SpaLibvaEnc));
handle->get_interface = spa_libva_enc_get_interface;
this = (SpaLibvaEnc *) handle;
this->props[1].props.n_prop_info = PROP_ID_LAST;
this->props[1].props.prop_info = prop_info;
this->props[1].props.set_prop = spa_props_generic_set_prop;
this->props[1].props.get_prop = spa_props_generic_get_prop;
reset_libva_enc_props (&this->props[1]);
this->state[INPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[INPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
this->state[OUTPUT_PORT_ID].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[OUTPUT_PORT_ID].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return handle;
}

96
spa/plugins/libva/libva.c Normal file
View file

@ -0,0 +1,96 @@
/* Spa V4l2 support
* 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.
*/
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_libva_dec_new (void);
SpaHandle * spa_libva_enc_new (void);
static SpaResult
libva_dec_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_libva_dec_new ();
return SPA_RESULT_OK;
}
static SpaResult
libva_enc_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_libva_enc_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo libva_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
libva_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &libva_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "libva-dec",
NULL,
libva_dec_instantiate,
libva_enum_interface_info,
},
{ "libva-enc",
NULL,
libva_enc_instantiate,
libva_enum_interface_info,
}
};
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 2)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
return SPA_RESULT_OK;
}

10
spa/plugins/libva/meson.build Normal file
View file

@ -0,0 +1,10 @@
libva_sources = ['libva.c',
'libva-dec.c',
'libva-enc.c']
libvalib = shared_library('spa-libva',
libva_sources,
include_directories : inc,
dependencies : libva_dep,
link_with : spalib,
install : true)

1161
spa/plugins/libva/vaapi-recorder.c Normal file
View file

File diff suppressed because it is too large Load diff

38
spa/plugins/libva/vaapi-recorder.h Normal file
View file

@ -0,0 +1,38 @@
/*
* Copyright © 2013 Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef _VAAPI_RECORDER_H_
#define _VAAPI_RECORDER_H_
struct vaapi_recorder;
struct vaapi_recorder *
vaapi_recorder_create(int drm_fd, int width, int height, const char *filename);
void
vaapi_recorder_destroy(struct vaapi_recorder *r);
int
vaapi_recorder_frame(struct vaapi_recorder *r, int fd, int stride);
#endif /* _VAAPI_RECORDER_H_ */

2
spa/plugins/meson.build
View file

@ -1,6 +1,8 @@
subdir('alsa')
subdir('audiomixer')
subdir('audiotestsrc')
subdir('ffmpeg')
#subdir('libva')
subdir('volume')
subdir('v4l2')
subdir('xv')

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

@ -77,6 +77,8 @@ typedef struct {
SpaPollFd fds[1];
SpaPollItem poll;
SpaPortInfo info;
SpaAllocParam *params[1];
SpaAllocParamBuffers param_buffers;
SpaPortStatus status;
} SpaV4l2State;
@ -467,6 +469,8 @@ spa_v4l2_source_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_v4l2_source_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -573,13 +577,15 @@ spa_v4l2_source_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_v4l2_source_new (void)
static SpaResult
v4l2_source_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaV4l2Source *this;
handle = calloc (1, sizeof (SpaV4l2Source));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_v4l2_source_get_interface;
this = (SpaV4l2Source *) handle;
@ -591,5 +597,35 @@ spa_v4l2_source_new (void)
this->state[0].info.flags = SPA_PORT_INFO_FLAG_NONE;
this->state[0].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo v4l2_source_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
v4l2_source_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &v4l2_source_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_v4l2_source_factory =
{ "v4l2-source",
NULL,
sizeof (SpaV4l2Source),
v4l2_source_init,
v4l2_source_enum_interface_info,
};

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

@ -314,13 +314,19 @@ spa_v4l2_set_format (SpaV4l2Source *this, SpaFormat *format, bool try_only)
state->fmt = fmt;
state->info.flags = SPA_PORT_INFO_FLAG_CAN_GIVE_BUFFER;
state->info.minsize = fmt.fmt.pix.sizeimage;
state->info.stride = fmt.fmt.pix.bytesperline;
state->info.min_buffers = 2;
state->info.max_buffers = MAX_BUFFERS;
state->info.align = 16;
state->info.maxbuffering = -1;
state->info.latency = -1;
state->info.n_params = 1;
state->info.params = state->params;
state->params[0] = &state->param_buffers.param;
state->param_buffers.param.type = SPA_ALLOC_PARAM_TYPE_BUFFERS;
state->param_buffers.param.size = sizeof (&state->buffers);
state->param_buffers.minsize = fmt.fmt.pix.sizeimage;
state->param_buffers.stride = fmt.fmt.pix.bytesperline;
state->param_buffers.min_buffers = 2;
state->param_buffers.max_buffers = MAX_BUFFERS;
state->param_buffers.align = 16;
state->info.features = NULL;
return 0;
@ -334,6 +340,7 @@ spa_v4l2_close (SpaV4l2Source *this)
if (!state->opened)
return 0;
fprintf (stderr, "close\n");
if (close(state->fd))
perror ("close");

58
spa/plugins/v4l2/v4l2.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_v4l2_source_new (void);
static SpaResult
v4l2_source_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_v4l2_source_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo v4l2_source_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
v4l2_source_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &v4l2_source_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "v4l2-source",
NULL,
v4l2_source_instantiate,
v4l2_source_enum_interface_info,
},
};
extern const SpaHandleFactory spa_v4l2_source_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (index) {
case 0:
*factory = &spa_v4l2_source_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

58
spa/plugins/volume/plugin.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_volume_new (void);
static SpaResult
volume_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_volume_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo volume_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
volume_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &volume_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "volume",
NULL,
volume_instantiate,
volume_enum_interface_info,
},
};
extern const SpaHandleFactory spa_volume_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (index) {
case 0:
*factory = &spa_volume_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

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

@ -398,6 +398,8 @@ spa_volume_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_volume_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -594,13 +596,15 @@ spa_volume_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_volume_new (void)
static SpaResult
volume_instantiate (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaVolume *this;
handle = calloc (1, sizeof (SpaVolume));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_volume_get_interface;
this = (SpaVolume *) handle;
@ -619,5 +623,34 @@ spa_volume_new (void)
this->ports[0].status.flags = SPA_PORT_STATUS_FLAG_NEED_INPUT;
this->ports[1].status.flags = SPA_PORT_STATUS_FLAG_NONE;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo volume_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
volume_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &volume_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_volume_factory =
{ "volume",
NULL,
sizeof (SpaVolume),
volume_instantiate,
volume_enum_interface_info,
};

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

@ -442,6 +442,8 @@ spa_xv_sink_node_port_use_buffers (SpaHandle *handle,
static SpaResult
spa_xv_sink_node_port_alloc_buffers (SpaHandle *handle,
uint32_t port_id,
SpaAllocParam **params,
uint32_t n_params,
SpaBuffer **buffers,
uint32_t *n_buffers)
{
@ -546,13 +548,15 @@ spa_xv_sink_get_interface (SpaHandle *handle,
return SPA_RESULT_OK;
}
SpaHandle *
spa_xv_sink_new (void)
static SpaResult
xv_sink_init (const SpaHandleFactory *factory,
SpaHandle *handle)
{
SpaHandle *handle;
SpaXvSink *this;
handle = calloc (1, sizeof (SpaXvSink));
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
handle->get_interface = spa_xv_sink_get_interface;
this = (SpaXvSink *) handle;
@ -564,5 +568,35 @@ spa_xv_sink_new (void)
this->info.flags = SPA_PORT_INFO_FLAG_NONE;
this->status.flags = SPA_PORT_STATUS_FLAG_NONE;
return handle;
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo xv_sink_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
xv_sink_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &xv_sink_interfaces[index];
return SPA_RESULT_OK;
}
const SpaHandleFactory spa_xv_sink_factory =
{ "xv-sink",
NULL,
sizeof (SpaXvSink),
xv_sink_init,
xv_sink_enum_interface_info,
};

58
spa/plugins/xv/xv.c
View file

@ -20,59 +20,21 @@
#include <spa/plugin.h>
#include <spa/node.h>
SpaHandle * spa_xv_sink_new (void);
static SpaResult
xv_sink_instantiate (const SpaHandleFactory *factory,
SpaHandle **handle)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
*handle = spa_xv_sink_new ();
return SPA_RESULT_OK;
}
static const SpaInterfaceInfo xv_sink_interfaces[] =
{
{ SPA_INTERFACE_ID_NODE,
SPA_INTERFACE_ID_NODE_NAME,
SPA_INTERFACE_ID_NODE_DESCRIPTION,
},
};
static SpaResult
xv_sink_enum_interface_info (const SpaHandleFactory *factory,
unsigned int index,
const SpaInterfaceInfo **info)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &xv_sink_interfaces[index];
return SPA_RESULT_OK;
}
static const SpaHandleFactory factories[] =
{
{ "xv-sink",
NULL,
xv_sink_instantiate,
xv_sink_enum_interface_info,
},
};
extern const SpaHandleFactory spa_xv_sink_factory;
SpaResult
spa_enum_handle_factory (unsigned int index,
const SpaHandleFactory **factory)
{
if (index >= 1)
return SPA_RESULT_ENUM_END;
*factory = &factories[index];
if (factory == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
switch (index) {
case 0:
*factory = &spa_xv_sink_factory;
break;
default:
return SPA_RESULT_ENUM_END;
}
return SPA_RESULT_OK;
}

2
spa/tests/meson.build
View file

@ -1,9 +1,11 @@
executable('test-mixer', 'test-mixer.c',
include_directories : inc,
dependencies : [dl_lib, pthread_lib],
link_with : spalib,
install : false)
executable('test-v4l2', 'test-v4l2.c',
include_directories : inc,
dependencies : [dl_lib, sdl_dep, pthread_lib],
link_with : spalib,
install : false)

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

@ -75,7 +75,8 @@ make_node (SpaHandle **handle, const SpaNode **node, const char *lib, const char
if (strcmp (factory->name, name))
continue;
if ((res = factory->instantiate (factory, handle)) < 0) {
*handle = calloc (1, factory->size);
if ((res = factory->init (factory, *handle)) < 0) {
printf ("can't make factory instance: %d\n", res);
return res;
}
@ -200,8 +201,8 @@ make_nodes (AppData *data)
printf ("got get_props error %d\n", res);
value.type = SPA_PROP_TYPE_STRING;
value.size = strlen ("hw:1")+1;
value.value = "hw:1";
value.value = "hw:0";
value.size = strlen (value.value)+1;
props->set_prop (props, spa_props_index_for_name (props, "device"), &value);
if ((res = data->sink_node->set_props (data->sink, props)) < 0)

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

@ -29,9 +29,10 @@
#include <SDL2/SDL.h>
#include <spa/node.h>
#include <spa/debug.h>
#include <spa/video/format.h>
#define USE_BUFFER
#undef USE_BUFFER
#define MAX_BUFFERS 8
@ -87,7 +88,8 @@ make_node (SpaHandle **handle, const SpaNode **node, const char *lib, const char
if (strcmp (factory->name, name))
continue;
if ((res = factory->instantiate (factory, handle)) < 0) {
*handle = calloc (1, factory->size);
if ((res = factory->init (factory, *handle)) < 0) {
printf ("can't make factory instance: %d\n", res);
return res;
}
@ -309,14 +311,7 @@ negotiate_formats (AppData *data)
if ((res = data->source_node->port_get_info (data->source, 0, &info)) < 0)
return res;
printf ("flags: %d\n", info->flags);
printf ("minsize: %zd\n", info->minsize);
printf ("stride: %zd\n", info->stride);
printf ("min_buffers: %d\n", info->min_buffers);
printf ("max_buffers: %d\n", info->max_buffers);
printf ("align: %d\n", info->align);
printf ("maxbuffering: %d\n", info->maxbuffering);
printf ("latency: %lu\n", info->latency);
spa_debug_port_info (info);
#ifdef USE_BUFFER
alloc_buffers (data);

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

@ -188,7 +188,8 @@ inspect_factory (const SpaHandleFactory *factory)
else
printf (" none\n");
if ((res = factory->instantiate (factory, &handle)) < 0) {
handle = calloc (1, factory->size);
if ((res = factory->init (factory, handle)) < 0) {
printf ("can't make factory instance: %d\n", res);
return;
}