#include <stdio.h>
#include <unistd.h>
#include <signal.h>
 
#include <spa/param/video/format-utils.h>
 
 
#define WIDTH   640
#define HEIGHT  480
 
#define MAX_BUFFERS     64
 
#include "sdl.h"
 
struct pixel {
};
 
struct data {
        const char *path;
 
        SDL_Renderer *renderer;
        SDL_Window *window;
        SDL_Texture *texture;
        SDL_Texture *cursor;
 
 
 
 
        int32_t stride;
 
        int counter;
        SDL_Rect rect;
        SDL_Rect cursor_rect;
        bool is_yuv;
};
 
static void handle_events(struct data *data)
{
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
                switch (event.type) {
                case SDL_QUIT:
                        break;
                }
        }
}
 
static void
on_process(void *_data)
{
        struct data *data = _data;
        void *sdata, *ddata;
        int sstride, dstride, ostride;
        uint32_t i, j;
        uint8_t *src, *dst;
        bool render_cursor = false;
 
        b = NULL;
        while (true) {
                        break;
                if (b)
                b = t;
        }
        if (b == NULL) {
                return;
        }
 
 
 
        handle_events(data);
 
                goto done;
 
        }
 
        
        }
        
                void *cdata;
                int cstride;
 
 
 
                if (data->cursor == NULL) {
                        data->cursor = SDL_CreateTexture(data->renderer,
                                                 SDL_TEXTUREACCESS_STREAMING,
                        SDL_SetTextureBlendMode(data->cursor, SDL_BLENDMODE_BLEND);
                }
 
 
                if (SDL_LockTexture(data->cursor, NULL, &cdata, &cstride) < 0) {
                        fprintf(stderr, "Couldn't lock cursor texture: %s\n", SDL_GetError());
                        goto done;
                }
 
                
                dst = cdata;
 
                        memcpy(dst, src, ostride);
                        dst += cstride;
                }
                SDL_UnlockTexture(data->cursor);
 
                render_cursor = true;
        }
 
        
        if (data->is_yuv) {
                sstride = data->stride;
                SDL_UpdateYUVTexture(data->texture,
                                NULL,
                                sdata,
                                sstride,
                                SPA_PTROFF(sdata, sstride * data->size.height, 
void),
 
                                sstride / 2,
                                SPA_PTROFF(sdata, 5 * (sstride * data->size.height) / 4, 
void),
 
                                sstride / 2);
        }
        else {
                if (SDL_LockTexture(data->texture, NULL, &ddata, &dstride) < 0) {
                        fprintf(stderr, "Couldn't lock texture: %s\n", SDL_GetError());
                        goto done;
                }
 
                if (sstride == 0)
                ostride = 
SPA_MIN(sstride, dstride);
 
                src = sdata;
                dst = ddata;
 
                        for (i = 0; i < data->size.height; i++) {
                                struct pixel *p = (struct pixel *) src;
                                for (j = 0; j < data->size.width; j++) {
                                        dst[j * 4 + 0] = 
SPA_CLAMP((uint8_t)(p[j].
r * 255.0f), 0u, 255u);
                                        dst[j * 4 + 1] = 
SPA_CLAMP((uint8_t)(p[j].g * 255.0f), 0u, 255u);
                                        dst[j * 4 + 2] = 
SPA_CLAMP((uint8_t)(p[j].b * 255.0f), 0u, 255u);
                                        dst[j * 4 + 3] = 
SPA_CLAMP((uint8_t)(p[j].a * 255.0f), 0u, 255u);
                                }
                                src += sstride;
                                dst += dstride;
                        }
                } else {
                        for (i = 0; i < data->size.height; i++) {
                                memcpy(dst, src, ostride);
                                src += sstride;
                                dst += dstride;
                        }
                }
                SDL_UnlockTexture(data->texture);
        }
 
        SDL_RenderClear(data->renderer);
        
        SDL_RenderCopy(data->renderer, data->texture, &data->rect, NULL);
        if (render_cursor) {
                SDL_RenderCopy(data->renderer, data->cursor, NULL, &data->cursor_rect);
        }
        SDL_RenderPresent(data->renderer);
 
      done:
}
 
