src/lib/ecore_buffer/bq_mgr_protocol.h

   1 #ifndef BQ_MGR_CLIENT_PROTOCOL_H
   2 #define BQ_MGR_CLIENT_PROTOCOL_H
   3
   4 #ifdef  __cplusplus
   5 extern "C" {
   6 #endif
   7
   8 #include <stdint.h>
   9 #include <stddef.h>
  10 #include "wayland-client.h"
  11
  12 struct wl_client;
  13 struct wl_resource;
  14
  15 struct bq_mgr;
  16 struct bq_consumer;
  17 struct bq_provider;
  18 struct bq_buffer;
  19
  20 extern const struct wl_interface bq_mgr_interface;
  21 extern const struct wl_interface bq_consumer_interface;
  22 extern const struct wl_interface bq_provider_interface;
  23 extern const struct wl_interface bq_buffer_interface;
  24
  25 #ifndef BQ_MGR_ERROR_ENUM
  26 #define BQ_MGR_ERROR_ENUM
  27 enum bq_mgr_error {
  28         BQ_MGR_ERROR_INVALID_PERMISSION = 0,
  29         BQ_MGR_ERROR_INVALID_NAME = 1,
  30         BQ_MGR_ERROR_ALREADY_USED = 2,
  31 };
  32 #endif /* BQ_MGR_ERROR_ENUM */
  33
  34 #define BQ_MGR_CREATE_CONSUMER  0
  35 #define BQ_MGR_CREATE_PROVIDER  1
  36
  37 static inline void
  38 bq_mgr_set_user_data(struct bq_mgr *bq_mgr, void *user_data)
  39 {
  40         wl_proxy_set_user_data((struct wl_proxy *) bq_mgr, user_data);
  41 }
  42
  43 static inline void *
  44 bq_mgr_get_user_data(struct bq_mgr *bq_mgr)
  45 {
  46         return wl_proxy_get_user_data((struct wl_proxy *) bq_mgr);
  47 }
  48
  49 static inline void
  50 bq_mgr_destroy(struct bq_mgr *bq_mgr)
  51 {
  52         wl_proxy_destroy((struct wl_proxy *) bq_mgr);
  53 }
  54
  55 static inline struct bq_consumer *
  56 bq_mgr_create_consumer(struct bq_mgr *bq_mgr, const char *name, int32_t queue_size, int32_t width, int32_t height)
  57 {
  58         struct wl_proxy *id;
  59
  60         id = wl_proxy_marshal_constructor((struct wl_proxy *) bq_mgr,
  61                          BQ_MGR_CREATE_CONSUMER, &bq_consumer_interface, NULL, name, queue_size, width, height);
  62
  63         return (struct bq_consumer *) id;
  64 }
  65
  66 static inline struct bq_provider *
  67 bq_mgr_create_provider(struct bq_mgr *bq_mgr, const char *name)
  68 {
  69         struct wl_proxy *id;
  70
  71         id = wl_proxy_marshal_constructor((struct wl_proxy *) bq_mgr,
  72                          BQ_MGR_CREATE_PROVIDER, &bq_provider_interface, NULL, name);
  73
  74         return (struct bq_provider *) id;
  75 }
  76
  77 struct bq_consumer_listener {
  78         /**
  79          * connected - (none)
  80          */
  81         void (*connected)(void *data,
  82                           struct bq_consumer *bq_consumer);
  83         /**
  84          * disconnected - (none)
  85          */
  86         void (*disconnected)(void *data,
  87                              struct bq_consumer *bq_consumer);
  88         /**
  89          * buffer_attached - (none)
  90          * @buffer: (none)
  91          * @engine: (none)
  92          * @width: (none)
  93          * @height: (none)
  94          * @format: (none)
  95          * @flags: (none)
  96          */
  97         void (*buffer_attached)(void *data,
  98                                 struct bq_consumer *bq_consumer,
  99                                 struct bq_buffer *buffer,
 100                                 const char *engine,
 101                                 int32_t width,
 102                                 int32_t height,
 103                                 int32_t format,
 104                                 uint32_t flags);
 105         /**
 106          * set_buffer_id - (none)
 107          * @buffer: (none)
 108          * @id: (none)
 109          * @offset0: (none)
 110          * @stride0: (none)
 111          * @offset1: (none)
 112          * @stride1: (none)
 113          * @offset2: (none)
 114          * @stride2: (none)
 115          */
 116         void (*set_buffer_id)(void *data,
 117                               struct bq_consumer *bq_consumer,
 118                               struct bq_buffer *buffer,
 119                               int32_t id,
 120                               int32_t offset0,
 121                               int32_t stride0,
 122                               int32_t offset1,
 123                               int32_t stride1,
 124                               int32_t offset2,
 125                               int32_t stride2);
 126         /**
 127          * set_buffer_fd - (none)
 128          * @buffer: (none)
 129          * @fd: (none)
 130          * @offset0: (none)
 131          * @stride0: (none)
 132          * @offset1: (none)
 133          * @stride1: (none)
 134          * @offset2: (none)
 135          * @stride2: (none)
 136          */
 137         void (*set_buffer_fd)(void *data,
 138                               struct bq_consumer *bq_consumer,
 139                               struct bq_buffer *buffer,
 140                               int32_t fd,
 141                               int32_t offset0,
 142                               int32_t stride0,
 143                               int32_t offset1,
 144                               int32_t stride1,
 145                               int32_t offset2,
 146                               int32_t stride2);
 147         /**
 148          * buffer_detached - (none)
 149          * @buffer: (none)
 150          */
 151         void (*buffer_detached)(void *data,
 152                                 struct bq_consumer *bq_consumer,
 153                                 struct bq_buffer *buffer);
 154         /**
 155          * add_buffer - (none)
 156          * @buffer: (none)
 157          * @serial: (none)
 158          */
 159         void (*add_buffer)(void *data,
 160                            struct bq_consumer *bq_consumer,
 161                            struct bq_buffer *buffer,
 162                            uint32_t serial);
 163 };
 164
 165 static inline int
 166 bq_consumer_add_listener(struct bq_consumer *bq_consumer,
 167                          const struct bq_consumer_listener *listener, void *data)
 168 {
 169         return wl_proxy_add_listener((struct wl_proxy *) bq_consumer,
 170                                      (void (**)(void)) listener, data);
 171 }
 172
 173 #define BQ_CONSUMER_RELEASE_BUFFER      0
 174
 175 static inline void
 176 bq_consumer_set_user_data(struct bq_consumer *bq_consumer, void *user_data)
 177 {
 178         wl_proxy_set_user_data((struct wl_proxy *) bq_consumer, user_data);
 179 }
 180
 181 static inline void *
 182 bq_consumer_get_user_data(struct bq_consumer *bq_consumer)
 183 {
 184         return wl_proxy_get_user_data((struct wl_proxy *) bq_consumer);
 185 }
 186
 187 static inline void
 188 bq_consumer_destroy(struct bq_consumer *bq_consumer)
 189 {
 190         wl_proxy_destroy((struct wl_proxy *) bq_consumer);
 191 }
 192
 193 static inline void
 194 bq_consumer_release_buffer(struct bq_consumer *bq_consumer, struct bq_buffer *buffer)
 195 {
 196         wl_proxy_marshal((struct wl_proxy *) bq_consumer,
 197                          BQ_CONSUMER_RELEASE_BUFFER, buffer);
 198 }
 199
 200 #ifndef BQ_PROVIDER_ERROR_ENUM
 201 #define BQ_PROVIDER_ERROR_ENUM
 202 enum bq_provider_error {
 203         BQ_PROVIDER_ERROR_OVERFLOW_QUEUE_SIZE = 0,
 204         BQ_PROVIDER_ERROR_CONNECTION = 1,
 205 };
 206 #endif /* BQ_PROVIDER_ERROR_ENUM */
 207
 208 struct bq_provider_listener {
 209         /**
 210          * connected - (none)
 211          * @queue_size: (none)
 212          * @width: (none)
 213          * @height: (none)
 214          */
 215         void (*connected)(void *data,
 216                           struct bq_provider *bq_provider,
 217                           int32_t queue_size,
 218                           int32_t width,
 219                           int32_t height);
 220         /**
 221          * disconnected - (none)
 222          */
 223         void (*disconnected)(void *data,
 224                              struct bq_provider *bq_provider);
 225         /**
 226          * add_buffer - (none)
 227          * @buffer: (none)
 228          * @serial: (none)
 229          */
 230         void (*add_buffer)(void *data,
 231                            struct bq_provider *bq_provider,
 232                            struct bq_buffer *buffer,
 233                            uint32_t serial);
 234 };
 235
 236 static inline int
 237 bq_provider_add_listener(struct bq_provider *bq_provider,
 238                          const struct bq_provider_listener *listener, void *data)
 239 {
 240         return wl_proxy_add_listener((struct wl_proxy *) bq_provider,
 241                                      (void (**)(void)) listener, data);
 242 }
 243
 244 #define BQ_PROVIDER_ATTACH_BUFFER       0
 245 #define BQ_PROVIDER_SET_BUFFER_ID       1
 246 #define BQ_PROVIDER_SET_BUFFER_FD       2
 247 #define BQ_PROVIDER_DETACH_BUFFER       3
 248 #define BQ_PROVIDER_ENQUEUE_BUFFER      4
 249
 250 static inline void
 251 bq_provider_set_user_data(struct bq_provider *bq_provider, void *user_data)
 252 {
 253         wl_proxy_set_user_data((struct wl_proxy *) bq_provider, user_data);
 254 }
 255
 256 static inline void *
 257 bq_provider_get_user_data(struct bq_provider *bq_provider)
 258 {
 259         return wl_proxy_get_user_data((struct wl_proxy *) bq_provider);
 260 }
 261
 262 static inline void
 263 bq_provider_destroy(struct bq_provider *bq_provider)
 264 {
 265         wl_proxy_destroy((struct wl_proxy *) bq_provider);
 266 }
 267
 268 static inline struct bq_buffer *
 269 bq_provider_attach_buffer(struct bq_provider *bq_provider, const char *engine, int32_t width, int32_t height, int32_t format, uint32_t flags)
 270 {
 271         struct wl_proxy *buffer;
 272
 273         buffer = wl_proxy_marshal_constructor((struct wl_proxy *) bq_provider,
 274                          BQ_PROVIDER_ATTACH_BUFFER, &bq_buffer_interface, NULL, engine, width, height, format, flags);
 275
 276         return (struct bq_buffer *) buffer;
 277 }
 278
 279 static inline void
 280 bq_provider_set_buffer_id(struct bq_provider *bq_provider, struct bq_buffer *buffer, int32_t id, int32_t offset0, int32_t stride0, int32_t offset1, int32_t stride1, int32_t offset2, int32_t stride2)
 281 {
 282         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 283                          BQ_PROVIDER_SET_BUFFER_ID, buffer, id, offset0, stride0, offset1, stride1, offset2, stride2);
 284 }
 285
 286 static inline void
 287 bq_provider_set_buffer_fd(struct bq_provider *bq_provider, struct bq_buffer *buffer, int32_t fd, int32_t offset0, int32_t stride0, int32_t offset1, int32_t stride1, int32_t offset2, int32_t stride2)
 288 {
 289         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 290                          BQ_PROVIDER_SET_BUFFER_FD, buffer, fd, offset0, stride0, offset1, stride1, offset2, stride2);
 291 }
 292
 293 static inline void
 294 bq_provider_detach_buffer(struct bq_provider *bq_provider, struct bq_buffer *buffer)
 295 {
 296         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 297                          BQ_PROVIDER_DETACH_BUFFER, buffer);
 298 }
 299
 300 static inline void
 301 bq_provider_enqueue_buffer(struct bq_provider *bq_provider, struct bq_buffer *buffer, uint32_t serial)
 302 {
 303         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 304                          BQ_PROVIDER_ENQUEUE_BUFFER, buffer, serial);
 305 }
 306
 307 static inline void
 308 bq_buffer_set_user_data(struct bq_buffer *bq_buffer, void *user_data)
 309 {
 310         wl_proxy_set_user_data((struct wl_proxy *) bq_buffer, user_data);
 311 }
 312
 313 static inline void *
 314 bq_buffer_get_user_data(struct bq_buffer *bq_buffer)
 315 {
 316         return wl_proxy_get_user_data((struct wl_proxy *) bq_buffer);
 317 }
 318
 319 static inline void
 320 bq_buffer_destroy(struct bq_buffer *bq_buffer)
 321 {
 322         wl_proxy_destroy((struct wl_proxy *) bq_buffer);
 323 }
 324
 325 #ifdef  __cplusplus
 326 }
 327 #endif
 328
 329 #endif