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

indent -kr -i8 -l100

Browse source
This commit is contained in:
Wim Taymans 2017-05-25 16:23:13 +02:00
parent 11f23a3ffa
commit d1a06ae247
28 changed files with 7034 additions and 10381 deletions
Download patch file Download diff file Expand all files Collapse all files

676
spa/plugins/ffmpeg/ffmpeg-dec.c
View file

@ -32,490 +32,478 @@
#define MAX_BUFFERS 32
struct buffer {
struct spa_buffer *outbuf;
bool outstanding;
struct buffer *next;
struct spa_buffer *outbuf;
bool outstanding;
struct buffer *next;
};
struct port {
bool have_format;
struct spa_video_info current_format;
bool have_buffers;
struct buffer buffers[MAX_BUFFERS];
struct spa_port_info info;
struct spa_port_io *io;
bool have_format;
struct spa_video_info current_format;
bool have_buffers;
struct buffer buffers[MAX_BUFFERS];
struct spa_port_info info;
struct spa_port_io *io;
};
struct type {
uint32_t node;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_command_node command_node;
uint32_t node;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_command_node command_node;
};
static inline void
init_type (struct type *type, struct spa_type_map *map)
static inline void init_type(struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video);
spa_type_command_node_map (map, &type->command_node);
type->node = spa_type_map_get_id(map, SPA_TYPE__Node);
spa_type_media_type_map(map, &type->media_type);
spa_type_media_subtype_map(map, &type->media_subtype);
spa_type_format_video_map(map, &type->format_video);
spa_type_command_node_map(map, &type->command_node);
}
struct impl {
struct spa_handle handle;
struct spa_node node;
struct spa_handle handle;
struct spa_node node;
struct type type;
struct spa_type_map *map;
struct spa_log *log;
struct type type;
struct spa_type_map *map;
struct spa_log *log;
struct spa_node_callbacks callbacks;
void *user_data;
struct spa_node_callbacks callbacks;
void *user_data;
struct port in_ports[1];
struct port out_ports[1];
struct port in_ports[1];
struct port out_ports[1];
bool started;
bool started;
};
static int
spa_ffmpeg_dec_node_get_props (struct spa_node *node,
struct spa_props **props)
static int spa_ffmpeg_dec_node_get_props(struct spa_node *node, struct spa_props **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int spa_ffmpeg_dec_node_set_props(struct spa_node *node, const struct spa_props *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int spa_ffmpeg_dec_node_send_command(struct spa_node *node, struct spa_command *command)
{
struct impl *this;
if (node == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF(node, struct impl, node);
if (SPA_COMMAND_TYPE(command) == this->type.command_node.Start) {
this->started = true;
} else if (SPA_COMMAND_TYPE(command) == this->type.command_node.Pause) {
this->started = false;
} else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_set_props (struct spa_node *node,
const struct spa_props *props)
spa_ffmpeg_dec_node_set_callbacks(struct spa_node *node,
const struct spa_node_callbacks *callbacks,
size_t callbacks_size,
void *user_data)
{
return SPA_RESULT_NOT_IMPLEMENTED;
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF(node, struct impl, node);
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_send_command (struct spa_node *node,
struct spa_command *command)
spa_ffmpeg_dec_node_get_n_ports(struct spa_node *node,
uint32_t * n_input_ports,
uint32_t * max_input_ports,
uint32_t * n_output_ports,
uint32_t * max_output_ports)
{
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || command == 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;
this = SPA_CONTAINER_OF (node, struct impl, node);
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
this->started = true;
}
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
this->started = false;
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_set_callbacks (struct spa_node *node,
const struct spa_node_callbacks *callbacks,
size_t callbacks_size,
void *user_data)
spa_ffmpeg_dec_node_get_port_ids(struct spa_node *node,
uint32_t n_input_ports,
uint32_t * input_ids,
uint32_t n_output_ports,
uint32_t * output_ids)
{
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0 && input_ids != NULL)
input_ids[0] = 0;
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
this = SPA_CONTAINER_OF (node, struct impl, node);
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_get_n_ports (struct spa_node *node,
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == 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 int
spa_ffmpeg_dec_node_get_port_ids (struct spa_node *node,
uint32_t n_input_ports,
uint32_t *input_ids,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0 && input_ids != NULL)
input_ids[0] = 0;
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_add_port (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id)
spa_ffmpeg_dec_node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_remove_port (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id)
spa_ffmpeg_dec_node_remove_port(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_enum_formats (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
spa_ffmpeg_dec_node_port_enum_formats(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
{
//struct impl *this;
//struct impl *this;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
//this = SPA_CONTAINER_OF (node, struct impl, node);
//this = SPA_CONTAINER_OF (node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
switch (index) {
case 0:
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = NULL;
switch (index) {
case 0:
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = NULL;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_port_set_format (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
const struct spa_format *format)
spa_ffmpeg_dec_node_port_set_format(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
const struct spa_format *format)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
if (format == NULL) {
port->have_format = false;
return SPA_RESULT_OK;
} else {
struct spa_video_info info = { SPA_FORMAT_MEDIA_TYPE (format),
SPA_FORMAT_MEDIA_SUBTYPE (format), };
if (format == NULL) {
port->have_format = false;
return SPA_RESULT_OK;
} else {
struct spa_video_info info = { SPA_FORMAT_MEDIA_TYPE(format),
SPA_FORMAT_MEDIA_SUBTYPE(format),
};
if (info.media_type != this->type.media_type.video &&
info.media_subtype != this->type.media_subtype.raw)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (info.media_type != this->type.media_type.video &&
info.media_subtype != this->type.media_subtype.raw)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!spa_format_video_raw_parse (format, &info.info.raw, &this->type.format_video))
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!spa_format_video_raw_parse(format, &info.info.raw, &this->type.format_video))
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!(flags & SPA_PORT_FORMAT_FLAG_TEST_ONLY)) {
port->current_format = info;
port->have_format = true;
}
}
return SPA_RESULT_OK;
if (!(flags & SPA_PORT_FORMAT_FLAG_TEST_ONLY)) {
port->current_format = info;
port->have_format = true;
}
}
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_port_get_format (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_format **format)
spa_ffmpeg_dec_node_port_get_format(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_format **format)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
*format = NULL;
*format = NULL;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_port_get_info (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_port_info **info)
spa_ffmpeg_dec_node_port_get_info(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_port_info **info)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
*info = &port->info;
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
*info = &port->info;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_port_enum_params (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t index,
struct spa_param **param)
spa_ffmpeg_dec_node_port_enum_params(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t index,
struct spa_param **param)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_set_param (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_param *param)
spa_ffmpeg_dec_node_port_set_param(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_param *param)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_use_buffers (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_buffer **buffers,
uint32_t n_buffers)
spa_ffmpeg_dec_node_port_use_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_buffer **buffers,
uint32_t n_buffers)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (node, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(node, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_alloc_buffers (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_param **params,
uint32_t n_params,
struct spa_buffer **buffers,
uint32_t *n_buffers)
spa_ffmpeg_dec_node_port_alloc_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_param **params,
uint32_t n_params,
struct spa_buffer **buffers,
uint32_t * n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_set_io (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_port_io *io)
spa_ffmpeg_dec_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_port_io *io)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port->io = io;
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port->io = io;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int spa_ffmpeg_dec_node_process_input(struct spa_node *node)
{
return SPA_RESULT_INVALID_PORT;
}
static int spa_ffmpeg_dec_node_process_output(struct spa_node *node)
{
struct impl *this;
struct port *port;
struct spa_port_io *output;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF(node, struct impl, node);
port = &this->out_ports[0];
if ((output = port->io) == NULL)
return SPA_RESULT_ERROR;
if (!port->have_format) {
output->status = SPA_RESULT_NO_FORMAT;
return SPA_RESULT_ERROR;
}
output->status = SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_process_input (struct spa_node *node)
spa_ffmpeg_dec_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
return SPA_RESULT_INVALID_PORT;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_process_output (struct spa_node *node)
spa_ffmpeg_dec_node_port_send_command(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_command *command)
{
struct impl *this;
struct port *port;
struct spa_port_io *output;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
port = &this->out_ports[0];
if ((output = port->io) == NULL)
return SPA_RESULT_ERROR;
if (!port->have_format) {
output->status = SPA_RESULT_NO_FORMAT;
return SPA_RESULT_ERROR;
}
output->status = SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_dec_node_port_reuse_buffer (struct spa_node *node,
uint32_t port_id,
uint32_t buffer_id)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_dec_node_port_send_command (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_command *command)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static const struct spa_node ffmpeg_dec_node = {
sizeof (struct spa_node),
NULL,
spa_ffmpeg_dec_node_get_props,
spa_ffmpeg_dec_node_set_props,
spa_ffmpeg_dec_node_send_command,
spa_ffmpeg_dec_node_set_callbacks,
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_enum_params,
spa_ffmpeg_dec_node_port_set_param,
spa_ffmpeg_dec_node_port_use_buffers,
spa_ffmpeg_dec_node_port_alloc_buffers,
spa_ffmpeg_dec_node_port_set_io,
spa_ffmpeg_dec_node_port_reuse_buffer,
spa_ffmpeg_dec_node_port_send_command,
spa_ffmpeg_dec_node_process_input,
spa_ffmpeg_dec_node_process_output,
sizeof(struct spa_node),
NULL,
spa_ffmpeg_dec_node_get_props,
spa_ffmpeg_dec_node_set_props,
spa_ffmpeg_dec_node_send_command,
spa_ffmpeg_dec_node_set_callbacks,
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_enum_params,
spa_ffmpeg_dec_node_port_set_param,
spa_ffmpeg_dec_node_port_use_buffers,
spa_ffmpeg_dec_node_port_alloc_buffers,
spa_ffmpeg_dec_node_port_set_io,
spa_ffmpeg_dec_node_port_reuse_buffer,
spa_ffmpeg_dec_node_port_send_command,
spa_ffmpeg_dec_node_process_input,
spa_ffmpeg_dec_node_process_output,
};
static int
spa_ffmpeg_dec_get_interface (struct spa_handle *handle,
uint32_t interface_id,
void **interface)
spa_ffmpeg_dec_get_interface(struct spa_handle *handle, uint32_t interface_id, void **interface)
{
struct impl *this;
struct impl *this;
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = (struct impl *) handle;
this = (struct impl *) handle;
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
int
spa_ffmpeg_dec_init (struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
spa_ffmpeg_dec_init(struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
struct impl *this;
uint32_t i;
struct impl *this;
uint32_t i;
handle->get_interface = spa_ffmpeg_dec_get_interface;
handle->get_interface = spa_ffmpeg_dec_get_interface;
this = (struct impl *) handle;
this = (struct impl *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_type (&this->type, this->map);
for (i = 0; i < n_support; i++) {
if (strcmp(support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp(support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error(this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
init_type(&this->type, this->map);
this->node = ffmpeg_dec_node;
this->node = ffmpeg_dec_node;
this->in_ports[0].info.flags = 0;
this->out_ports[0].info.flags = 0;
this->in_ports[0].info.flags = 0;
this->out_ports[0].info.flags = 0;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}

642
spa/plugins/ffmpeg/ffmpeg-enc.c
View file

@ -32,495 +32,467 @@
#define MAX_BUFFERS 32
struct buffer {
struct spa_buffer buffer;
struct spa_meta metas[1];
struct spa_meta_header header;
struct spa_data datas[1];
struct spa_buffer *imported;
bool outstanding;
struct buffer *next;
struct spa_buffer buffer;
struct spa_meta metas[1];
struct spa_meta_header header;
struct spa_data datas[1];
struct spa_buffer *imported;
bool outstanding;
struct buffer *next;
};
struct port {
bool have_format;
struct spa_video_info current_format;
bool have_buffers;
struct buffer buffers[MAX_BUFFERS];
struct spa_port_info info;
struct spa_port_io *io;
bool have_format;
struct spa_video_info current_format;
bool have_buffers;
struct buffer buffers[MAX_BUFFERS];
struct spa_port_info info;
struct spa_port_io *io;
};
struct type {
uint32_t node;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_command_node command_node;
uint32_t node;
struct spa_type_media_type media_type;
struct spa_type_media_subtype media_subtype;
struct spa_type_format_video format_video;
struct spa_type_command_node command_node;
};
static inline void
init_type (struct type *type, struct spa_type_map *map)
static inline void init_type(struct type *type, struct spa_type_map *map)
{
type->node = spa_type_map_get_id (map, SPA_TYPE__Node);
spa_type_media_type_map (map, &type->media_type);
spa_type_media_subtype_map (map, &type->media_subtype);
spa_type_format_video_map (map, &type->format_video);
spa_type_command_node_map (map, &type->command_node);
type->node = spa_type_map_get_id(map, SPA_TYPE__Node);
spa_type_media_type_map(map, &type->media_type);
spa_type_media_subtype_map(map, &type->media_subtype);
spa_type_format_video_map(map, &type->format_video);
spa_type_command_node_map(map, &type->command_node);
}
struct impl {
struct spa_handle handle;
struct spa_node node;
struct spa_handle handle;
struct spa_node node;
struct type type;
struct spa_type_map *map;
struct spa_log *log;
struct type type;
struct spa_type_map *map;
struct spa_log *log;
struct spa_node_callbacks callbacks;
void *user_data;
struct spa_node_callbacks callbacks;
void *user_data;
struct port in_ports[1];
struct port out_ports[1];
struct port in_ports[1];
struct port out_ports[1];
bool started;
bool started;
};
static int
spa_ffmpeg_enc_node_get_props (struct spa_node *node,
struct spa_props **props)
static int spa_ffmpeg_enc_node_get_props(struct spa_node *node, struct spa_props **props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int spa_ffmpeg_enc_node_set_props(struct spa_node *node, const struct spa_props *props)
{
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int spa_ffmpeg_enc_node_send_command(struct spa_node *node, struct spa_command *command)
{
struct impl *this;
if (node == NULL || command == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF(node, struct impl, node);
if (SPA_COMMAND_TYPE(command) == this->type.command_node.Start) {
this->started = true;
} else if (SPA_COMMAND_TYPE(command) == this->type.command_node.Pause) {
this->started = false;
} else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_set_props (struct spa_node *node,
const struct spa_props *props)
spa_ffmpeg_enc_node_set_callbacks(struct spa_node *node,
const struct spa_node_callbacks *callbacks,
size_t callbacks_size, void *user_data)
{
return SPA_RESULT_NOT_IMPLEMENTED;
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF(node, struct impl, node);
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_send_command (struct spa_node *node,
struct spa_command *command)
spa_ffmpeg_enc_node_get_n_ports(struct spa_node *node,
uint32_t * n_input_ports,
uint32_t * max_input_ports,
uint32_t * n_output_ports, uint32_t * max_output_ports)
{
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || command == 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;
this = SPA_CONTAINER_OF (node, struct impl, node);
if (SPA_COMMAND_TYPE (command) == this->type.command_node.Start) {
this->started = true;
}
else if (SPA_COMMAND_TYPE (command) == this->type.command_node.Pause) {
this->started = false;
}
else
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_set_callbacks (struct spa_node *node,
const struct spa_node_callbacks *callbacks,
size_t callbacks_size,
void *user_data)
spa_ffmpeg_enc_node_get_port_ids(struct spa_node *node,
uint32_t n_input_ports,
uint32_t * input_ids,
uint32_t n_output_ports, uint32_t * output_ids)
{
struct impl *this;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0 && input_ids != NULL)
input_ids[0] = 0;
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
this = SPA_CONTAINER_OF (node, struct impl, node);
this->callbacks = *callbacks;
this->user_data = user_data;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_get_n_ports (struct spa_node *node,
uint32_t *n_input_ports,
uint32_t *max_input_ports,
uint32_t *n_output_ports,
uint32_t *max_output_ports)
{
if (node == 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 int
spa_ffmpeg_enc_node_get_port_ids (struct spa_node *node,
uint32_t n_input_ports,
uint32_t *input_ids,
uint32_t n_output_ports,
uint32_t *output_ids)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (n_input_ports > 0 && input_ids != NULL)
input_ids[0] = 0;
if (n_output_ports > 0 && output_ids != NULL)
output_ids[0] = 0;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_add_port (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id)
spa_ffmpeg_enc_node_add_port(struct spa_node *node, enum spa_direction direction, uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_remove_port (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id)
spa_ffmpeg_enc_node_remove_port(struct spa_node *node,
enum spa_direction direction, uint32_t port_id)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_enum_formats (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter,
uint32_t index)
spa_ffmpeg_enc_node_port_enum_formats(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_format **format,
const struct spa_format *filter, uint32_t index)
{
//struct impl *this;
//struct port *port;
//struct impl *this;
//struct port *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
//this = SPA_CONTAINER_OF (node, struct impl, node);
//this = SPA_CONTAINER_OF (node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
//port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
//port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
switch (index) {
case 0:
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = NULL;
switch (index) {
case 0:
break;
default:
return SPA_RESULT_ENUM_END;
}
*format = NULL;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_port_set_format (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
const struct spa_format *format)
spa_ffmpeg_enc_node_port_set_format(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags, const struct spa_format *format)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
if (format == NULL) {
port->have_format = false;
return SPA_RESULT_OK;
} else {
struct spa_video_info info = { SPA_FORMAT_MEDIA_TYPE (format),
SPA_FORMAT_MEDIA_SUBTYPE (format), };
if (format == NULL) {
port->have_format = false;
return SPA_RESULT_OK;
} else {
struct spa_video_info info = { SPA_FORMAT_MEDIA_TYPE(format),
SPA_FORMAT_MEDIA_SUBTYPE(format),
};
if (info.media_type != this->type.media_type.video &&
info.media_subtype != this->type.media_subtype.raw)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (info.media_type != this->type.media_type.video &&
info.media_subtype != this->type.media_subtype.raw)
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!spa_format_video_raw_parse (format, &info.info.raw, &this->type.format_video))
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!spa_format_video_raw_parse(format, &info.info.raw, &this->type.format_video))
return SPA_RESULT_INVALID_MEDIA_TYPE;
if (!(flags & SPA_PORT_FORMAT_FLAG_TEST_ONLY)) {
port->current_format = info;
port->have_format = true;
}
}
return SPA_RESULT_OK;
if (!(flags & SPA_PORT_FORMAT_FLAG_TEST_ONLY)) {
port->current_format = info;
port->have_format = true;
}
}
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_port_get_format (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_format **format)
spa_ffmpeg_enc_node_port_get_format(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, const struct spa_format **format)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || format == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
if (!port->have_format)
return SPA_RESULT_NO_FORMAT;
*format = NULL;
*format = NULL;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_port_get_info (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_port_info **info)
spa_ffmpeg_enc_node_port_get_info(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, const struct spa_port_info **info)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
*info = &port->info;
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
*info = &port->info;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_port_enum_params (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
uint32_t index,
struct spa_param **param)
spa_ffmpeg_enc_node_port_enum_params(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, uint32_t index, struct spa_param **param)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_set_param (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
const struct spa_param *param)
spa_ffmpeg_enc_node_port_set_param(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, const struct spa_param *param)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_use_buffers (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_buffer **buffers,
uint32_t n_buffers)
spa_ffmpeg_enc_node_port_use_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_buffer **buffers, uint32_t n_buffers)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (!IS_VALID_PORT (node, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(node, direction, port_id))
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_alloc_buffers (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_param **params,
uint32_t n_params,
struct spa_buffer **buffers,
uint32_t *n_buffers)
spa_ffmpeg_enc_node_port_alloc_buffers(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_param **params,
uint32_t n_params,
struct spa_buffer **buffers, uint32_t * n_buffers)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_set_io (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_port_io *io)
spa_ffmpeg_enc_node_port_set_io(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, struct spa_port_io *io)
{
struct impl *this;
struct port *port;
struct impl *this;
struct port *port;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if (!IS_VALID_PORT (this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
if (!IS_VALID_PORT(this, direction, port_id))
return SPA_RESULT_INVALID_PORT;
port = direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port->io = io;
port =
direction == SPA_DIRECTION_INPUT ? &this->in_ports[port_id] : &this->out_ports[port_id];
port->io = io;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static int
spa_ffmpeg_enc_node_port_reuse_buffer (struct spa_node *node,
uint32_t port_id,
uint32_t buffer_id)
spa_ffmpeg_enc_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
{
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
if (port_id != 0)
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_port_send_command (struct spa_node *node,
enum spa_direction direction,
uint32_t port_id,
struct spa_command *command)
spa_ffmpeg_enc_node_port_send_command(struct spa_node *node,
enum spa_direction direction,
uint32_t port_id, struct spa_command *command)
{
return SPA_RESULT_NOT_IMPLEMENTED;
return SPA_RESULT_NOT_IMPLEMENTED;
}
static int
spa_ffmpeg_enc_node_process_input (struct spa_node *node)
static int spa_ffmpeg_enc_node_process_input(struct spa_node *node)
{
return SPA_RESULT_INVALID_PORT;
return SPA_RESULT_INVALID_PORT;
}
static int
spa_ffmpeg_enc_node_process_output (struct spa_node *node)
static int spa_ffmpeg_enc_node_process_output(struct spa_node *node)
{
struct impl *this;
struct port *port;
struct spa_port_io *output;
struct impl *this;
struct port *port;
struct spa_port_io *output;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (node == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = SPA_CONTAINER_OF (node, struct impl, node);
this = SPA_CONTAINER_OF(node, struct impl, node);
if ((output = this->out_ports[0].io) == NULL)
return SPA_RESULT_OK;
if ((output = this->out_ports[0].io) == NULL)
return SPA_RESULT_OK;
port = &this->out_ports[0];
port = &this->out_ports[0];
if (!port->have_format) {
output->status = SPA_RESULT_NO_FORMAT;
return SPA_RESULT_ERROR;
}
output->status = SPA_RESULT_OK;
if (!port->have_format) {
output->status = SPA_RESULT_NO_FORMAT;
return SPA_RESULT_ERROR;
}
output->status = SPA_RESULT_OK;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
static const struct spa_node ffmpeg_enc_node = {
sizeof (struct spa_node),
NULL,
spa_ffmpeg_enc_node_get_props,
spa_ffmpeg_enc_node_set_props,
spa_ffmpeg_enc_node_send_command,
spa_ffmpeg_enc_node_set_callbacks,
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_enum_params,
spa_ffmpeg_enc_node_port_set_param,
spa_ffmpeg_enc_node_port_use_buffers,
spa_ffmpeg_enc_node_port_alloc_buffers,
spa_ffmpeg_enc_node_port_set_io,
spa_ffmpeg_enc_node_port_reuse_buffer,
spa_ffmpeg_enc_node_port_send_command,
spa_ffmpeg_enc_node_process_input,
spa_ffmpeg_enc_node_process_output,
sizeof(struct spa_node),
NULL,
spa_ffmpeg_enc_node_get_props,
spa_ffmpeg_enc_node_set_props,
spa_ffmpeg_enc_node_send_command,
spa_ffmpeg_enc_node_set_callbacks,
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_enum_params,
spa_ffmpeg_enc_node_port_set_param,
spa_ffmpeg_enc_node_port_use_buffers,
spa_ffmpeg_enc_node_port_alloc_buffers,
spa_ffmpeg_enc_node_port_set_io,
spa_ffmpeg_enc_node_port_reuse_buffer,
spa_ffmpeg_enc_node_port_send_command,
spa_ffmpeg_enc_node_process_input,
spa_ffmpeg_enc_node_process_output,
};
static int
spa_ffmpeg_enc_get_interface (struct spa_handle *handle,
uint32_t interface_id,
void **interface)
spa_ffmpeg_enc_get_interface(struct spa_handle *handle, uint32_t interface_id, void **interface)
{
struct impl *this;
struct impl *this;
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (handle == NULL || interface == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
this = (struct impl *) handle;
this = (struct impl *) handle;
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
if (interface_id == this->type.node)
*interface = &this->node;
else
return SPA_RESULT_UNKNOWN_INTERFACE;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
int
spa_ffmpeg_enc_init (struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
spa_ffmpeg_enc_init(struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support, uint32_t n_support)
{
struct impl *this;
uint32_t i;
struct impl *this;
uint32_t i;
handle->get_interface = spa_ffmpeg_enc_get_interface;
handle->get_interface = spa_ffmpeg_enc_get_interface;
this = (struct impl *) handle;
this = (struct impl *) handle;
for (i = 0; i < n_support; i++) {
if (strcmp (support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp (support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error (this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
for (i = 0; i < n_support; i++) {
if (strcmp(support[i].type, SPA_TYPE__TypeMap) == 0)
this->map = support[i].data;
else if (strcmp(support[i].type, SPA_TYPE__Log) == 0)
this->log = support[i].data;
}
if (this->map == NULL) {
spa_log_error(this->log, "a type-map is needed");
return SPA_RESULT_ERROR;
}
this->node = ffmpeg_enc_node;
this->node = ffmpeg_enc_node;
this->in_ports[0].info.flags = 0;
this->out_ports[0].info.flags = 0;
this->in_ports[0].info.flags = 0;
this->out_ports[0].info.flags = 0;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}

121
spa/plugins/ffmpeg/ffmpeg.c
View file

@ -25,92 +25,89 @@
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
int spa_ffmpeg_dec_init (struct spa_handle *handle, const struct spa_dict *info, const struct spa_support *support, uint32_t n_support);
int spa_ffmpeg_enc_init (struct spa_handle *handle, const struct spa_dict *info, const struct spa_support *support, uint32_t n_support);
int spa_ffmpeg_dec_init(struct spa_handle *handle, const struct spa_dict *info,
const struct spa_support *support, uint32_t n_support);
int spa_ffmpeg_enc_init(struct spa_handle *handle, const struct spa_dict *info,
const struct spa_support *support, uint32_t n_support);
static int
ffmpeg_dec_init (const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
ffmpeg_dec_init(const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return spa_ffmpeg_dec_init (handle, info, support, n_support);
return spa_ffmpeg_dec_init(handle, info, support, n_support);
}
static int
ffmpeg_enc_init (const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
ffmpeg_enc_init(const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (factory == NULL || handle == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
return spa_ffmpeg_enc_init (handle, info, support, n_support);
return spa_ffmpeg_enc_init(handle, info, support, n_support);
}
static const struct spa_interface_info ffmpeg_interfaces[] =
{
{ SPA_TYPE__Node,
},
static const struct spa_interface_info ffmpeg_interfaces[] = {
{SPA_TYPE__Node, },
};
static int
ffmpeg_enum_interface_info (const struct spa_handle_factory *factory,
const struct spa_interface_info **info,
uint32_t index)
ffmpeg_enum_interface_info(const struct spa_handle_factory *factory,
const struct spa_interface_info **info,
uint32_t index)
{
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (factory == NULL || info == NULL)
return SPA_RESULT_INVALID_ARGUMENTS;
if (index >= 1)
return SPA_RESULT_ENUM_END;
if (index >= 1)
return SPA_RESULT_ENUM_END;
*info = &ffmpeg_interfaces[index];
*info = &ffmpeg_interfaces[index];
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}
int
spa_handle_factory_enum (const struct spa_handle_factory **factory,
uint32_t index)
int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t index)
{
static const AVCodec *c = NULL;
static int ci = 0;
static struct spa_handle_factory f;
static char name[128];
static const AVCodec *c = NULL;
static int ci = 0;
static struct spa_handle_factory f;
static char name[128];
av_register_all();
av_register_all();
if (index == 0) {
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 (index == 0) {
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;
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;
*factory = &f;
return SPA_RESULT_OK;
return SPA_RESULT_OK;
}