#include "config.h"
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#define BPP 3
#define CURSOR_WIDTH 64
#define CURSOR_HEIGHT 64
#define CURSOR_BPP 4
#define MAX_BUFFERS 64
#define M_PI_M2 ( M_PI + M_PI )
struct data {
int32_t stride;
int counter;
uint32_t seq;
double crop;
double accumulator;
};
static void draw_elipse(uint32_t *dst, int width, int height, uint32_t color)
{
int i, j, r1, r2, r12, r22, r122;
r1 = width/2;
r12 = r1 * r1;
r2 = height/2;
r22 = r2 * r2;
r122 = r12 * r22;
for (i = -r2; i < r2; i++) {
for (j = -r1; j < r1; j++) {
dst[(i + r2)*width+(j+r1)] =
(i * i * r12 + j * j * r22 <= r122) ? color : 0x00000000;
}
}
}
static void on_process(void *userdata)
{
struct data *data = userdata;
uint32_t i, j;
uint8_t *p;
return;
}
return;
#if 0
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
#else
#endif
}
r++;
}
}
data->crop = (sin(data->accumulator) + 1.0) * 32.0;
}
uint32_t *bitmap, color;
mcs->
position.
x = (sin(data->accumulator) + 1.0) * 160.0 + 80;
mcs->
position.
y = (cos(data->accumulator) + 1.0) * 100.0 + 50;
mb->
stride = CURSOR_WIDTH * CURSOR_BPP;
color = (cos(data->accumulator) + 1.0) * (1 << 23);
color |= 0xff000000;
}
for (i = 0; i < data->format.size.height; i++) {
for (j = 0; j < data->format.size.width * BPP; j++) {
p[j] = data->counter + j * i;
}
p += data->stride;
data->counter += 13;
}
data->accumulator += M_PI_M2 / 50.0;
if (data->accumulator >= M_PI_M2)
data->accumulator -= M_PI_M2;
}
static void on_timeout(void *userdata, uint64_t expirations)
{
struct data *data = userdata;
}
const char *error)
{
struct data *data = _data;
switch (state) {
data->timer, NULL, NULL, false);
break;
{
struct timespec timeout, interval;
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
interval.tv_sec = 0;
data->timer, &timeout, &interval, false);
break;
}
default:
break;
}
}
static void on_stream_add_buffer(
void *_data,
struct pw_buffer *buffer)
{
struct data *data = _data;
#ifdef HAVE_MEMFD_CREATE
unsigned int seals;
#endif
return;
}
#ifdef HAVE_MEMFD_CREATE
d[0].
fd = memfd_create(
"video-src-memfd", MFD_CLOEXEC | MFD_ALLOW_SEALING);
#else
#endif
return;
}
return;
}
#ifdef HAVE_MEMFD_CREATE
seals = F_SEAL_GROW | F_SEAL_SHRINK | F_SEAL_SEAL;
if (fcntl(d[0].
fd, F_ADD_SEALS, seals) == -1) {
}
#endif
d[0].
data = mmap(NULL, d[0].
maxsize, PROT_READ|PROT_WRITE,
if (d[0].
data == MAP_FAILED) {
return;
}
}
static void on_stream_remove_buffer(
void *_data,
struct pw_buffer *buffer)
{
}
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];
return;
#define CURSOR_META_SIZE(w,h) (sizeof(struct spa_meta_cursor) + \
sizeof(struct spa_meta_bitmap) + w * h * CURSOR_BPP)
CURSOR_META_SIZE(CURSOR_WIDTH,CURSOR_HEIGHT)));
}
.process = on_process,
.state_changed = on_stream_state_changed,
.param_changed = on_stream_param_changed,
.add_buffer = on_stream_add_buffer,
.remove_buffer = on_stream_remove_buffer,
};
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];
"video-src-alloc",
NULL),
&stream_events,
params, 1);
return 0;
}