mikael-lovqvists-claude-agent/video-setup
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8fa2f33badd0d53fd59c5024ba78d557cc8ff2ed
video-setup/src/modules/protocol/protocol.c
mikael-lovqvists-claude-agent 8fa2f33bad Rename scale → scale_mode in protocol/struct layer; add control grouping future note 
- `Proto_Display_Device_Info.scale` → `scale_mode`
- `Proto_Start_Display.scale` → `scale_mode`
- `PROTO_DISPLAY_CTRL_SCALE` → `PROTO_DISPLAY_CTRL_SCALE_MODE`
- `proto_write_start_display` param and all callers updated
- `on_display` callback param and all sites updated
- `Display_Slot.scale` → `scale_mode` in node
- Control name "Scale" → "Scale Mode"
- planning.md: add control grouping deferred decision

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-03-30 00:54:22 +00:00

906 lines
28 KiB
C
Raw Blame History

#include <stdlib.h>
#include <string.h>
#include "protocol.h"
#include "serial.h"
/* -- growable write buffer ------------------------------------------------- */
struct Wbuf {
uint8_t *data;
uint32_t len;
uint32_t cap;
};
static struct App_Error wbuf_init(struct Wbuf *b, uint32_t initial) {
b->data = malloc(initial);
if (!b->data) { return APP_SYSCALL_ERROR(); }
b->len = 0;
b->cap = initial;
return APP_OK;
}
static void wbuf_free(struct Wbuf *b) {
free(b->data);
}
static struct App_Error wbuf_grow(struct Wbuf *b, uint32_t extra) {
if (b->len + extra <= b->cap) { return APP_OK; }
uint32_t newcap = b->cap ? b->cap : 64;
while (newcap < b->len + extra) { newcap *= 2; }
uint8_t *p = realloc(b->data, newcap);
if (!p) { return APP_SYSCALL_ERROR(); }
b->data = p;
b->cap = newcap;
return APP_OK;
}
static struct App_Error wbuf_u8(struct Wbuf *b, uint8_t v) {
struct App_Error e = wbuf_grow(b, 1);
if (!APP_IS_OK(e)) { return e; }
put_u8(b->data, b->len, v);
b->len += 1;
return APP_OK;
}
static struct App_Error wbuf_u16(struct Wbuf *b, uint16_t v) {
struct App_Error e = wbuf_grow(b, 2);
if (!APP_IS_OK(e)) { return e; }
put_u16(b->data, b->len, v);
b->len += 2;
return APP_OK;
}
static struct App_Error wbuf_i16(struct Wbuf *b, int16_t v) {
struct App_Error e = wbuf_grow(b, 2);
if (!APP_IS_OK(e)) { return e; }
put_i16(b->data, b->len, v);
b->len += 2;
return APP_OK;
}
static struct App_Error wbuf_u32(struct Wbuf *b, uint32_t v) {
struct App_Error e = wbuf_grow(b, 4);
if (!APP_IS_OK(e)) { return e; }
put_u32(b->data, b->len, v);
b->len += 4;
return APP_OK;
}
static struct App_Error wbuf_i32(struct Wbuf *b, int32_t v) {
struct App_Error e = wbuf_grow(b, 4);
if (!APP_IS_OK(e)) { return e; }
put_i32(b->data, b->len, v);
b->len += 4;
return APP_OK;
}
static struct App_Error wbuf_i64(struct Wbuf *b, int64_t v) {
struct App_Error e = wbuf_grow(b, 8);
if (!APP_IS_OK(e)) { return e; }
put_i64(b->data, b->len, v);
b->len += 8;
return APP_OK;
}
/* Serialise a string as u8 length prefix + bytes (truncates at 255). */
static struct App_Error wbuf_str8(struct Wbuf *b, const char *s) {
size_t slen = s ? strlen(s) : 0;
uint8_t n = (slen > 255u) ? 255u : (uint8_t)slen;
struct App_Error e = wbuf_grow(b, (uint32_t)1 + n);
if (!APP_IS_OK(e)) { return e; }
put_u8(b->data, b->len, n);
b->len += 1;
memcpy(b->data + b->len, s, n);
b->len += n;
return APP_OK;
}
static struct App_Error wbuf_bytes(struct Wbuf *b,
const uint8_t *data, uint32_t len)
{
struct App_Error e = wbuf_grow(b, len);
if (!APP_IS_OK(e)) { return e; }
memcpy(b->data + b->len, data, len);
b->len += len;
return APP_OK;
}
/* -- sequential read cursor ------------------------------------------------ */
struct Cursor {
const uint8_t *buf;
uint32_t len;
uint32_t pos;
int ok;
};
static void cur_init(struct Cursor *c, const uint8_t *buf, uint32_t len) {
c->buf = buf;
c->len = len;
c->pos = 0;
c->ok = 1;
}
static void cur_need(struct Cursor *c, uint32_t n) {
if (c->ok && c->pos + n > c->len) { c->ok = 0; }
}
static uint8_t cur_u8(struct Cursor *c) {
cur_need(c, 1);
if (!c->ok) { return 0; }
uint8_t v = get_u8(c->buf, c->pos);
c->pos += 1;
return v;
}
static uint16_t cur_u16(struct Cursor *c) {
cur_need(c, 2);
if (!c->ok) { return 0; }
uint16_t v = get_u16(c->buf, c->pos);
c->pos += 2;
return v;
}
static uint32_t cur_u32(struct Cursor *c) {
cur_need(c, 4);
if (!c->ok) { return 0; }
uint32_t v = get_u32(c->buf, c->pos);
c->pos += 4;
return v;
}
static int32_t cur_i32(struct Cursor *c) {
cur_need(c, 4);
if (!c->ok) { return 0; }
int32_t v = get_i32(c->buf, c->pos);
c->pos += 4;
return v;
}
static int64_t cur_i64(struct Cursor *c) {
cur_need(c, 8);
if (!c->ok) { return 0; }
int64_t v = get_i64(c->buf, c->pos);
c->pos += 8;
return v;
}
/* Read a u8-length-prefixed string; returns pointer into buf and sets *len. */
static const char *cur_str8(struct Cursor *c, uint8_t *len_out) {
uint8_t n = cur_u8(c);
cur_need(c, n);
if (!c->ok) { *len_out = 0; return NULL; }
const char *p = (const char *)(c->buf + c->pos);
c->pos += n;
*len_out = n;
return p;
}
#define CUR_CHECK(c) \
do { if (!(c).ok) { return APP_INVALID_ERROR_MSG(0, "payload too short"); } } while (0)
/* -- write helpers --------------------------------------------------------- */
/*
* Build a CONTROL_RESPONSE base (request_id + status) into b, then append
* extra, then send — all in one call. Used by the specific response writers.
*/
static struct App_Error send_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status,
const uint8_t *extra, uint32_t extra_len)
{
struct Wbuf b;
struct App_Error e = wbuf_init(&b, 4 + extra_len);
if (!APP_IS_OK(e)) { return e; }
e = wbuf_u16(&b, request_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, status); if (!APP_IS_OK(e)) { goto fail; }
if (extra && extra_len > 0) {
e = wbuf_bytes(&b, extra, extra_len);
if (!APP_IS_OK(e)) { goto fail; }
}
e = transport_send_frame(conn, PROTO_MSG_CONTROL_RESPONSE, b.data, b.len);
fail:
wbuf_free(&b);
return e;
}
/* -- write functions ------------------------------------------------------- */
struct App_Error proto_write_video_frame(struct Transport_Conn *conn,
uint16_t stream_id, const uint8_t *data, uint32_t data_len)
{
uint32_t total = 2u + data_len;
uint8_t *buf = malloc(total);
if (!buf) { return APP_SYSCALL_ERROR(); }
put_u16(buf, 0, stream_id);
memcpy(buf + 2, data, data_len);
struct App_Error e = transport_send_frame(conn, PROTO_MSG_VIDEO_FRAME, buf, total);
free(buf);
return e;
}
struct App_Error proto_write_stream_event(struct Transport_Conn *conn,
uint16_t stream_id, uint8_t event_code)
{
uint8_t buf[3];
put_u16(buf, 0, stream_id);
put_u8 (buf, 2, event_code);
return transport_send_frame(conn, PROTO_MSG_STREAM_EVENT, buf, 3);
}
struct App_Error proto_write_stream_open(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id,
uint16_t format, uint16_t pixel_format, uint16_t origin)
{
uint8_t buf[12];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_STREAM_OPEN);
put_u16(buf, 4, stream_id);
put_u16(buf, 6, format);
put_u16(buf, 8, pixel_format);
put_u16(buf, 10, origin);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 12);
}
struct App_Error proto_write_stream_close(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id)
{
uint8_t buf[6];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_STREAM_CLOSE);
put_u16(buf, 4, stream_id);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 6);
}
struct App_Error proto_write_enum_devices(struct Transport_Conn *conn,
uint16_t request_id)
{
uint8_t buf[4];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_ENUM_DEVICES);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 4);
}
struct App_Error proto_write_enum_controls(struct Transport_Conn *conn,
uint16_t request_id, uint16_t device_index)
{
uint8_t buf[6];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_ENUM_CONTROLS);
put_u16(buf, 4, device_index);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 6);
}
struct App_Error proto_write_get_control(struct Transport_Conn *conn,
uint16_t request_id, uint16_t device_index, uint32_t control_id)
{
uint8_t buf[10];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_GET_CONTROL);
put_u16(buf, 4, device_index);
put_u32(buf, 6, control_id);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 10);
}
struct App_Error proto_write_set_control(struct Transport_Conn *conn,
uint16_t request_id, uint16_t device_index,
uint32_t control_id, int32_t value)
{
uint8_t buf[14];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_SET_CONTROL);
put_u16(buf, 4, device_index);
put_u32(buf, 6, control_id);
put_i32(buf, 10, value);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 14);
}
struct App_Error proto_write_enum_monitors(struct Transport_Conn *conn,
uint16_t request_id)
{
uint8_t buf[4];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_ENUM_MONITORS);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 4);
}
struct App_Error proto_write_start_ingest(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id,
uint16_t format, uint16_t width, uint16_t height,
uint16_t fps_n, uint16_t fps_d,
uint16_t transport_mode,
const char *device_path, const char *dest_host, uint16_t dest_port)
{
size_t dp_len = device_path ? strlen(device_path) : 0;
size_t dh_len = dest_host ? strlen(dest_host) : 0;
uint8_t dp_n = dp_len > 255u ? 255u : (uint8_t)dp_len;
uint8_t dh_n = dh_len > 255u ? 255u : (uint8_t)dh_len;
/* 20 bytes fixed + 1+dp_n (device_path str8) + 1+dh_n (dest_host str8) */
uint32_t total = 20u + 1u + dp_n + 1u + dh_n;
uint8_t *buf = malloc(total);
if (!buf) { return APP_SYSCALL_ERROR(); }
uint32_t o = 0;
put_u16(buf, o, request_id); o += 2;
put_u16(buf, o, PROTO_CMD_START_INGEST); o += 2;
put_u16(buf, o, stream_id); o += 2;
put_u16(buf, o, format); o += 2;
put_u16(buf, o, width); o += 2;
put_u16(buf, o, height); o += 2;
put_u16(buf, o, fps_n); o += 2;
put_u16(buf, o, fps_d); o += 2;
put_u16(buf, o, dest_port); o += 2;
put_u16(buf, o, transport_mode); o += 2;
put_u8 (buf, o, dp_n); o += 1;
memcpy(buf + o, device_path, dp_n); o += dp_n;
put_u8 (buf, o, dh_n); o += 1;
memcpy(buf + o, dest_host, dh_n); o += dh_n;
struct App_Error e = transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, total);
free(buf);
return e;
}
struct App_Error proto_write_stop_ingest(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id)
{
uint8_t buf[6];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_STOP_INGEST);
put_u16(buf, 4, stream_id);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 6);
}
struct App_Error proto_write_control_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status,
const uint8_t *payload, uint32_t payload_len)
{
return send_response(conn, request_id, status, payload, payload_len);
}
struct App_Error proto_write_get_control_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status, int32_t value)
{
uint8_t extra[4];
put_i32(extra, 0, value);
return send_response(conn, request_id, status, extra, 4);
}
struct App_Error proto_write_enum_devices_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status,
const struct Proto_Media_Device_Info *media_devices, uint16_t media_count,
const struct Proto_Standalone_Device_Info *standalone, uint16_t standalone_count,
const struct Proto_Display_Device_Info *displays, uint16_t display_count)
{
struct Wbuf b;
struct App_Error e = wbuf_init(&b, 128);
if (!APP_IS_OK(e)) { return e; }
e = wbuf_u16(&b, request_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, status); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, media_count); if (!APP_IS_OK(e)) { goto fail; }
for (uint16_t i = 0; i < media_count; i++) {
const struct Proto_Media_Device_Info *m = &media_devices[i];
e = wbuf_str8(&b, m->path); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, m->driver); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, m->model); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, m->bus_info); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, m->video_node_count); if (!APP_IS_OK(e)) { goto fail; }
for (uint8_t j = 0; j < m->video_node_count; j++) {
const struct Proto_Video_Node_Info *v = &m->video_nodes[j];
e = wbuf_str8(&b, v->path); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, v->entity_name); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32 (&b, v->entity_type); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32 (&b, v->entity_flags);if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32 (&b, v->device_caps); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, v->pad_flags); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, v->is_capture); if (!APP_IS_OK(e)) { goto fail; }
}
}
e = wbuf_u16(&b, standalone_count); if (!APP_IS_OK(e)) { goto fail; }
for (uint16_t i = 0; i < standalone_count; i++) {
e = wbuf_str8(&b, standalone[i].path); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, standalone[i].name); if (!APP_IS_OK(e)) { goto fail; }
}
e = wbuf_u16(&b, display_count); if (!APP_IS_OK(e)) { goto fail; }
for (uint16_t i = 0; i < display_count; i++) {
const struct Proto_Display_Device_Info *d = &displays[i];
e = wbuf_u16(&b, d->device_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, d->stream_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i16(&b, d->win_x); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i16(&b, d->win_y); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, d->win_w); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, d->win_h); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, d->scale_mode); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, d->anchor); if (!APP_IS_OK(e)) { goto fail; }
}
e = transport_send_frame(conn, PROTO_MSG_CONTROL_RESPONSE, b.data, b.len);
fail:
wbuf_free(&b);
return e;
}
struct App_Error proto_write_enum_controls_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status,
const struct Proto_Control_Info *controls, uint16_t count)
{
struct Wbuf b;
struct App_Error e = wbuf_init(&b, 256);
if (!APP_IS_OK(e)) { return e; }
e = wbuf_u16(&b, request_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, status); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, count); if (!APP_IS_OK(e)) { goto fail; }
for (uint16_t i = 0; i < count; i++) {
const struct Proto_Control_Info *c = &controls[i];
e = wbuf_u32(&b, c->id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, c->type); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32(&b, c->flags); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, c->name); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, c->min); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, c->max); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, c->step); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, c->default_val); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, c->current_val); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u8 (&b, c->menu_count); if (!APP_IS_OK(e)) { goto fail; }
for (uint8_t j = 0; j < c->menu_count; j++) {
const struct Proto_Menu_Item *m = &c->menu_items[j];
e = wbuf_u32(&b, m->index); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, m->name); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i64(&b, m->int_value); if (!APP_IS_OK(e)) { goto fail; }
}
}
e = transport_send_frame(conn, PROTO_MSG_CONTROL_RESPONSE, b.data, b.len);
fail:
wbuf_free(&b);
return e;
}
struct App_Error proto_write_enum_monitors_response(struct Transport_Conn *conn,
uint16_t request_id, uint16_t status,
const struct Proto_Monitor_Info *monitors, uint16_t count)
{
struct Wbuf b;
struct App_Error e = wbuf_init(&b, 64);
if (!APP_IS_OK(e)) { return e; }
e = wbuf_u16(&b, request_id); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, status); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u16(&b, count); if (!APP_IS_OK(e)) { goto fail; }
for (uint16_t i = 0; i < count; i++) {
const struct Proto_Monitor_Info *m = &monitors[i];
e = wbuf_i32(&b, m->x); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_i32(&b, m->y); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32(&b, m->width); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_u32(&b, m->height); if (!APP_IS_OK(e)) { goto fail; }
e = wbuf_str8(&b, m->name); if (!APP_IS_OK(e)) { goto fail; }
}
e = transport_send_frame(conn, PROTO_MSG_CONTROL_RESPONSE, b.data, b.len);
fail:
wbuf_free(&b);
return e;
}
/* -- read functions -------------------------------------------------------- */
struct App_Error proto_read_video_frame(
const uint8_t *payload, uint32_t length,
struct Proto_Video_Frame *out)
{
if (length < 2) { return APP_INVALID_ERROR_MSG(0, "VIDEO_FRAME payload too short"); }
out->stream_id = get_u16(payload, 0);
out->data = payload + 2;
out->data_len = length - 2;
return APP_OK;
}
struct App_Error proto_read_stream_event(
const uint8_t *payload, uint32_t length,
struct Proto_Stream_Event *out)
{
if (length < 3) { return APP_INVALID_ERROR_MSG(0, "STREAM_EVENT payload too short"); }
out->stream_id = get_u16(payload, 0);
out->event_code = get_u8 (payload, 2);
return APP_OK;
}
struct App_Error proto_read_request_header(
const uint8_t *payload, uint32_t length,
struct Proto_Request_Header *out)
{
if (length < 4) { return APP_INVALID_ERROR_MSG(0, "CONTROL_REQUEST payload too short"); }
out->request_id = get_u16(payload, 0);
out->command = get_u16(payload, 2);
return APP_OK;
}
struct App_Error proto_read_stream_open(
const uint8_t *payload, uint32_t length,
struct Proto_Stream_Open *out)
{
if (length < 12) { return APP_INVALID_ERROR_MSG(0, "STREAM_OPEN payload too short"); }
out->request_id = get_u16(payload, 0);
out->stream_id = get_u16(payload, 4);
out->format = get_u16(payload, 6);
out->pixel_format = get_u16(payload, 8);
out->origin = get_u16(payload, 10);
return APP_OK;
}
struct App_Error proto_read_stream_close(
const uint8_t *payload, uint32_t length,
struct Proto_Stream_Close *out)
{
if (length < 6) { return APP_INVALID_ERROR_MSG(0, "STREAM_CLOSE payload too short"); }
out->request_id = get_u16(payload, 0);
out->stream_id = get_u16(payload, 4);
return APP_OK;
}
struct App_Error proto_read_enum_controls_req(
const uint8_t *payload, uint32_t length,
struct Proto_Enum_Controls_Req *out)
{
if (length < 6) { return APP_INVALID_ERROR_MSG(0, "ENUM_CONTROLS request payload too short"); }
out->request_id = get_u16(payload, 0);
out->device_index = get_u16(payload, 4);
return APP_OK;
}
struct App_Error proto_read_get_control_req(
const uint8_t *payload, uint32_t length,
struct Proto_Get_Control_Req *out)
{
if (length < 10) { return APP_INVALID_ERROR_MSG(0, "GET_CONTROL request payload too short"); }
out->request_id = get_u16(payload, 0);
out->device_index = get_u16(payload, 4);
out->control_id = get_u32(payload, 6);
return APP_OK;
}
struct App_Error proto_read_set_control_req(
const uint8_t *payload, uint32_t length,
struct Proto_Set_Control_Req *out)
{
if (length < 14) { return APP_INVALID_ERROR_MSG(0, "SET_CONTROL request payload too short"); }
out->request_id = get_u16(payload, 0);
out->device_index = get_u16(payload, 4);
out->control_id = get_u32(payload, 6);
out->value = get_i32(payload, 10);
return APP_OK;
}
struct App_Error proto_read_start_ingest(
const uint8_t *payload, uint32_t length,
struct Proto_Start_Ingest *out)
{
/* Fixed portion: request_id(2) cmd(2) stream_id(2) format(2) width(2)
* height(2) fps_n(2) fps_d(2) dest_port(2) transport_mode(2) = 20 bytes,
* then two str8 fields. */
struct Cursor c;
cur_init(&c, payload, length);
out->request_id = cur_u16(&c);
/* skip command word at [2..3] */
(void) cur_u16(&c);
out->stream_id = cur_u16(&c);
out->format = cur_u16(&c);
out->width = cur_u16(&c);
out->height = cur_u16(&c);
out->fps_n = cur_u16(&c);
out->fps_d = cur_u16(&c);
out->dest_port = cur_u16(&c);
out->transport_mode = cur_u16(&c);
out->device_path = cur_str8(&c, &out->device_path_len);
out->dest_host = cur_str8(&c, &out->dest_host_len);
CUR_CHECK(c);
return APP_OK;
}
struct App_Error proto_read_stop_ingest(
const uint8_t *payload, uint32_t length,
struct Proto_Stop_Ingest *out)
{
if (length < 6) { return APP_INVALID_ERROR_MSG(0, "STOP_INGEST payload too short"); }
out->request_id = get_u16(payload, 0);
out->stream_id = get_u16(payload, 4);
return APP_OK;
}
/* START_DISPLAY: request_id(2) cmd(2) stream_id(2) win_x(2) win_y(2)
* win_w(2) win_h(2) scale_mode(1) anchor(1) no_signal_fps(1) reserved(1) = 18 bytes */
struct App_Error proto_write_start_display(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id,
int16_t win_x, int16_t win_y, uint16_t win_w, uint16_t win_h,
uint8_t scale_mode, uint8_t anchor, uint8_t no_signal_fps)
{
uint8_t buf[18];
uint32_t o = 0;
put_u16(buf, o, request_id); o += 2;
put_u16(buf, o, PROTO_CMD_START_DISPLAY); o += 2;
put_u16(buf, o, stream_id); o += 2;
put_i16(buf, o, win_x); o += 2;
put_i16(buf, o, win_y); o += 2;
put_u16(buf, o, win_w); o += 2;
put_u16(buf, o, win_h); o += 2;
put_u8 (buf, o, scale_mode); o += 1;
put_u8 (buf, o, anchor); o += 1;
put_u8 (buf, o, no_signal_fps); o += 1;
put_u8 (buf, o, 0); o += 1; /* reserved */
(void)o;
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 18);
}
struct App_Error proto_write_stop_display(struct Transport_Conn *conn,
uint16_t request_id, uint16_t stream_id)
{
uint8_t buf[6];
put_u16(buf, 0, request_id);
put_u16(buf, 2, PROTO_CMD_STOP_DISPLAY);
put_u16(buf, 4, stream_id);
return transport_send_frame(conn, PROTO_MSG_CONTROL_REQUEST, buf, 6);
}
struct App_Error proto_read_start_display(
const uint8_t *payload, uint32_t length,
struct Proto_Start_Display *out)
{
if (length < 16) { return APP_INVALID_ERROR_MSG(0, "START_DISPLAY payload too short"); }
out->request_id = get_u16(payload, 0);
/* skip command word at [2..3] */
out->stream_id = get_u16(payload, 4);
out->win_x = get_i16(payload, 6);
out->win_y = get_i16(payload, 8);
out->win_w = get_u16(payload, 10);
out->win_h = get_u16(payload, 12);
out->scale_mode = get_u8 (payload, 14);
out->anchor = get_u8 (payload, 15);
out->no_signal_fps = length >= 18 ? get_u8(payload, 16) : 0;
return APP_OK;
}
struct App_Error proto_read_stop_display(
const uint8_t *payload, uint32_t length,
struct Proto_Stop_Display *out)
{
if (length < 6) { return APP_INVALID_ERROR_MSG(0, "STOP_DISPLAY payload too short"); }
out->request_id = get_u16(payload, 0);
out->stream_id = get_u16(payload, 4);
return APP_OK;
}
struct App_Error proto_read_response_header(
const uint8_t *payload, uint32_t length,
struct Proto_Response_Header *out)
{
if (length < 4) { return APP_INVALID_ERROR_MSG(0, "CONTROL_RESPONSE payload too short"); }
out->request_id = get_u16(payload, 0);
out->status = get_u16(payload, 2);
return APP_OK;
}
struct App_Error proto_read_get_control_response(
const uint8_t *payload, uint32_t length,
struct Proto_Get_Control_Resp *out)
{
if (length < 8) { return APP_INVALID_ERROR_MSG(0, "GET_CONTROL response payload too short"); }
out->request_id = get_u16(payload, 0);
out->status = get_u16(payload, 2);
out->value = get_i32(payload, 4);
return APP_OK;
}
struct App_Error proto_read_enum_devices_response(
const uint8_t *payload, uint32_t length,
struct Proto_Response_Header *header_out,
void (*on_media_device)(
const char *path, uint8_t path_len,
const char *driver, uint8_t driver_len,
const char *model, uint8_t model_len,
const char *bus_info, uint8_t bus_info_len,
uint8_t video_node_count,
void *userdata),
void (*on_video_node)(
const char *path, uint8_t path_len,
const char *entity_name, uint8_t entity_name_len,
uint32_t entity_type, uint32_t entity_flags,
uint32_t device_caps,
uint8_t pad_flags, uint8_t is_capture,
void *userdata),
void (*on_standalone)(
const char *path, uint8_t path_len,
const char *name, uint8_t name_len,
void *userdata),
void (*on_display)(
uint16_t stream_id,
int16_t win_x, int16_t win_y,
uint16_t win_w, uint16_t win_h,
uint8_t scale_mode, uint8_t anchor,
void *userdata),
void *userdata)
{
struct Cursor c;
cur_init(&c, payload, length);
header_out->request_id = cur_u16(&c);
header_out->status = cur_u16(&c);
uint16_t media_count = cur_u16(&c);
CUR_CHECK(c);
for (uint16_t i = 0; i < media_count; i++) {
uint8_t path_len, driver_len, model_len, bus_info_len;
const char *path = cur_str8(&c, &path_len);
const char *driver = cur_str8(&c, &driver_len);
const char *model = cur_str8(&c, &model_len);
const char *bus_info = cur_str8(&c, &bus_info_len);
uint8_t vcount = cur_u8(&c);
CUR_CHECK(c);
if (on_media_device) {
on_media_device(path, path_len, driver, driver_len,
model, model_len, bus_info, bus_info_len,
vcount, userdata);
}
for (uint8_t j = 0; j < vcount; j++) {
uint8_t vpath_len, ename_len;
const char *vpath = cur_str8(&c, &vpath_len);
const char *ename = cur_str8(&c, &ename_len);
uint32_t etype = cur_u32(&c);
uint32_t eflags = cur_u32(&c);
uint32_t dcaps = cur_u32(&c);
uint8_t pflags = cur_u8(&c);
uint8_t iscap = cur_u8(&c);
CUR_CHECK(c);
if (on_video_node) {
on_video_node(vpath, vpath_len, ename, ename_len,
etype, eflags, dcaps, pflags, iscap, userdata);
}
}
}
uint16_t standalone_count = cur_u16(&c);
CUR_CHECK(c);
for (uint16_t i = 0; i < standalone_count; i++) {
uint8_t path_len, name_len;
const char *path = cur_str8(&c, &path_len);
const char *name = cur_str8(&c, &name_len);
CUR_CHECK(c);
if (on_standalone) { on_standalone(path, path_len, name, name_len, userdata); }
}
/* Display section — optional; absent in messages from older nodes */
if (c.ok && c.pos + 2 <= c.len) {
uint16_t display_count = cur_u16(&c);
CUR_CHECK(c);
for (uint16_t i = 0; i < display_count; i++) {
uint16_t device_id = cur_u16(&c);
uint16_t stream_id = cur_u16(&c);
int16_t win_x = (int16_t)cur_u16(&c);
int16_t win_y = (int16_t)cur_u16(&c);
uint16_t win_w = cur_u16(&c);
uint16_t win_h = cur_u16(&c);
uint8_t scale_mode = cur_u8(&c);
uint8_t anchor = cur_u8(&c);
CUR_CHECK(c);
if (on_display) {
on_display(device_id, stream_id, win_x, win_y,
win_w, win_h, scale_mode, anchor, userdata);
}
}
}
return APP_OK;
}
struct App_Error proto_read_enum_controls_response(
const uint8_t *payload, uint32_t length,
struct Proto_Response_Header *header_out,
void (*on_control)(
uint32_t id, uint8_t type, uint32_t flags,
const char *name, uint8_t name_len,
int32_t min, int32_t max, int32_t step,
int32_t default_val, int32_t current_val,
uint8_t menu_count, void *userdata),
void (*on_menu_item)(
uint32_t index,
const char *name, uint8_t name_len,
int64_t int_value,
void *userdata),
void *userdata)
{
struct Cursor c;
cur_init(&c, payload, length);
header_out->request_id = cur_u16(&c);
header_out->status = cur_u16(&c);
CUR_CHECK(c);
if (header_out->status != PROTO_STATUS_OK) { return APP_OK; }
uint16_t count = cur_u16(&c);
CUR_CHECK(c);
for (uint16_t i = 0; i < count; i++) {
uint32_t id = cur_u32(&c);
uint8_t type = cur_u8 (&c);
uint32_t flags = cur_u32(&c);
uint8_t name_len;
const char *name = cur_str8(&c, &name_len);
int32_t min = cur_i32(&c);
int32_t max = cur_i32(&c);
int32_t step = cur_i32(&c);
int32_t def = cur_i32(&c);
int32_t cur = cur_i32(&c);
uint8_t menu_count = cur_u8(&c);
CUR_CHECK(c);
if (on_control) {
on_control(id, type, flags, name, name_len,
min, max, step, def, cur, menu_count, userdata);
}
for (uint8_t j = 0; j < menu_count; j++) {
uint32_t midx = cur_u32(&c);
uint8_t mname_len;
const char *mname = cur_str8(&c, &mname_len);
int64_t mval = cur_i64(&c);
CUR_CHECK(c);
if (on_menu_item) {
on_menu_item(midx, mname, mname_len, mval, userdata);
}
}
}
return APP_OK;
}
struct App_Error proto_read_enum_monitors_response(
const uint8_t *payload, uint32_t length,
struct Proto_Response_Header *header_out,
void (*on_monitor)(
int32_t x, int32_t y, uint32_t width, uint32_t height,
const char *name, uint8_t name_len,
void *userdata),
void *userdata)
{
struct Cursor c;
cur_init(&c, payload, length);
header_out->request_id = cur_u16(&c);
header_out->status = cur_u16(&c);
uint16_t count = cur_u16(&c);
CUR_CHECK(c);
for (uint16_t i = 0; i < count; i++) {
int32_t x = cur_i32(&c);
int32_t y = cur_i32(&c);
uint32_t width = cur_u32(&c);
uint32_t height = cur_u32(&c);
uint8_t name_len;
const char *name = cur_str8(&c, &name_len);
CUR_CHECK(c);
if (on_monitor) {
on_monitor(x, y, width, height, name, name_len, userdata);
}
}
return APP_OK;
}
Reference in New Issue View Git Blame Copy Permalink