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/src/gst/gstpipewirepool.h

90 lines
2.1 KiB
C
Raw Normal View History

treewide: use SPDX tags to specify copyright information SPDX tags make the licensing information easy to understand and clear, and they are machine parseable. See https://spdx.dev for more information.
2023-02-08 18:12:00 +01:00
/* GStreamer */
/* SPDX-FileCopyrightText: Copyright © 2018 Wim Taymans */
/* SPDX-License-Identifier: MIT */
pinos -> pipewire
2017-05-23 19:15:33 +02:00
#ifndef __GST_PIPEWIRE_POOL_H__
#define __GST_PIPEWIRE_POOL_H__
gst: reference the GstPipeWireStream from the pool & the clock
2024-06-01 17:15:09 +03:00
#include "gstpipewirestream.h"
pinos -> pipewire
2017-05-23 19:15:33 +02:00
#include <gst/gst.h>
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
#include <gst/audio/audio.h>
gst: add buffer video meta support Fixes video buffer strides handling. This enables passing of image datas with right line padding.
2023-02-03 13:02:49 +08:00
#include <gst/video/video.h>
move things around
2017-07-11 15:57:20 +02:00
#include <pipewire/pipewire.h>
pinos -> pipewire
2017-05-23 19:15:33 +02:00
G_BEGIN_DECLS
gst: use G_DECLARE_FINAL_TYPE for all classes
2024-06-01 18:01:42 +03:00
#define GST_TYPE_PIPEWIRE_POOL (gst_pipewire_pool_get_type())
G_DECLARE_FINAL_TYPE (GstPipeWirePool, gst_pipewire_pool, GST, PIPEWIRE_POOL, GstBufferPool)
pinos -> pipewire
2017-05-23 19:15:33 +02:00
gst: pool: Some refinements to min/max handling A number of changes for correctness. 1) We expose the actualy min and max values we support in the allocation query. 2) We don't support max_buffers as 0, as unlimited buffers is not an option 3) In ParamBuffers, we request the max_buffers from bufferpool config, as we cannot dynamically allocate buffers
2025-03-26 11:55:13 -04:00
#define PIPEWIRE_POOL_MIN_BUFFERS 2u
#define PIPEWIRE_POOL_MAX_BUFFERS 16u
gst: handle blocks and size allocation for encoded format In case of encoded video we get n_planes as 0 from the video info so passing that as n_datas is failing during the buffer negotiation. Make sure to use an appropriate value based on whether we have raw video or not. Co-authored-by: Taruntej Kanakamalla <taruntej@asymptotic.io>
2025-04-16 19:47:40 -04:00
/* Only available in GStreamer 1.22+ */
#ifndef GST_VIDEO_FORMAT_INFO_IS_VALID_RAW
#define GST_VIDEO_FORMAT_INFO_IS_VALID_RAW(info) \
(info != NULL && (info)->format > GST_VIDEO_FORMAT_ENCODED)
#endif
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
typedef struct _GstPipeWirePoolData GstPipeWirePoolData;
struct _GstPipeWirePoolData {
GstPipeWirePool *pool;
void *owner;
struct spa_meta_header *header;
guint flags;
struct pw_buffer *b;
GstBuffer *buf;
gst: keep track of queued buffers Pipewire might update buffers that have not been recycled by GStreamer, because they are still used downstream. There is nothing we can do about it in the pipewiresrc. If a buffer is sent downstream more than once, take an additional reference to make sure that we don't queue a buffer that is still used and print a warning.
2020-05-05 13:07:12 +02:00
gboolean queued;
gst: support VideoCrop meta Convert the VideoCrop metadata to GStreamer metadata.
2020-07-31 11:44:46 +02:00
struct spa_meta_region *crop;
gst: Implement SPA_META_VideoTransform support Many Gstreamer elements support transforming buffers via the `image-orientation` tag. Use it to implement support for the new VideoTransform meta. In order for Gstreamer pipelines to enable support for these tags usually the rotate method has to be set to `auto` or `automatic`, e.g. `videoflip method=automatic`, `glimagesink rotate-method=automatic` or `waylandsink rotate-method=auto`.
2022-12-03 23:20:52 +01:00
struct spa_meta_videotransform *videotransform;
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
};
pinos -> pipewire
2017-05-23 19:15:33 +02:00
struct _GstPipeWirePool {
GstBufferPool parent;
gst: reference the GstPipeWireStream from the pool & the clock
2024-06-01 17:15:09 +03:00
GWeakRef stream;
gst: sink: post an element error when all buffers are removed abruptly When the link on the pipewire side is destroyed, on video streams, buffers are removed abruptly and there is no way this pipeline can be revived, so let's post an element error to stop it. On a normal shutdown, the pool is first set to flushing in change_state(), so checking for the flushing state is a good indicator to know if this is a normal shutdown or not. See #1980
2024-05-28 17:34:45 +03:00
guint n_buffers;
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
gboolean has_video;
gst: handle blocks and size allocation for encoded format In case of encoded video we get n_planes as 0 from the video info so passing that as n_datas is failing during the buffer negotiation. Make sure to use an appropriate value based on whether we have raw video or not. Co-authored-by: Taruntej Kanakamalla <taruntej@asymptotic.io>
2025-04-16 19:47:40 -04:00
gboolean has_rawvideo;
gst: add buffer video meta support Fixes video buffer strides handling. This enables passing of image datas with right line padding.
2023-02-03 13:02:49 +08:00
gboolean add_metavideo;
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
GstAudioInfo audio_info;
gst: add buffer video meta support Fixes video buffer strides handling. This enables passing of image datas with right line padding.
2023-02-03 13:02:49 +08:00
GstVideoInfo video_info;
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
GstVideoAlignment video_align;
gst: add buffer video meta support Fixes video buffer strides handling. This enables passing of image datas with right line padding.
2023-02-03 13:02:49 +08:00
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
GstAllocator *fd_allocator;
GstAllocator *dmabuf_allocator;
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
GstAllocator *shm_allocator;
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
pinos -> pipewire
2017-05-23 19:15:33 +02:00
GCond cond;
gst: handle blocking in the _render() function When we do any other blocking in the render function, we should unblock and call _wait_preroll() when we go to PAUSED. We can have this situation when all the buffers are queued in the pw_stream and we get a new _render() call. We can't get more buffers from the pool and so we must block and wait. When we go to PAUSED we need to unlock and go to _wait_preroll(). Implement this by setting a pool paused flag that is set when the sink goes to paused, we can then return a special value that does the wait_preroll(). See !2248
2025-01-17 16:33:15 +01:00
gboolean paused;
gst: sink: Manage buffer pool memory manually Let's make sure we own the memory in buffers, so that we can be resilient to the PW link going away. This currently maintains the status quo of copying data into the pipewirepool for sending to the remote end, but moves the allocation of buffers so that ownership is maintained by the sink in all cases. There are some tricky corners, especially with bufferpool vs. buffers param negotiation -- bufferpool parameters can be negotiated in GStreamer before the link even comes up, so we try to adapt the buffers param to use the negotiated value. For now, that is more brittle than tying those two aspects together. We can revisit this if we can find a way to tie pipeline state and link state more closely. Co-authored-by: Arun Raghavan <arun@asymptotic.io>
2025-03-20 21:13:03 -04:00
gboolean allocate_memory;
pinos -> pipewire
2017-05-23 19:15:33 +02:00
};
gst: don't use bufferpool for audio by default Deprecate the `always-copy` property in pipewiresrc and use the new property `use-bufferpool` in both pipewiresrc and pipewiresink to specify whether to use the gstpipewirepool or not. The gstpipewirepool is used for video by default unless `use-bufferpool` is set to `false` and it is not used for audio by default unless `use-bufferpool` is set to `true`
2025-01-24 21:07:55 +05:30
enum GstPipeWirePoolMode {
USE_BUFFERPOOL_NO = 0,
USE_BUFFERPOOL_AUTO,
USE_BUFFERPOOL_YES
};
gst: reference the GstPipeWireStream from the pool & the clock
2024-06-01 17:15:09 +03:00
GstPipeWirePool * gst_pipewire_pool_new (GstPipeWireStream *stream);
pinos -> pipewire
2017-05-23 19:15:33 +02:00
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
void gst_pipewire_pool_wrap_buffer (GstPipeWirePool *pool, struct pw_buffer *buffer);
gst: pool: add explicit remove_buffer method This is for readability and better control. Make sure we clear out all pointers to anything related to the released pw_buffer, including all the memories.
2024-05-28 16:47:15 +03:00
void gst_pipewire_pool_remove_buffer (GstPipeWirePool *pool, struct pw_buffer *buffer);
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
gst: sink: post an element error when all buffers are removed abruptly When the link on the pipewire side is destroyed, on video streams, buffers are removed abruptly and there is no way this pipeline can be revived, so let's post an element error to stop it. On a normal shutdown, the pool is first set to flushing in change_state(), so checking for the flushing state is a good indicator to know if this is a normal shutdown or not. See #1980
2024-05-28 17:34:45 +03:00
static inline gboolean
gst_pipewire_pool_has_buffers (GstPipeWirePool *pool)
{
return pool->n_buffers > 0;
}
stream: improve stream API Simplify the stream API. make just 2 methods to queue and dequeue buffers. Make just one callback when new buffers can be dequeued. Add support for driver nodes such as the video-src. Pass a pw_buffer structure to add/remove_buffer and make it possible to attach metadata to it. This makes it a lot easier to implement the gstreamer pipewire pool. Call the stream process function from the main loop and use a lockfree ringbuffer to pass buffers between the threads. Make it possible to also call process from the RT thread. unmap the buffer data when needed.
2018-03-22 16:40:27 +01:00
GstPipeWirePoolData *gst_pipewire_pool_get_data (GstBuffer *buffer);
gst: handle blocking in the _render() function When we do any other blocking in the render function, we should unblock and call _wait_preroll() when we go to PAUSED. We can have this situation when all the buffers are queued in the pw_stream and we get a new _render() call. We can't get more buffers from the pool and so we must block and wait. When we go to PAUSED we need to unlock and go to _wait_preroll(). Implement this by setting a pool paused flag that is set when the sink goes to paused, we can then return a special value that does the wait_preroll(). See !2248
2025-01-17 16:33:15 +01:00
void gst_pipewire_pool_set_paused (GstPipeWirePool *pool, gboolean paused);
pinos -> pipewire
2017-05-23 19:15:33 +02:00
G_END_DECLS
#endif /* __GST_PIPEWIRE_POOL_H__ */
Reference in a new issue Copy permalink