{
        struct data *data = _data;
        switch (state) {
                break;
                
                break;
        default:
                break;
        }
}
 
static void
on_stream_io_changed(void *_data, uint32_t id, void *area, uint32_t size)
{
        struct data *data = _data;
 
        switch (id) {
                data->position = area;
                break;
        }
}
 
static void
on_stream_param_changed(
void *_data, uint32_t 
id, 
const struct spa_pod *param)
{
        struct data *data = _data;
        uint8_t params_buffer[1024];
        Uint32 sdl_format;
        void *d;
 
                return;
        }
                        fprintf(stderr, "got latency: %"PRIu64"\n", (info.min_ns + info.max_ns) / 2);
                return;
        }
        
                return;
 
        fprintf(stderr, "got format:\n");
 
        if (
spa_format_parse(param, &data->format.media_type, &data->format.media_subtype) < 0)
 
                return;
 
                return;
 
        switch (data->format.media_subtype) {
                
                sdl_format = id_to_sdl_format(data->format.info.raw.format);
                                data->format.info.raw.size.height);
                mult = 1;
                break;
                        return;
                sdl_format = SDL_PIXELFORMAT_RGBA32;
                                data->position->video.size.height);
                mult = 4;
                break;
        default:
                sdl_format = SDL_PIXELFORMAT_UNKNOWN;
                break;
        }
 
        if (sdl_format == SDL_PIXELFORMAT_UNKNOWN) {
                return;
        }
        if (data->size.width == 0 || data->size.height == 0) {
                return;
        }
 
        data->texture = SDL_CreateTexture(data->renderer,
                                          sdl_format,
                                          SDL_TEXTUREACCESS_STREAMING,
                                          data->size.width,
                                          data->size.height);
        SDL_LockTexture(data->texture, NULL, &d, &data->stride);
        SDL_UnlockTexture(data->texture);
 
        switch(sdl_format) {
        case SDL_PIXELFORMAT_YV12:
        case SDL_PIXELFORMAT_IYUV:
                size = (data->stride * data->size.height) * 3 / 2;
                data->is_yuv = true;
                break;
        default:
                size = data->stride * data->size.height;
                break;
        }
 
        data->rect.x = 0;
        data->rect.y = 0;
        data->rect.w = data->size.width;
        data->rect.h = data->size.height;
 
        
 
        
        
#define CURSOR_META_SIZE(w,h)   (sizeof(struct spa_meta_cursor) + \
                                 sizeof(struct spa_meta_bitmap) + w * h * 4)
        
                                CURSOR_META_SIZE(64,64),
                                CURSOR_META_SIZE(1,1),
                                CURSOR_META_SIZE(256,256)));
 
        
}
 
        .state_changed = on_stream_state_changed,
        .io_changed = on_stream_io_changed,
        .param_changed = on_stream_param_changed,
        .process = on_process,
};
 
{
        SDL_RendererInfo info;
 
        SDL_GetRendererInfo(data->renderer, &info);
        params[0] = sdl_build_formats(&info, b);
 
        fprintf(stderr, "supported SDL formats:\n");
 
 
        fprintf(stderr, "supported DSP formats:\n");
 
        return 2;
}
 
static void do_quit(void *userdata, int signal_number)
{
        struct data *data = userdata;
}
 
