backends/virtual/tdm_virtual_display.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include "tdm_virtual.h"
   6
   7 typedef struct _tdm_virtual_output_data tdm_virtual_output_data;
   8 typedef struct _tdm_virtual_layer_data tdm_virtual_layer_data;
   9 typedef struct _tdm_virtual_event_data tdm_virtual_event_data;
  10
  11 typedef enum {
  12         TDM_VIRTUAL_EVENT_TYPE_WAIT,
  13         TDM_VIRTUAL_EVENT_TYPE_COMMIT,
  14 } tdm_virtual_event_type;
  15
  16 struct _tdm_virtual_event_data {
  17         struct list_head link;
  18
  19         tdm_virtual_event_type type;
  20         tdm_virtual_output_data *output_data;
  21         void *user_data;
  22 };
  23
  24 struct _tdm_virtual_output_data {
  25         struct list_head link;
  26
  27         /* data which are fixed at initializing */
  28         tdm_virtual_data *virtual_data;
  29
  30         uint32_t pipe;
  31         tdm_output_mode *output_mode;
  32         int mode_count;
  33         tdm_output_type connector_type;
  34         struct list_head layer_list;
  35         tdm_virtual_layer_data *primary_layer;
  36
  37         /* not fixed data below */
  38         tdm_output_vblank_handler vblank_func;
  39         tdm_output_commit_handler commit_func;
  40
  41         tdm_output_conn_status status;
  42
  43         int mode_changed;
  44         const tdm_output_mode *current_mode;
  45
  46         tdm_event_loop_source *timer;
  47         unsigned int timer_waiting;
  48         struct list_head timer_event_list;
  49
  50         unsigned int mmwidth;
  51         unsigned int mmheight;
  52
  53         char name[TDM_NAME_LEN];        /**< The output name */
  54 };
  55
  56 struct _tdm_virtual_layer_data {
  57         struct list_head link;
  58
  59         /* data which are fixed at initializing */
  60         tdm_virtual_data *virtual_data;
  61         tdm_virtual_output_data *output_data;
  62         tdm_layer_capability capabilities;
  63         int zpos;
  64
  65         /* not fixed data below */
  66         tdm_info_layer info;
  67         int info_changed;
  68
  69         tbm_surface_h display_buffer;
  70         int display_buffer_changed;
  71 };
  72
  73 static void
  74 _tdm_virtual_display_cb_event(tdm_virtual_output_data *output_data, tdm_virtual_event_data *event_data,
  75                                                         unsigned int sequence, unsigned int tv_sec, unsigned int tv_usec)
  76 {
  77         switch (event_data->type) {
  78         case TDM_VIRTUAL_EVENT_TYPE_WAIT:
  79                 if (output_data->vblank_func)
  80                         output_data->vblank_func(output_data, sequence, tv_sec, tv_usec, event_data->user_data);
  81                 break;
  82         case TDM_VIRTUAL_EVENT_TYPE_COMMIT:
  83                 if (output_data->commit_func)
  84                         output_data->commit_func(output_data, sequence, tv_sec, tv_usec, event_data->user_data);
  85                 break;
  86         default:
  87                 break;
  88         }
  89 }
  90
  91 static tdm_error
  92 _tdm_virtual_display_cb_timeout(void *user_data)
  93 {
  94         tdm_virtual_output_data *output_data = user_data;
  95         tdm_virtual_event_data *e = NULL, *ee = NULL;
  96         unsigned int tv_sec, tv_usec;
  97         static unsigned int sequence = 0;
  98         struct timespec tp;
  99
 100         sequence++;
 101
 102         if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0) {
 103                 tv_sec = tp.tv_sec;
 104                 tv_usec = tp.tv_nsec / 1000;
 105         } else {
 106                 tv_sec = tv_usec = 0;
 107         }
 108
 109         LIST_FOR_EACH_ENTRY_SAFE(e, ee, &output_data->timer_event_list, link) {
 110                 LIST_DEL(&e->link);
 111                 _tdm_virtual_display_cb_event(output_data, e, sequence, tv_sec, tv_usec);
 112                 free(e);
 113         }
 114
 115         return TDM_ERROR_NONE;
 116 }
 117
 118 static tdm_error
 119 _tdm_virtual_display_wait_vblank(tdm_virtual_output_data *output_data, int interval, tdm_virtual_event_data *event_data)
 120 {
 121         tdm_error ret;
 122         unsigned int ms;
 123
 124         RETURN_VAL_IF_FAIL(output_data->timer != NULL, TDM_ERROR_OPERATION_FAILED);
 125         RETURN_VAL_IF_FAIL(output_data->output_mode->vrefresh > 0, TDM_ERROR_OPERATION_FAILED);
 126
 127         if (output_data->timer_waiting) {
 128                 LIST_ADDTAIL(&event_data->link, &output_data->timer_event_list);
 129                 return TDM_ERROR_NONE;
 130         }
 131
 132         ms = ((double)1000.0 / output_data->output_mode->vrefresh) * interval;
 133
 134         ret = tdm_event_loop_source_timer_update(output_data->timer, ms);
 135         if (ret != TDM_ERROR_NONE)
 136                 return ret;
 137
 138         LIST_ADDTAIL(&event_data->link, &output_data->timer_event_list);
 139
 140         return TDM_ERROR_NONE;
 141 }
 142
 143 static void
 144 _tdm_virtual_display_destroy_layer_list(tdm_virtual_data *virtual_data)
 145 {
 146         tdm_virtual_output_data *o = NULL;
 147
 148         LIST_FOR_EACH_ENTRY(o, &virtual_data->output_list, link) {
 149                 tdm_virtual_layer_data *l = NULL, *ll = NULL;
 150                 LIST_FOR_EACH_ENTRY_SAFE(l, ll, &o->layer_list, link) {
 151                         LIST_DEL(&l->link);
 152                         free(l);
 153                 }
 154         }
 155 }
 156
 157 tdm_error
 158 tdm_virtual_display_create_layer_list(tdm_virtual_data *virtual_data)
 159 {
 160         tdm_virtual_output_data *output_data = NULL;
 161         tdm_error ret = TDM_ERROR_NONE;
 162
 163         if (LIST_IS_EMPTY(&virtual_data->output_list)) {
 164                 TDM_ERR("no output");
 165                 return TDM_ERROR_OPERATION_FAILED;
 166         }
 167
 168         /* The TDM virtual backend only support one output. */
 169         LIST_FOR_EACH_ENTRY(output_data, &virtual_data->output_list, link) {
 170                 tdm_virtual_layer_data *layer_data = calloc(1, sizeof(tdm_virtual_layer_data));
 171                 if (!layer_data) {
 172                         TDM_ERR("alloc failed");
 173                         ret = TDM_ERROR_OUT_OF_MEMORY;
 174                         goto failed;
 175                 }
 176
 177                 layer_data->virtual_data = virtual_data;
 178                 layer_data->output_data = output_data;
 179                 layer_data->zpos = 0;
 180
 181                 layer_data->capabilities = TDM_LAYER_CAPABILITY_PRIMARY | TDM_LAYER_CAPABILITY_GRAPHIC;
 182                 output_data->primary_layer = layer_data;
 183
 184                 LIST_ADDTAIL(&layer_data->link, &output_data->layer_list);
 185         }
 186
 187         return TDM_ERROR_NONE;
 188 failed:
 189         _tdm_virtual_display_destroy_layer_list(virtual_data);
 190         return ret;
 191 }
 192
 193 void
 194 tdm_virtual_display_destroy_output_list(tdm_virtual_data *virtual_data)
 195 {
 196         tdm_virtual_output_data *o = NULL, *oo = NULL;
 197
 198         if (LIST_IS_EMPTY(&virtual_data->output_list))
 199                 return;
 200
 201         _tdm_virtual_display_destroy_layer_list(virtual_data);
 202
 203         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &virtual_data->output_list, link) {
 204                 LIST_DEL(&o->link);
 205
 206                 if (!LIST_IS_EMPTY(&o->timer_event_list)) {
 207                         tdm_virtual_event_data *e = NULL, *ee = NULL;
 208                         LIST_FOR_EACH_ENTRY_SAFE(e, ee, &o->timer_event_list, link) {
 209                                 LIST_DEL(&e->link);
 210                                 free(e);
 211                         }
 212                 }
 213
 214                 if (o->timer)
 215                         tdm_event_loop_source_remove(o->timer);
 216
 217                 free(o->output_mode);
 218                 free(o);
 219         }
 220 }
 221
 222 tdm_error
 223 tdm_virtual_display_create_output_list(tdm_virtual_data *virtual_data)
 224 {
 225         tdm_virtual_output_data *output_data;
 226         tdm_error ret;
 227
 228         RETURN_VAL_IF_FAIL(LIST_IS_EMPTY(&virtual_data->output_list), TDM_ERROR_OPERATION_FAILED);
 229
 230         output_data = calloc(1, sizeof(tdm_virtual_output_data));
 231         if (!output_data) {
 232                 TDM_ERR("alloc failed");
 233                 ret = TDM_ERROR_OUT_OF_MEMORY;
 234                 goto failed_create;
 235         }
 236
 237         LIST_INITHEAD(&output_data->layer_list);
 238
 239         output_data->virtual_data = virtual_data;
 240         output_data->pipe = 0;
 241         output_data->connector_type = TDM_OUTPUT_TYPE_Unknown;
 242         output_data->status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
 243
 244         output_data->output_mode = calloc(1, sizeof(tdm_output_mode));
 245         if (!output_data->output_mode) {
 246                 TDM_ERR("alloc failed");
 247                 free(output_data);
 248                 ret = TDM_ERROR_OUT_OF_MEMORY;
 249                 goto failed_create;
 250         }
 251
 252         snprintf(output_data->output_mode->name, TDM_NAME_LEN, "640x480");
 253         output_data->output_mode->vrefresh = 30;
 254         output_data->output_mode->clock = 25200;
 255         output_data->output_mode->hdisplay = 640;
 256         output_data->output_mode->hsync_start = 656;
 257         output_data->output_mode->hsync_end = 752;
 258         output_data->output_mode->htotal = 800;
 259         output_data->output_mode->hskew = 0;
 260         output_data->output_mode->vdisplay = 480;
 261         output_data->output_mode->vsync_start = 490;
 262         output_data->output_mode->vsync_end = 492;
 263         output_data->output_mode->vtotal = 525;
 264         output_data->output_mode->vscan = 0;
 265         output_data->output_mode->flags = 0;
 266         output_data->output_mode->type = 0;
 267
 268         output_data->timer = tdm_event_loop_add_timer_handler(virtual_data->dpy,
 269                                                                                                                   _tdm_virtual_display_cb_timeout,
 270                                                                                                                   output_data,
 271                                                                                                                   &ret);
 272         if (!output_data->timer) {
 273                 free(output_data);
 274                 return ret;
 275         }
 276
 277         LIST_INITHEAD(&output_data->timer_event_list);
 278
 279         LIST_ADDTAIL(&output_data->link, &virtual_data->output_list);
 280
 281         return TDM_ERROR_NONE;
 282 failed_create:
 283         tdm_virtual_display_destroy_output_list(virtual_data);
 284         return ret;
 285 }
 286
 287 tdm_error
 288 virtual_display_get_capability(tdm_backend_data *bdata, tdm_caps_display *caps)
 289 {
 290         RETURN_VAL_IF_FAIL(caps, TDM_ERROR_INVALID_PARAMETER);
 291
 292         caps->max_layer_count = -1; /* not defined */
 293
 294         return TDM_ERROR_NONE;
 295 }
 296
 297 tdm_output **
 298 virtual_display_get_outputs(tdm_backend_data *bdata, int *count, tdm_error *error)
 299 {
 300         tdm_virtual_data *virtual_data = bdata;
 301         tdm_virtual_output_data *output_data = NULL;
 302         tdm_output **outputs;
 303         tdm_error ret;
 304         int i;
 305
 306         RETURN_VAL_IF_FAIL(virtual_data, NULL);
 307         RETURN_VAL_IF_FAIL(count, NULL);
 308
 309         *count = 0;
 310         LIST_FOR_EACH_ENTRY(output_data, &virtual_data->output_list, link)
 311         (*count)++;
 312
 313         if (*count == 0) {
 314                 ret = TDM_ERROR_NONE;
 315                 goto failed_get;
 316         }
 317
 318         /* will be freed in frontend */
 319         outputs = calloc(*count, sizeof(tdm_virtual_output_data *));
 320         if (!outputs) {
 321                 TDM_ERR("failed: alloc memory");
 322                 *count = 0;
 323                 ret = TDM_ERROR_OUT_OF_MEMORY;
 324                 goto failed_get;
 325         }
 326
 327         i = 0;
 328         LIST_FOR_EACH_ENTRY(output_data, &virtual_data->output_list, link)
 329         outputs[i++] = output_data;
 330
 331         if (error)
 332                 *error = TDM_ERROR_NONE;
 333
 334         return outputs;
 335 failed_get:
 336         if (error)
 337                 *error = ret;
 338         return NULL;
 339 }
 340
 341 tdm_error
 342 virtual_display_get_fd(tdm_backend_data *bdata, int *fd)
 343 {
 344         tdm_virtual_data *virtual_data = bdata;
 345
 346         RETURN_VAL_IF_FAIL(virtual_data, TDM_ERROR_INVALID_PARAMETER);
 347         RETURN_VAL_IF_FAIL(fd, TDM_ERROR_INVALID_PARAMETER);
 348
 349         *fd = virtual_data->pipe[0];
 350
 351         return TDM_ERROR_NONE;
 352 }
 353
 354 tdm_error
 355 virtual_display_handle_events(tdm_backend_data *bdata)
 356 {
 357         return TDM_ERROR_NONE;
 358 }
 359
 360 tdm_output *
 361 virtual_display_output_create(tdm_backend_data *bdata, const char *name, tdm_error *error)
 362 {
 363         tdm_virtual_data *virtual_data = bdata;
 364         tdm_virtual_output_data *output_data = NULL;
 365         tdm_virtual_layer_data *layer_data = NULL;
 366         tdm_error ret;
 367
 368         if (!virtual_data || !name) {
 369                 TDM_ERR("invalid parameter");
 370                 *error = TDM_ERROR_INVALID_PARAMETER;
 371                 return NULL;
 372         }
 373
 374         output_data = calloc(1, sizeof(tdm_virtual_output_data));
 375         if (!output_data) {
 376                 TDM_ERR("alloc failed");
 377                 *error = TDM_ERROR_OUT_OF_MEMORY;
 378                 return NULL;
 379         }
 380
 381         LIST_INITHEAD(&output_data->layer_list);
 382
 383         output_data->virtual_data = virtual_data;
 384         output_data->pipe = 0;
 385         output_data->connector_type = TDM_OUTPUT_TYPE_Unknown;
 386         output_data->status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
 387
 388         if (name)
 389                 snprintf(output_data->name, TDM_NAME_LEN, "%s", name);
 390         else
 391                 snprintf(output_data->name, TDM_NAME_LEN, "unknown");
 392 #if 0
 393         output_data->output_mode = calloc(1, sizeof(tdm_output_mode));
 394         if (!output_data->output_mode) {
 395                 TDM_ERR("alloc failed");
 396                 ret = TDM_ERROR_OUT_OF_MEMORY;
 397                 goto create_fail;
 398         }
 399
 400         snprintf(output_data->output_mode->name, TDM_NAME_LEN, "640x480");
 401         output_data->output_mode->vrefresh = 30;
 402         output_data->output_mode->clock = 25200;
 403         output_data->output_mode->hdisplay = 640;
 404         output_data->output_mode->hsync_start = 656;
 405         output_data->output_mode->hsync_end = 752;
 406         output_data->output_mode->htotal = 800;
 407         output_data->output_mode->hskew = 0;
 408         output_data->output_mode->vdisplay = 480;
 409         output_data->output_mode->vsync_start = 490;
 410         output_data->output_mode->vsync_end = 492;
 411         output_data->output_mode->vtotal = 525;
 412         output_data->output_mode->vscan = 0;
 413         output_data->output_mode->flags = 0;
 414         output_data->output_mode->type = 0;
 415
 416         output_data->mode_count = 1;
 417 #endif
 418         output_data->timer = tdm_event_loop_add_timer_handler(virtual_data->dpy,
 419                                                                                                                   _tdm_virtual_display_cb_timeout,
 420                                                                                                                   output_data,
 421                                                                                                                   &ret);
 422         if (!output_data->timer) goto create_fail;
 423
 424         LIST_INITHEAD(&output_data->timer_event_list);
 425
 426         /* The TDM virtual backend output support only one layer. */
 427         layer_data = calloc(1, sizeof(tdm_virtual_layer_data));
 428         if (!layer_data) {
 429                 TDM_ERR("alloc failed");
 430                 ret = TDM_ERROR_OUT_OF_MEMORY;
 431                 goto create_fail;
 432         }
 433
 434         layer_data->virtual_data = virtual_data;
 435         layer_data->output_data = output_data;
 436         layer_data->zpos = 0;
 437
 438         layer_data->capabilities = TDM_LAYER_CAPABILITY_PRIMARY | TDM_LAYER_CAPABILITY_GRAPHIC;
 439         output_data->primary_layer = layer_data;
 440
 441         LIST_ADDTAIL(&layer_data->link, &output_data->layer_list);
 442
 443         ret = tdm_backend_register_output(virtual_data->dpy, output_data);
 444         GOTO_IF_FAIL(ret == TDM_ERROR_NONE, create_fail);
 445
 446         *error = TDM_ERROR_NONE;
 447
 448         return output_data;
 449
 450 create_fail:
 451         if (layer_data) free(layer_data);
 452         if (output_data->output_mode) free(output_data->output_mode);
 453         free(output_data);
 454
 455         *error = ret;
 456
 457         return NULL;
 458 }
 459
 460 tdm_error
 461 virtual_display_output_destroy(tdm_backend_data *bdata, tdm_output *output)
 462 {
 463         tdm_virtual_data *virtual_data = bdata;
 464         tdm_virtual_output_data *o, *output_data = output;
 465         int find = 0;
 466
 467         RETURN_VAL_IF_FAIL(virtual_data, TDM_ERROR_INVALID_PARAMETER);
 468         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 469
 470         LIST_FOR_EACH_ENTRY(o, &virtual_data->output_list, link) {
 471                 if (o == output_data) {
 472                         find = 1;
 473                         break;
 474                 }
 475         }
 476
 477         if (find)
 478                 tdm_backend_unregister_output(virtual_data->dpy, output);
 479         else
 480                 return TDM_ERROR_INVALID_PARAMETER;
 481
 482         return TDM_ERROR_NONE;
 483 }
 484
 485 tdm_error
 486 virtual_output_get_capability(tdm_output *output, tdm_caps_output *caps)
 487 {
 488         tdm_virtual_output_data *output_data = output;
 489         tdm_error ret;
 490
 491         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 492         RETURN_VAL_IF_FAIL(caps, TDM_ERROR_INVALID_PARAMETER);
 493
 494         memset(caps, 0, sizeof(tdm_caps_output));
 495
 496         snprintf(caps->maker, TDM_NAME_LEN, "virtual");
 497         snprintf(caps->model, TDM_NAME_LEN, "virtual");
 498         snprintf(caps->name, TDM_NAME_LEN, "%s", output_data->name);
 499
 500         caps->status = output_data->status;
 501         caps->type = output_data->connector_type;
 502         caps->type_id = 0;
 503
 504         caps->mode_count = output_data->mode_count;
 505         if (output_data->mode_count != 0) {
 506                 caps->modes = calloc(output_data->mode_count, sizeof(tdm_output_mode));
 507                 if (!caps->modes) {
 508                         ret = TDM_ERROR_OUT_OF_MEMORY;
 509                         TDM_ERR("alloc failed\n");
 510                         goto failed_get;
 511                 }
 512
 513                 *caps->modes = *output_data->output_mode;
 514         }
 515
 516         caps->mmWidth = output_data->mmwidth;
 517         caps->mmHeight =output_data->mmheight;
 518         caps->subpixel = 1;
 519
 520         caps->min_w = -1;
 521         caps->min_h = -1;
 522         caps->max_w = -1;
 523         caps->max_h = -1;
 524         caps->preferred_align = -1;
 525
 526         caps->prop_count = 0;
 527
 528         return TDM_ERROR_NONE;
 529 failed_get:
 530         memset(caps, 0, sizeof(tdm_caps_output));
 531         return ret;
 532 }
 533
 534 tdm_layer **
 535 virtual_output_get_layers(tdm_output *output,  int *count, tdm_error *error)
 536 {
 537         tdm_virtual_output_data *output_data = output;
 538         tdm_virtual_layer_data *layer_data = NULL;
 539         tdm_layer **layers;
 540         tdm_error ret;
 541         int i;
 542
 543         RETURN_VAL_IF_FAIL(output_data, NULL);
 544         RETURN_VAL_IF_FAIL(count, NULL);
 545
 546         *count = 0;
 547         LIST_FOR_EACH_ENTRY(layer_data, &output_data->layer_list, link)
 548         (*count)++;
 549
 550         if (*count == 0) {
 551                 ret = TDM_ERROR_NONE;
 552                 goto failed_get;
 553         }
 554
 555         /* will be freed in frontend */
 556         layers = calloc(*count, sizeof(tdm_virtual_layer_data *));
 557         if (!layers) {
 558                 TDM_ERR("failed: alloc memory");
 559                 *count = 0;
 560                 ret = TDM_ERROR_OUT_OF_MEMORY;
 561                 goto failed_get;
 562         }
 563
 564         i = 0;
 565         LIST_FOR_EACH_ENTRY(layer_data, &output_data->layer_list, link)
 566         layers[i++] = layer_data;
 567
 568         if (error)
 569                 *error = TDM_ERROR_NONE;
 570
 571         return layers;
 572 failed_get:
 573         if (error)
 574                 *error = ret;
 575         return NULL;
 576 }
 577
 578 tdm_error
 579 virtual_output_wait_vblank(tdm_output *output, int interval, int sync, void *user_data)
 580 {
 581         tdm_virtual_output_data *output_data = output;
 582         tdm_virtual_event_data *event_data;
 583         tdm_error ret;
 584
 585         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 586
 587         event_data = calloc(1, sizeof(tdm_virtual_event_data));
 588         if (!event_data) {
 589                 TDM_ERR("alloc failed");
 590                 return TDM_ERROR_OUT_OF_MEMORY;
 591         }
 592
 593         event_data->type = TDM_VIRTUAL_EVENT_TYPE_WAIT;
 594         event_data->output_data = output_data;
 595         event_data->user_data = user_data;
 596
 597         ret = _tdm_virtual_display_wait_vblank(output_data, interval, event_data);
 598         if (ret != TDM_ERROR_NONE) {
 599                 free(event_data);
 600                 return ret;
 601         }
 602
 603         return TDM_ERROR_NONE;
 604 }
 605
 606 tdm_error
 607 virtual_output_set_vblank_handler(tdm_output *output, tdm_output_vblank_handler func)
 608 {
 609         tdm_virtual_output_data *output_data = output;
 610
 611         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 612         RETURN_VAL_IF_FAIL(func, TDM_ERROR_INVALID_PARAMETER);
 613
 614         output_data->vblank_func = func;
 615
 616         return TDM_ERROR_NONE;
 617 }
 618
 619 tdm_error
 620 virtual_output_commit(tdm_output *output, int sync, void *user_data)
 621 {
 622         tdm_virtual_output_data *output_data = output;
 623         tdm_virtual_event_data *event_data;
 624         tdm_error ret;
 625
 626         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 627
 628         event_data = calloc(1, sizeof(tdm_virtual_event_data));
 629         if (!event_data) {
 630                 TDM_ERR("alloc failed");
 631                 return TDM_ERROR_OUT_OF_MEMORY;
 632         }
 633
 634         event_data->type = TDM_VIRTUAL_EVENT_TYPE_COMMIT;
 635         event_data->output_data = output_data;
 636         event_data->user_data = user_data;
 637
 638         ret = _tdm_virtual_display_wait_vblank(output_data, 1, event_data);
 639         if (ret != TDM_ERROR_NONE) {
 640                 free(event_data);
 641                 return ret;
 642         }
 643
 644         return TDM_ERROR_NONE;
 645 }
 646
 647 tdm_error
 648 virtual_output_set_commit_handler(tdm_output *output, tdm_output_commit_handler func)
 649 {
 650         tdm_virtual_output_data *output_data = output;
 651
 652         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 653         RETURN_VAL_IF_FAIL(func, TDM_ERROR_INVALID_PARAMETER);
 654
 655         output_data->commit_func = func;
 656
 657         return TDM_ERROR_NONE;
 658 }
 659
 660 tdm_error
 661 virtual_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 662 {
 663         tdm_virtual_output_data *output_data = output;
 664
 665         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 666         RETURN_VAL_IF_FAIL(mode, TDM_ERROR_INVALID_PARAMETER);
 667
 668         output_data->current_mode = mode;
 669         output_data->mode_changed = 1;
 670
 671         return TDM_ERROR_NONE;
 672 }
 673
 674 tdm_error
 675 virtual_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
 676 {
 677         tdm_virtual_output_data *output_data = output;
 678
 679         RETURN_VAL_IF_FAIL(output_data, TDM_ERROR_INVALID_PARAMETER);
 680         RETURN_VAL_IF_FAIL(mode, TDM_ERROR_INVALID_PARAMETER);
 681
 682         *mode = output_data->current_mode;
 683
 684         return TDM_ERROR_NONE;
 685 }
 686
 687 tdm_error
 688 virtual_layer_get_capability(tdm_layer *layer, tdm_caps_layer *caps)
 689 {
 690         tdm_virtual_layer_data *layer_data = layer;
 691
 692         RETURN_VAL_IF_FAIL(layer_data, TDM_ERROR_INVALID_PARAMETER);
 693         RETURN_VAL_IF_FAIL(caps, TDM_ERROR_INVALID_PARAMETER);
 694
 695         memset(caps, 0, sizeof(tdm_caps_layer));
 696
 697         caps->capabilities = layer_data->capabilities;
 698         caps->zpos = layer_data->zpos;
 699
 700         caps->format_count = 2;
 701         caps->formats = calloc(caps->format_count, sizeof(tbm_format));
 702         if (!caps->formats) {
 703                 TDM_ERR("alloc failed\n");
 704                 free(caps->formats);
 705                 memset(caps, 0, sizeof(tdm_caps_layer));
 706                 return TDM_ERROR_OUT_OF_MEMORY;
 707         }
 708
 709         caps->formats[0] = TBM_FORMAT_ARGB8888;
 710         caps->formats[1] = TBM_FORMAT_XRGB8888;
 711
 712         caps->prop_count = 0;
 713
 714         return TDM_ERROR_NONE;
 715 }
 716
 717 tdm_error
 718 virtual_layer_set_info(tdm_layer *layer, tdm_info_layer *info)
 719 {
 720         tdm_virtual_layer_data *layer_data = layer;
 721
 722         RETURN_VAL_IF_FAIL(layer_data, TDM_ERROR_INVALID_PARAMETER);
 723         RETURN_VAL_IF_FAIL(info, TDM_ERROR_INVALID_PARAMETER);
 724
 725         layer_data->info = *info;
 726         layer_data->info_changed = 1;
 727
 728         return TDM_ERROR_NONE;
 729 }
 730
 731 tdm_error
 732 virtual_layer_get_info(tdm_layer *layer, tdm_info_layer *info)
 733 {
 734         tdm_virtual_layer_data *layer_data = layer;
 735
 736         RETURN_VAL_IF_FAIL(layer_data, TDM_ERROR_INVALID_PARAMETER);
 737         RETURN_VAL_IF_FAIL(info, TDM_ERROR_INVALID_PARAMETER);
 738
 739         *info = layer_data->info;
 740
 741         return TDM_ERROR_NONE;
 742 }
 743
 744 tdm_error
 745 virtual_layer_set_buffer(tdm_layer *layer, tbm_surface_h buffer)
 746 {
 747         tdm_virtual_layer_data *layer_data = layer;
 748
 749         RETURN_VAL_IF_FAIL(layer_data, TDM_ERROR_INVALID_PARAMETER);
 750         RETURN_VAL_IF_FAIL(buffer, TDM_ERROR_INVALID_PARAMETER);
 751
 752         layer_data->display_buffer = buffer;
 753         layer_data->display_buffer_changed = 1;
 754
 755         return TDM_ERROR_NONE;
 756 }
 757
 758 tdm_error
 759 virtual_layer_unset_buffer(tdm_layer *layer)
 760 {
 761         tdm_virtual_layer_data *layer_data = layer;
 762
 763         RETURN_VAL_IF_FAIL(layer_data, TDM_ERROR_INVALID_PARAMETER);
 764
 765         layer_data->display_buffer = NULL;
 766         layer_data->display_buffer_changed = 1;
 767
 768         return TDM_ERROR_NONE;
 769 }