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_pixmap_id - (none)
 128          * @buffer: (none)
 129          * @id: (none)
 130          * @offset0: (none)
 131          * @stride0: (none)
 132          * @offset1: (none)
 133          * @stride1: (none)
 134          * @offset2: (none)
 135          * @stride2: (none)
 136          */
 137         void (*set_buffer_pixmap_id)(void *data,
 138                                      struct bq_consumer *bq_consumer,
 139                                      struct bq_buffer *buffer,
 140                                      int32_t id,
 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          * set_buffer_fd - (none)
 149          * @buffer: (none)
 150          * @fd: (none)
 151          * @offset0: (none)
 152          * @stride0: (none)
 153          * @offset1: (none)
 154          * @stride1: (none)
 155          * @offset2: (none)
 156          * @stride2: (none)
 157          */
 158         void (*set_buffer_fd)(void *data,
 159                               struct bq_consumer *bq_consumer,
 160                               struct bq_buffer *buffer,
 161                               int32_t fd,
 162                               int32_t offset0,
 163                               int32_t stride0,
 164                               int32_t offset1,
 165                               int32_t stride1,
 166                               int32_t offset2,
 167                               int32_t stride2);
 168         /**
 169          * buffer_detached - (none)
 170          * @buffer: (none)
 171          */
 172         void (*buffer_detached)(void *data,
 173                                 struct bq_consumer *bq_consumer,
 174                                 struct bq_buffer *buffer);
 175         /**
 176          * add_buffer - (none)
 177          * @buffer: (none)
 178          * @serial: (none)
 179          */
 180         void (*add_buffer)(void *data,
 181                            struct bq_consumer *bq_consumer,
 182                            struct bq_buffer *buffer,
 183                            uint32_t serial);
 184 };
 185
 186 static inline int
 187 bq_consumer_add_listener(struct bq_consumer *bq_consumer,
 188                          const struct bq_consumer_listener *listener, void *data)
 189 {
 190         return wl_proxy_add_listener((struct wl_proxy *) bq_consumer,
 191                                      (void (**)(void)) listener, data);
 192 }
 193
 194 #define BQ_CONSUMER_DESTROY     0
 195 #define BQ_CONSUMER_RELEASE_BUFFER      1
 196
 197 static inline void
 198 bq_consumer_set_user_data(struct bq_consumer *bq_consumer, void *user_data)
 199 {
 200         wl_proxy_set_user_data((struct wl_proxy *) bq_consumer, user_data);
 201 }
 202
 203 static inline void *
 204 bq_consumer_get_user_data(struct bq_consumer *bq_consumer)
 205 {
 206         return wl_proxy_get_user_data((struct wl_proxy *) bq_consumer);
 207 }
 208
 209 static inline void
 210 bq_consumer_destroy(struct bq_consumer *bq_consumer)
 211 {
 212         wl_proxy_marshal((struct wl_proxy *) bq_consumer,
 213                          BQ_CONSUMER_DESTROY);
 214
 215         wl_proxy_destroy((struct wl_proxy *) bq_consumer);
 216 }
 217
 218 static inline void
 219 bq_consumer_release_buffer(struct bq_consumer *bq_consumer, struct bq_buffer *buffer)
 220 {
 221         wl_proxy_marshal((struct wl_proxy *) bq_consumer,
 222                          BQ_CONSUMER_RELEASE_BUFFER, buffer);
 223 }
 224
 225 #ifndef BQ_PROVIDER_ERROR_ENUM
 226 #define BQ_PROVIDER_ERROR_ENUM
 227 enum bq_provider_error {
 228         BQ_PROVIDER_ERROR_OVERFLOW_QUEUE_SIZE = 0,
 229         BQ_PROVIDER_ERROR_CONNECTION = 1,
 230 };
 231 #endif /* BQ_PROVIDER_ERROR_ENUM */
 232
 233 struct bq_provider_listener {
 234         /**
 235          * connected - (none)
 236          * @queue_size: (none)
 237          * @width: (none)
 238          * @height: (none)
 239          */
 240         void (*connected)(void *data,
 241                           struct bq_provider *bq_provider,
 242                           int32_t queue_size,
 243                           int32_t width,
 244                           int32_t height);
 245         /**
 246          * disconnected - (none)
 247          */
 248         void (*disconnected)(void *data,
 249                              struct bq_provider *bq_provider);
 250         /**
 251          * add_buffer - (none)
 252          * @buffer: (none)
 253          * @serial: (none)
 254          */
 255         void (*add_buffer)(void *data,
 256                            struct bq_provider *bq_provider,
 257                            struct bq_buffer *buffer,
 258                            uint32_t serial);
 259 };
 260
 261 static inline int
 262 bq_provider_add_listener(struct bq_provider *bq_provider,
 263                          const struct bq_provider_listener *listener, void *data)
 264 {
 265         return wl_proxy_add_listener((struct wl_proxy *) bq_provider,
 266                                      (void (**)(void)) listener, data);
 267 }
 268
 269 #define BQ_PROVIDER_DESTROY     0
 270 #define BQ_PROVIDER_ATTACH_BUFFER       1
 271 #define BQ_PROVIDER_SET_BUFFER_ID       2
 272 #define BQ_PROVIDER_SET_BUFFER_PIXMAP_ID        3
 273 #define BQ_PROVIDER_SET_BUFFER_FD       4
 274 #define BQ_PROVIDER_DETACH_BUFFER       5
 275 #define BQ_PROVIDER_ENQUEUE_BUFFER      6
 276
 277 static inline void
 278 bq_provider_set_user_data(struct bq_provider *bq_provider, void *user_data)
 279 {
 280         wl_proxy_set_user_data((struct wl_proxy *) bq_provider, user_data);
 281 }
 282
 283 static inline void *
 284 bq_provider_get_user_data(struct bq_provider *bq_provider)
 285 {
 286         return wl_proxy_get_user_data((struct wl_proxy *) bq_provider);
 287 }
 288
 289 static inline void
 290 bq_provider_destroy(struct bq_provider *bq_provider)
 291 {
 292         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 293                          BQ_PROVIDER_DESTROY);
 294
 295         wl_proxy_destroy((struct wl_proxy *) bq_provider);
 296 }
 297
 298 static inline struct bq_buffer *
 299 bq_provider_attach_buffer(struct bq_provider *bq_provider, const char *engine, int32_t width, int32_t height, int32_t format, uint32_t flags)
 300 {
 301         struct wl_proxy *buffer;
 302
 303         buffer = wl_proxy_marshal_constructor((struct wl_proxy *) bq_provider,
 304                          BQ_PROVIDER_ATTACH_BUFFER, &bq_buffer_interface, NULL, engine, width, height, format, flags);
 305
 306         return (struct bq_buffer *) buffer;
 307 }
 308
 309 static inline void
 310 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)
 311 {
 312         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 313                          BQ_PROVIDER_SET_BUFFER_ID, buffer, id, offset0, stride0, offset1, stride1, offset2, stride2);
 314 }
 315
 316 static inline void
 317 bq_provider_set_buffer_pixmap_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)
 318 {
 319         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 320                          BQ_PROVIDER_SET_BUFFER_PIXMAP_ID, buffer, id, offset0, stride0, offset1, stride1, offset2, stride2);
 321 }
 322
 323 static inline void
 324 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)
 325 {
 326         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 327                          BQ_PROVIDER_SET_BUFFER_FD, buffer, fd, offset0, stride0, offset1, stride1, offset2, stride2);
 328 }
 329
 330 static inline void
 331 bq_provider_detach_buffer(struct bq_provider *bq_provider, struct bq_buffer *buffer)
 332 {
 333         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 334                          BQ_PROVIDER_DETACH_BUFFER, buffer);
 335 }
 336
 337 static inline void
 338 bq_provider_enqueue_buffer(struct bq_provider *bq_provider, struct bq_buffer *buffer, uint32_t serial)
 339 {
 340         wl_proxy_marshal((struct wl_proxy *) bq_provider,
 341                          BQ_PROVIDER_ENQUEUE_BUFFER, buffer, serial);
 342 }
 343
 344 #define BQ_BUFFER_DESTROY       0
 345
 346 static inline void
 347 bq_buffer_set_user_data(struct bq_buffer *bq_buffer, void *user_data)
 348 {
 349         wl_proxy_set_user_data((struct wl_proxy *) bq_buffer, user_data);
 350 }
 351
 352 static inline void *
 353 bq_buffer_get_user_data(struct bq_buffer *bq_buffer)
 354 {
 355         return wl_proxy_get_user_data((struct wl_proxy *) bq_buffer);
 356 }
 357
 358 static inline void
 359 bq_buffer_destroy(struct bq_buffer *bq_buffer)
 360 {
 361         wl_proxy_marshal((struct wl_proxy *) bq_buffer,
 362                          BQ_BUFFER_DESTROY);
 363
 364         wl_proxy_destroy((struct wl_proxy *) bq_buffer);
 365 }
 366
 367 #ifdef  __cplusplus
 368 }
 369 #endif
 370
 371 #endif