#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;
        bool have_request_process;
};
 
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:
}
 
static void enable_timeouts(struct data *data, bool enabled)
{
        struct timespec timeout, interval, *to, *iv;
 
        if (!enabled || data->have_request_process) {
                to = iv = NULL;
        } else {
                timeout.tv_sec = 0;
                timeout.tv_nsec = 1;
                interval.tv_sec = 0;
                to = &timeout;
                iv = &interval;
        }
                                data->timer, to, iv, false);
}
 
 
{
        struct data *data = _data;
        switch (state) {
                break;
                enable_timeouts(data, false);
                break;
                printf("driving:%d lazy:%d\n",
                        enable_timeouts(data, true);
                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_trigger_done(void *_data)
{
        struct data *data = _data;
}
 
static void on_timeout(void *userdata, uint64_t expirations)
{
        struct data *data = userdata;
}
 
static void
on_command(
void *_data, 
const struct spa_command *command)
{
        struct data *data = _data;
                break;
        default:
                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 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,
        .trigger_done = on_trigger_done,
        .command = on_command,
};
 
{
        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_NODE_SUPPORTS_REQUEST
The node supports emiting RequestProcess events when it wants the graph to be scheduled.
Definition keys.h:291
#define PW_KEY_MEDIA_TYPE
Media.
Definition keys.h:499
#define PW_KEY_NODE_SUPPORTS_LAZY
the node can be a lazy driver.
Definition keys.h:285
#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
PW_API_LOOP_IMPL int pw_loop_update_timer(struct pw_loop *object, struct spa_source *source, struct timespec *value, struct timespec *interval, bool absolute)
Definition loop.h:134
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
PW_API_LOOP_IMPL struct spa_source * pw_loop_add_timer(struct pw_loop *object, spa_source_timer_func_t func, void *data)
Definition loop.h:130
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
bool pw_stream_is_driving(struct pw_stream *stream)
Check if the stream is driving.
Definition stream.c:2602
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_trigger_process(struct pw_stream *stream)
Trigger a push/pull on the stream.
Definition stream.c:2646
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
bool pw_stream_is_lazy(struct pw_stream *stream)
Check if the graph is using lazy scheduling.
Definition stream.c:2608
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_MAP_BUFFERS
mmap the buffers except DmaBuf that is not explicitly marked as mappable.
Definition stream.h:469
@ PW_STREAM_FLAG_DRIVER
be a driver
Definition stream.h:471
@ 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
@ PW_STREAM_STATE_STREAMING
streaming
Definition stream.h:256
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_FORMAT int spa_debug_format(int indent, const struct spa_type_info *info, const struct spa_pod *format)
Definition format.h:217
#define SPA_NODE_COMMAND_ID(cmd)
Definition command.h:47
@ SPA_IO_Position
position information in the graph, struct spa_io_position
Definition io.h:45
@ SPA_NODE_COMMAND_RequestProcess
Sent to a driver when some other node emitted the RequestProcess event.
Definition command.h:42
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_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_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_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_NSEC_PER_MSEC
Definition defs.h:255
#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
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
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