int main(int argc, char *argv[])
{
        struct data data = { 0, };
        uint8_t buffer[1024];
 
 
        
 
 
        
                        NULL),
        data.path = argc > 1 ? argv[1] : NULL;
        if (data.path)
 
                        "video-play",
                        props,
                        &stream_events,
                        &data);
 
        if (SDL_Init(SDL_INIT_VIDEO) < 0) {
                fprintf(stderr, "can't initialize SDL: %s\n", SDL_GetError());
                return -1;
        }
 
        if (SDL_CreateWindowAndRenderer
            (WIDTH, HEIGHT, SDL_WINDOW_RESIZABLE, &data.window, &data.renderer)) {
                fprintf(stderr, "can't create window: %s\n", SDL_GetError());
                return -1;
        }
 
        
        n_params = build_format(&data, &b, params);
 
        {
                
        }
 
        
                          params, n_params))             < 0) {
                return -1;
        }
 
        
 
 
        SDL_DestroyTexture(data.texture);
        if (data.cursor)
                SDL_DestroyTexture(data.cursor);
        SDL_DestroyRenderer(data.renderer);
        SDL_DestroyWindow(data.window);
 
        return 0;
}
#define PW_ID_ANY
Definition core.h:77
uint32_t int int const char int r
Definition core.h:447
uint32_t int int res
Definition core.h:433
#define PW_KEY_MEDIA_TYPE
Media.
Definition keys.h:499
#define PW_KEY_TARGET_OBJECT
a target object to link to.
Definition keys.h:566
#define PW_KEY_MEDIA_ROLE
Role: Movie, Music, Camera, Screen, Communication, Game, Notification, DSP, Production,...
Definition keys.h:505
#define PW_KEY_MEDIA_CATEGORY
Media Category: Playback, Capture, Duplex, Monitor, Manager.
Definition keys.h:502
#define pw_log_trace(...)
Definition log.h:182
#define pw_log_warn(...)
Definition log.h:179
#define pw_log_debug(...)
Definition log.h:181
PW_API_LOOP_IMPL struct spa_source * pw_loop_add_signal(struct pw_loop *object, int signal_number, spa_source_signal_func_t func, void *data)
Definition loop.h:141
int pw_main_loop_quit(struct pw_main_loop *loop)
Quit a main loop.
Definition main-loop.c:108
void pw_main_loop_destroy(struct pw_main_loop *loop)
Destroy a loop.
Definition main-loop.c:73
int pw_main_loop_run(struct pw_main_loop *loop)
Run a main loop.
Definition main-loop.c:122
struct pw_main_loop * pw_main_loop_new(const struct spa_dict *props)
Create a new main loop.
Definition main-loop.c:63
struct pw_loop * pw_main_loop_get_loop(struct pw_main_loop *loop)
Get the loop implementation.
Definition main-loop.c:96
void pw_init(int *argc, char **argv[])
Initialize PipeWire.
Definition pipewire.c:488
void pw_deinit(void)
Deinitialize PipeWire.
Definition pipewire.c:603
#define PW_DIRECTION_INPUT
Definition port.h:53
struct pw_properties * pw_properties_new(const char *key,...)
Make a new properties object.
Definition properties.c:97
int pw_properties_set(struct pw_properties *properties, const char *key, const char *value)
Set a property value.
Definition properties.c:585
int pw_stream_connect(struct pw_stream *stream, enum pw_direction direction, uint32_t target_id, enum pw_stream_flags flags, const struct spa_pod **params, uint32_t n_params)
Connect a stream for input or output on port_path.
Definition stream.c:1902
struct pw_buffer * pw_stream_dequeue_buffer(struct pw_stream *stream)
Get a buffer that can be filled for playback streams or consumed for capture streams.
Definition stream.c:2458
uint64_t pw_stream_get_nsec(struct pw_stream *stream)
Get the current time in nanoseconds.
Definition stream.c:2434
const char * pw_stream_state_as_string(enum pw_stream_state state)
Convert a stream state to a readable string.
Definition stream.c:1643
pw_stream_state
The state of a stream.
Definition stream.h:251
int pw_stream_set_error(struct pw_stream *stream, int res, const char *error,...)
Set the stream in error state.
Definition stream.c:2206
int pw_stream_update_params(struct pw_stream *stream, const struct spa_pod **params, uint32_t n_params)
Update the param exposed on the stream.
Definition stream.c:2232
int pw_stream_set_active(struct pw_stream *stream, bool active)
Activate or deactivate the stream.
Definition stream.c:2349
int pw_stream_queue_buffer(struct pw_stream *stream, struct pw_buffer *buffer)
Submit a buffer for playback or recycle a buffer for capture.
Definition stream.c:2486
struct pw_stream * pw_stream_new_simple(struct pw_loop *loop, const char *name, struct pw_properties *props, const struct pw_stream_events *events, void *data)
Definition stream.c:1599
#define PW_VERSION_STREAM_EVENTS
Definition stream.h:417
void pw_stream_destroy(struct pw_stream *stream)
Destroy a stream.
Definition stream.c:1693
@ PW_STREAM_FLAG_INACTIVE
start the stream inactive, pw_stream_set_active() needs to be called explicitly
Definition stream.h:466
@ PW_STREAM_FLAG_MAP_BUFFERS
mmap the buffers except DmaBuf that is not explicitly marked as mappable.
Definition stream.h:469
@ PW_STREAM_FLAG_AUTOCONNECT
try to automatically connect this stream
Definition stream.h:464
@ PW_STREAM_STATE_PAUSED
paused
Definition stream.h:255
@ PW_STREAM_STATE_UNCONNECTED
unconnected
Definition stream.h:253
SPA_API_BUFFER void * spa_buffer_find_meta_data(const struct spa_buffer *b, uint32_t type, size_t size)
Definition buffer.h:129
SPA_API_META bool spa_meta_region_is_valid(const struct spa_meta_region *m)
Definition meta.h:103
SPA_API_META bool spa_meta_cursor_is_valid(const struct spa_meta_cursor *m)
Definition meta.h:154
@ SPA_META_Cursor
struct spa_meta_cursor
Definition meta.h:41
@ SPA_META_VideoCrop
struct spa_meta_region with cropping data
Definition meta.h:38
@ SPA_META_Header
struct spa_meta_header
Definition meta.h:37
@ SPA_DATA_MemPtr
pointer to memory, the data field in struct spa_data is set.
Definition buffer.h:43
SPA_API_DEBUG_POD int spa_debug_pod(int indent, const struct spa_type_info *info, const struct spa_pod *pod)
Definition pod.h:208
SPA_API_DEBUG_FORMAT int spa_debug_format(int indent, const struct spa_type_info *info, const struct spa_pod *format)
Definition format.h:217
#define SPA_DICT_ITEM_INIT(key, value)
Definition dict.h:49
#define SPA_DICT_INIT(items, n_items)
Definition dict.h:67
@ SPA_IO_Position
position information in the graph, struct spa_io_position
Definition io.h:45
SPA_API_TAG_UTILS void spa_tag_build_start(struct spa_pod_builder *builder, struct spa_pod_frame *f, uint32_t id, enum spa_direction direction)
Definition tag-utils.h:109
SPA_API_TAG_UTILS void spa_tag_build_add_dict(struct spa_pod_builder *builder, const struct spa_dict *dict)
Definition tag-utils.h:127
SPA_API_TAG_UTILS struct spa_pod * spa_tag_build_end(struct spa_pod_builder *builder, struct spa_pod_frame *f)
Definition tag-utils.h:145
SPA_API_VIDEO_RAW_UTILS int spa_format_video_raw_parse(const struct spa_pod *format, struct spa_video_info_raw *info)
Definition raw-utils.h:37
SPA_API_VIDEO_DSP_UTILS int spa_format_video_dsp_parse(const struct spa_pod *format, struct spa_video_info_dsp *info)
Definition dsp-utils.h:37
SPA_API_FORMAT_UTILS int spa_format_parse(const struct spa_pod *format, uint32_t *media_type, uint32_t *media_subtype)
Definition format-utils.h:37
SPA_API_LATENCY_UTILS int spa_latency_parse(const struct spa_pod *latency, struct spa_latency_info *info)
Definition latency-utils.h:100
@ SPA_PARAM_META_size
the expected maximum size the meta (Int)
Definition buffers.h:40
@ SPA_PARAM_META_type
the metadata, one of enum spa_meta_type (Id enum spa_meta_type)
Definition buffers.h:39
@ SPA_MEDIA_TYPE_video
Definition format.h:28
@ SPA_PARAM_Tag
tag reporting, a SPA_TYPE_OBJECT_ParamTag.
Definition param.h:47
@ SPA_PARAM_Format
configured format as SPA_TYPE_OBJECT_Format
Definition param.h:34
@ SPA_PARAM_Meta
allowed metadata for buffers as SPA_TYPE_OBJECT_ParamMeta
Definition param.h:36
@ SPA_PARAM_EnumFormat
available formats as SPA_TYPE_OBJECT_Format
Definition param.h:33
@ SPA_PARAM_Latency
latency reporting, a SPA_TYPE_OBJECT_ParamLatency
Definition param.h:45
@ SPA_PARAM_Buffers
buffer configurations as SPA_TYPE_OBJECT_ParamBuffers
Definition param.h:35
@ SPA_FORMAT_mediaType
media type (Id enum spa_media_type)
Definition format.h:93
@ SPA_FORMAT_VIDEO_format
video format (Id enum spa_video_format)
Definition format.h:120
@ SPA_FORMAT_mediaSubtype
media subtype (Id enum spa_media_subtype)
Definition format.h:94
@ SPA_MEDIA_SUBTYPE_dsp
Definition format.h:39
@ SPA_MEDIA_SUBTYPE_raw
Definition format.h:38
@ SPA_VIDEO_FORMAT_DSP_F32
Definition raw.h:137
@ SPA_PARAM_BUFFERS_dataType
possible memory types (flags choice Int, mask of enum spa_data_type)
Definition buffers.h:32
@ SPA_PARAM_BUFFERS_size
size of a data block memory (Int)
Definition buffers.h:29
@ SPA_PARAM_BUFFERS_stride
stride of data block memory (Int)
Definition buffers.h:30
@ SPA_PARAM_BUFFERS_blocks
number of data blocks per buffer (Int)
Definition buffers.h:28
@ SPA_PARAM_BUFFERS_buffers
number of buffers (Int)
Definition buffers.h:27
#define SPA_POD_CHOICE_RANGE_Int(def, min, max)
Definition vararg.h:58
#define SPA_POD_Id(val)
Definition vararg.h:49
#define SPA_POD_BUILDER_INIT(buffer, size)
Definition builder.h:72
#define spa_pod_builder_add_object(b, type, id,...)
Definition builder.h:703
#define SPA_POD_Int(val)
Definition vararg.h:54
#define SPA_POD_CHOICE_FLAGS_Int(flags)
Definition vararg.h:62
SPA_API_RESULT const char * spa_strerror(int err)
Definition result.h:61
@ SPA_TYPE_OBJECT_ParamBuffers
Definition type.h:88
@ SPA_TYPE_OBJECT_ParamMeta
Definition type.h:89
@ SPA_TYPE_OBJECT_Format
Definition type.h:87
#define SPA_MIN(a, b)
Definition defs.h:165
#define SPA_CLAMP(v, low, high)
Definition defs.h:177
#define SPA_PTROFF(ptr_, offset_, type_)
Return the address (buffer + offset) as pointer of type.
Definition defs.h:222
#define SPA_RECTANGLE(width, height)
Definition defs.h:115
@ SPA_DIRECTION_INPUT
Definition defs.h:107
a buffer structure obtained from pw_stream_dequeue_buffer().
Definition stream.h:261
struct spa_buffer * buffer
the spa buffer
Definition stream.h:262
Definition properties.h:39
Events for a stream.
Definition stream.h:415
A Buffer.
Definition buffer.h:110
struct spa_data * datas
array of data members
Definition buffer.h:114
int32_t stride
stride of valid data
Definition buffer.h:65
uint32_t size
size of valid data.
Definition buffer.h:63
struct spa_chunk * chunk
valid chunk of memory
Definition buffer.h:106
void * data
optional data pointer
Definition buffer.h:105
A hook, contains the structure with functions and the data passed to the functions.
Definition hook.h:427
The position information adds extra meaning to the raw clock times.
Definition io.h:316
helper structure for managing latency objects
Definition latency.h:54
uint32_t size
Definition pod.h:44
int32_t y
Definition defs.h:125
int32_t x
Definition defs.h:124
uint32_t width
Definition defs.h:117
uint32_t height
Definition defs.h:118
struct spa_point position
Definition defs.h:131
struct spa_rectangle size
Definition defs.h:132