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

265 lines
9.9 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 {
/*< 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.
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
* @PINOS_PACKET_TYPE_FD_PAYLOAD: packet contains fd-payload. An fd-payload contains
* the media data as a file descriptor
* @PINOS_PACKET_TYPE_RELEASE_FD_PAYLOAD: packet contains release fd-payload. Notifies
* that a previously received fd-payload is no longer in use.
* @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
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 = 1,
PINOS_PACKET_TYPE_HEADER = 2,
PINOS_PACKET_TYPE_FD_PAYLOAD = 3,
PINOS_PACKET_TYPE_RELEASE_FD_PAYLOAD = 4,
PINOS_PACKET_TYPE_FORMAT_CHANGE = 5,
PINOS_PACKET_TYPE_PROPERTY_CHANGE = 6,
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 = 7,
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
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);
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 {
guint32 flags;
guint32 seq;
gint64 pts;
gint64 dts_offset;
} PinosPacketHeader;
gboolean pinos_buffer_iter_parse_header (PinosBufferIter *iter,
PinosPacketHeader *header);
gboolean pinos_buffer_builder_add_header (PinosBufferBuilder *builder,
PinosPacketHeader *header);
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
/* fd-payload packets */
/**
* PinosPacketFDPayload:
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
* @id: the unique id of this 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
* @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 data in an fd at @fd_index at @offset and with
* @size.
*/
typedef struct {
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;
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
gint32 fd_index;
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
guint64 offset;
guint64 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
} PinosPacketFDPayload;
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_iter_parse_fd_payload (PinosBufferIter *iter,
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
PinosPacketFDPayload *payload);
gboolean pinos_buffer_builder_add_fd_payload (PinosBufferBuilder *builder,
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
PinosPacketFDPayload *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
/* release fd-payload packets */
/**
* PinosPacketReleaseFDPayload:
* @id: the unique id of the fd-payload to release
*
* Release the payload with @id
*/
typedef struct {
guint32 id;
} PinosPacketReleaseFDPayload;
gboolean pinos_buffer_iter_parse_release_fd_payload (PinosBufferIter *iter,
PinosPacketReleaseFDPayload *payload);
gboolean pinos_buffer_builder_add_release_fd_payload (PinosBufferBuilder *builder,
PinosPacketReleaseFDPayload *payload);
/* format change packets */
/**
* PinosPacketFormatChange:
* @id: the id of the new format
* @format: the new format
*
* A new format.
*/
typedef struct {
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;
gboolean pinos_buffer_iter_parse_format_change (PinosBufferIter *iter,
PinosPacketFormatChange *payload);
gboolean pinos_buffer_builder_add_format_change (PinosBufferBuilder *builder,
PinosPacketFormatChange *payload);
/* property change packets */
/**
* PinosPacketPropertyChange:
* @key: the key of the property
* @value: the new value
*
* A new property change.
*/
typedef struct {
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;
gboolean pinos_buffer_iter_parse_property_change (PinosBufferIter *iter,
guint idx,
PinosPacketPropertyChange *payload);
gboolean pinos_buffer_builder_add_property_change (PinosBufferBuilder *builder,
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 {
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