mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-31 22:25:38 -04: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

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;
}