mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/pinos/client/buffer.h

333 lines
12 KiB
C
Raw Normal View History

Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/* Pinos
* Copyright (C) 2015 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.
*/
#ifndef __PINOS_BUFFER_H__
#define __PINOS_BUFFER_H__
#include <glib-object.h>
#include <gio/gio.h>
G_BEGIN_DECLS
typedef struct _PinosBuffer PinosBuffer;
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
typedef struct _PinosBufferIter PinosBufferIter;
typedef struct _PinosBufferBuilder PinosBufferBuilder;
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
#define PINOS_BUFFER_VERSION 0
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
/**
* PinosBufferFlags:
* @PINOS_BUFFER_FLAG_NONE: no flags
* @PINOS_BUFFER_FLAG_CONTROL: the buffer contains control info such
* as new format or properties.
*
* The possible buffer flags.
*/
typedef enum {
PINOS_BUFFER_FLAG_NONE = 0,
PINOS_BUFFER_FLAG_CONTROL = (1 << 0),
} PinosBufferFlags;
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
struct _PinosBuffer {
buffer: add next pointer Add next pointer to easily make linked lists
2016-05-24 20:40:04 +02:00
PinosBuffer *next;
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/*< private >*/
gsize x[16];
};
Rework pay/depay elements Rename the payloader and depayloader to pinospay/pinosdepay because they now store data in a pinos specific format. Subclass GstElement because they are not real transform elements. Rework/remove some buffer functions that are not used by some more performant ones.
2015-08-27 16:41:25 +02:00
void pinos_buffer_init_data (PinosBuffer *buffer,
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
gpointer data,
gsize size,
buffer: allow building into custom memory Make it possible to pass custom memory to the builder so that it can construct packets directly into specified memory and avoid allocs. Remove GError and GSocketControlMessage in the buffer API to make it possible to use other (rt-safe) API later.
2016-05-09 18:48:18 +02:00
gint *fds,
gint n_fds);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
buffer: improve memory management Add refcounting to buffers. Use static memory on ports for buffer input and output memory. Improve negotiation, let format and properties be negotiated on ports as the data passes. Improve some debug info.
2016-05-17 20:14:06 +02:00
PinosBuffer * pinos_buffer_ref (PinosBuffer *buffer);
gboolean pinos_buffer_unref (PinosBuffer *buffer);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
guint32 pinos_buffer_get_version (PinosBuffer *buffer);
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
PinosBufferFlags pinos_buffer_get_flags (PinosBuffer *buffer);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
int pinos_buffer_get_fd (PinosBuffer *buffer,
buffer: allow building into custom memory Make it possible to pass custom memory to the builder so that it can construct packets directly into specified memory and avoid allocs. Remove GError and GSocketControlMessage in the buffer API to make it possible to use other (rt-safe) API later.
2016-05-09 18:48:18 +02:00
gint index);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
buffer: allow building into custom memory Make it possible to pass custom memory to the builder so that it can construct packets directly into specified memory and avoid allocs. Remove GError and GSocketControlMessage in the buffer API to make it possible to use other (rt-safe) API later.
2016-05-09 18:48:18 +02:00
gpointer pinos_buffer_steal_data (PinosBuffer *buffer,
gsize *size);
gint * pinos_buffer_steal_fds (PinosBuffer *buffer,
gint *n_fds);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
/**
* PinosPacketType:
* @PINOS_PACKET_TYPE_INVALID: invalid packet type, ignore
add continuation packet Add continuation type packet that would make it possible to send commands using a piece of shared memory.
2015-08-31 17:10:44 +02:00
* @PINOS_PACKET_TYPE_CONTINUATION: continuation packet, used internally to send
* commands using a shared memory region.
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* @PINOS_PACKET_TYPE_REGISTER_MEM: register memory region
* @PINOS_PACKET_TYPE_RELEASE_MEM: release memory region
* @PINOS_PACKET_TYPE_START: start transfer
* @PINOS_PACKET_TYPE_STOP: stop transfer
*
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
* @PINOS_PACKET_TYPE_HEADER: common packet header
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* @PINOS_PACKET_TYPE_PROCESS_MEM: packet contains mem-payload. An mem-payload contains
* the media data as the index of a shared memory region
* @PINOS_PACKET_TYPE_REUSE_MEM: when a memory region has been consumed and is ready to
* be reused.
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
* @PINOS_PACKET_TYPE_FORMAT_CHANGE: a format change.
* @PINOS_PACKET_TYPE_PROPERTY_CHANGE: one or more property changes.
add refresh message Add a new refresh message to request a keyframe from the pinos server. pinospay: pass the refresh-request message upstream pinossink: turn refresh-request messages into events pinossrc: turn a keyframe event into a refresh-request message
2016-04-13 13:04:32 +02:00
* @PINOS_PACKET_TYPE_REFRESH_REQUEST: ask for a new keyframe
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
*
* The possible packet types.
*/
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
typedef enum {
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
PINOS_PACKET_TYPE_INVALID = 0,
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
PINOS_PACKET_TYPE_CONTINUATION,
PINOS_PACKET_TYPE_ADD_MEM,
PINOS_PACKET_TYPE_REMOVE_MEM,
PINOS_PACKET_TYPE_START,
PINOS_PACKET_TYPE_STREAMING,
PINOS_PACKET_TYPE_STOP,
PINOS_PACKET_TYPE_STOPPED,
PINOS_PACKET_TYPE_DRAIN,
PINOS_PACKET_TYPE_DRAINED,
PINOS_PACKET_TYPE_HEADER,
PINOS_PACKET_TYPE_PROCESS_MEM,
PINOS_PACKET_TYPE_REUSE_MEM,
PINOS_PACKET_TYPE_FORMAT_CHANGE,
PINOS_PACKET_TYPE_PROPERTY_CHANGE,
PINOS_PACKET_TYPE_REFRESH_REQUEST,
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
} PinosPacketType;
/* iterating packets */
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
struct _PinosBufferIter {
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/*< private >*/
gsize x[16];
};
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
void pinos_buffer_iter_init_full (PinosBufferIter *iter,
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
PinosBuffer *buffer,
guint32 version);
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
#define pinos_buffer_iter_init(i,b) pinos_buffer_iter_init_full(i,b, PINOS_BUFFER_VERSION);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
gboolean pinos_buffer_iter_next (PinosBufferIter *iter);
buffer: improve memory management Add refcounting to buffers. Use static memory on ports for buffer input and output memory. Improve negotiation, let format and properties be negotiated on ports as the data passes. Improve some debug info.
2016-05-17 20:14:06 +02:00
void pinos_buffer_iter_end (PinosBufferIter *iter);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
PinosPacketType pinos_buffer_iter_get_type (PinosBufferIter *iter);
gpointer pinos_buffer_iter_get_data (PinosBufferIter *iter, gsize *size);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/**
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
* PinosBufferBuilder:
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
*/
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
struct _PinosBufferBuilder {
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/*< private >*/
gsize x[16];
};
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
void pinos_buffer_builder_init_full (PinosBufferBuilder *builder,
buffer: allow building into custom memory Make it possible to pass custom memory to the builder so that it can construct packets directly into specified memory and avoid allocs. Remove GError and GSocketControlMessage in the buffer API to make it possible to use other (rt-safe) API later.
2016-05-09 18:48:18 +02:00
guint32 version,
gpointer data,
gsize max_data,
gint *fds,
gint max_fds);
#define pinos_buffer_builder_init_into(b,d,md,f,mf) pinos_buffer_builder_init_full(b, PINOS_BUFFER_VERSION,d,md,f,mf);
#define pinos_buffer_builder_init(b) pinos_buffer_builder_init_into(b, NULL, 0, NULL, 0);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
Rework how clients connect. Add buffer flags. The idea is to make it possible to easily check when a buffer contains control information that we need to parse to update the port fields. Make the client create remote nodes and ports and set up proxies for them. Make a port base class implementing most of the logic to pass buffers locally and remotely. Remove most code from stream.c, it's now in the port. Make a portsink and portsrc that can write and read to/from any port. We use these in the server to send and receive data. Rework format negotiation. The final format is now sent in-line before the data. The server will select a format on output ports.
2016-05-17 09:38:30 +02:00
void pinos_buffer_builder_set_flags (PinosBufferBuilder *builder,
PinosBufferFlags flags);
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
void pinos_buffer_builder_clear (PinosBufferBuilder *builder);
void pinos_buffer_builder_end (PinosBufferBuilder *builder,
PinosBuffer *buffer);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_builder_add_empty (PinosBufferBuilder *builder,
PinosPacketType type);
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
gint pinos_buffer_builder_add_fd (PinosBufferBuilder *builder,
buffer: allow building into custom memory Make it possible to pass custom memory to the builder so that it can construct packets directly into specified memory and avoid allocs. Remove GError and GSocketControlMessage in the buffer API to make it possible to use other (rt-safe) API later.
2016-05-09 18:48:18 +02:00
int fd);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
/* add-mem packets */
/**
* PinosPacketAddMem:
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
* @port: the port number
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* @id: the unique id of this memory block
* @type: the memory block type
* @fd_index: the index of the fd with the data
* @offset: the offset of the data
* @size: the size of the data
*
* A Packet that contains a memory block used for data transfer.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
guint32 id;
guint32 type;
gint32 fd_index;
guint64 offset;
guint64 size;
} PinosPacketAddMem;
gboolean pinos_buffer_iter_parse_add_mem (PinosBufferIter *iter,
PinosPacketAddMem *payload);
gboolean pinos_buffer_builder_add_add_mem (PinosBufferBuilder *builder,
PinosPacketAddMem *payload);
/* remove-mem packets */
/**
* PinosPacketRemoveMem:
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
* @port: the port number
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* @id: the unique id of the memory block
*
* Remove a memory block.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
guint32 id;
} PinosPacketRemoveMem;
gboolean pinos_buffer_iter_parse_remove_mem (PinosBufferIter *iter,
PinosPacketRemoveMem *payload);
gboolean pinos_buffer_builder_add_remove_mem (PinosBufferBuilder *builder,
PinosPacketRemoveMem *payload);
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
/* header packets */
/**
* PinosPacketHeader
* @flags: header flags
* @seq: sequence number
* @pts: presentation timestamp in nanoseconds
* @dts_offset: offset to presentation timestamp in nanoseconds to get decode timestamp
*
* A Packet that contains the header.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
guint32 flags;
guint32 seq;
gint64 pts;
gint64 dts_offset;
} PinosPacketHeader;
gboolean pinos_buffer_iter_parse_header (PinosBufferIter *iter,
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
PinosPacketHeader *payload);
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
gboolean pinos_buffer_builder_add_header (PinosBufferBuilder *builder,
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
PinosPacketHeader *payload);
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
/* process-mem packets */
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
/**
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* PinosPacketProcessMem:
* @id: the mem index to process
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
* @offset: the offset of the data
* @size: the size of the data
*
* A Packet that contains data in an fd at @fd_index at @offset and with
* @size.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
Rework buffer API a little Use BufferIter and BufferBuilder instead of Packet* Make separate method to set the header so you can set it later and not only at builder init time. Add method to clear the builder if you want to abort. Add method to add fd to builder instead of in _add_fd_payload. This would make it easier to add multiple fd-payloads using data from the same fd. Pass PinosPacketFDPayload to add_fd_payload to make it symetric with the parsing code. We should be able to get the size from the VERSION passed when the builder was made. Add ideas about releasing the fds back to the server.
2015-08-26 12:46:28 +02:00
guint32 id;
guint64 offset;
guint64 size;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
} PinosPacketProcessMem;
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_iter_parse_process_mem (PinosBufferIter *iter,
PinosPacketProcessMem *payload);
gboolean pinos_buffer_builder_add_process_mem (PinosBufferBuilder *builder,
PinosPacketProcessMem *payload);
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
/* reuse-mem packets */
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
/**
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
* PinosPacketReuseMem:
* @id: the unique id of the memory block to reuse
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
*
* Release the payload with @id
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
guint32 id;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
guint64 offset;
guint64 size;
} PinosPacketReuseMem;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_iter_parse_reuse_mem (PinosBufferIter *iter,
PinosPacketReuseMem *payload);
gboolean pinos_buffer_builder_add_reuse_mem (PinosBufferBuilder *builder,
PinosPacketReuseMem *payload);
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
/* format change packets */
/**
* PinosPacketFormatChange:
* @id: the id of the new format
* @format: the new format
*
* A new format.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
guint8 id;
Introduce the concept of a Port A port is an input or output on a Node. Channels are created from the ports and inherit the direction of the port. do automatic port selection based on the direction and caps and node/port name. Simplify stream_connect by passing the direction. Fix pinossink to connect in setcaps so that we know the format and can select a good sink to connect to.
2016-05-06 13:01:52 +02:00
const gchar *format;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
} PinosPacketFormatChange;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_iter_parse_format_change (PinosBufferIter *iter,
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
PinosPacketFormatChange *payload);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_builder_add_format_change (PinosBufferBuilder *builder,
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
PinosPacketFormatChange *payload);
/* property change packets */
/**
* PinosPacketPropertyChange:
* @key: the key of the property
* @value: the new value
*
* A new property change.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
Introduce the concept of a Port A port is an input or output on a Node. Channels are created from the ports and inherit the direction of the port. do automatic port selection based on the direction and caps and node/port name. Simplify stream_connect by passing the direction. Fix pinossink to connect in setcaps so that we know the format and can select a good sink to connect to.
2016-05-06 13:01:52 +02:00
const gchar *key;
const gchar *value;
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
} PinosPacketPropertyChange;
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_iter_parse_property_change (PinosBufferIter *iter,
guint idx,
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
PinosPacketPropertyChange *payload);
work on stream negotiation and start Add more buffer types to add and remove memory shared memory between the server and client. We would like to send buffers only once and then simply reference them by index. Do format negotiation and stream start with a START message.
2016-07-21 18:38:24 +02:00
gboolean pinos_buffer_builder_add_property_change (PinosBufferBuilder *builder,
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
PinosPacketPropertyChange *payload);
add refresh message Add a new refresh message to request a keyframe from the pinos server. pinospay: pass the refresh-request message upstream pinossink: turn refresh-request messages into events pinossrc: turn a keyframe event into a refresh-request message
2016-04-13 13:04:32 +02:00
/* refresh request packets */
/**
* PinosPacketRefreshRequest:
* @last_id: last frame seen frame id
* @request_type: the type of the request
* @pts: the timestamp of the requested key frame, 0 = as soon as possible
*
* A refresh request packet. This packet is sent to trigger a new keyframe.
*/
typedef struct {
add client-node again Add a client node again that uses the channel protocol but looks like a node in the graph.
2016-07-22 17:17:44 +02:00
guint32 port;
add refresh message Add a new refresh message to request a keyframe from the pinos server. pinospay: pass the refresh-request message upstream pinossink: turn refresh-request messages into events pinossrc: turn a keyframe event into a refresh-request message
2016-04-13 13:04:32 +02:00
guint32 last_id;
guint32 request_type;
gint64 pts;
} PinosPacketRefreshRequest;
gboolean pinos_buffer_iter_parse_refresh_request (PinosBufferIter *iter,
PinosPacketRefreshRequest *payload);
gboolean pinos_buffer_builder_add_refresh_request (PinosBufferBuilder *builder,
PinosPacketRefreshRequest *payload);
More work on wire protocol Make separate payload for the header. Make release-fd payloads capture_buffer -> peek_buffer to avoid a copy remove release-buffer, we really need to release each fd in the buffer separately. provide_buffer -> send_buffer so that we can also use this to send the release-fd messages. in pinossrc, send back release-fd messages when the fd is no longer in use.
2015-08-31 16:47:32 +02:00
Rework the wire protocol Send a command stream over the socket. Implement a new buffer object that holds the data and commands. Make iterator and builders to parse and construct buffers. Rework gstreamer elements to use new API for creating and parsing buffers. Add _release_buffer to notify a stream when we are done processing the buffer. This will eventually go all the way to the server and will allow us to do more complicated buffer management.
2015-08-24 16:41:04 +02:00
#endif /* __PINOS_BUFFER_H__ */
Reference in a new issue Copy permalink