tools: fix syntax error
[platform/core/uifw/libtdm.git] / tools / tdm_test_server.c
1 /**************************************************************************
2  *
3  * libtdm
4  *
5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
6  *
7  * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8  *          JinYoung Jeon <jy0.jeon@samsung.com>,
9  *          Taeheon Kim <th908.kim@samsung.com>,
10  *          YoungJun Cho <yj44.cho@samsung.com>,
11  *          SooChan Lim <sc1.lim@samsung.com>,
12  *          Boram Park <sc1.lim@samsung.com>
13  *
14  * Permission is hereby granted, free of charge, to any person obtaining a
15  * copy of this software and associated documentation files (the
16  * "Software"), to deal in the Software without restriction, including
17  * without limitation the rights to use, copy, modify, merge, publish,
18  * distribute, sub license, and/or sell copies of the Software, and to
19  * permit persons to whom the Software is furnished to do so, subject to
20  * the following conditions:
21  *
22  * The above copyright notice and this permission notice (including the
23  * next paragraph) shall be included in all copies or substantial portions
24  * of the Software.
25  *
26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
33  *
34 **************************************************************************/
35
36 #include <stdio.h>
37 #include <string.h>
38 #include <stdlib.h>
39 #include <signal.h>
40 #include <poll.h>
41 #include <errno.h>
42 #include <time.h>
43 #include <stdint.h>
44
45 #include <tbm_surface.h>
46 #include <tbm_surface_internal.h>
47
48 #include <tdm.h>
49 #include <tdm_log.h>
50 #include <tdm_list.h>
51 #include <tdm_helper.h>
52 #include <tdm_backend.h>
53
54 #include "tdm_macro.h"
55 #include "tdm_private.h"
56 #include "buffers.h"
57
58 ////////////////////////////////////////////////////////////////////////////////
59 struct typestrings {
60         int type;
61         const char *string;
62         const char *desc;
63 };
64
65 struct optstrings {
66         int  type;
67         const char *opt;
68         const char *desc;
69         const char *arg;
70         const char *ex;
71 };
72
73 enum {
74         OPT_QRY,
75         OPT_TST,
76         OPT_GEN,
77 };
78
79 static struct typestrings typestrs[] = {
80         {OPT_QRY, "Query",          NULL},
81         {OPT_TST, "Test",           NULL},
82         {OPT_GEN, "General",        NULL},
83 };
84
85 static struct optstrings optstrs[] = {
86         {
87                 OPT_QRY, "q", "show tdm output, layer information",
88                 NULL, NULL
89         },
90         {
91                 OPT_TST, "a", "set all layer objects for all connected outputs",
92                 NULL, NULL
93         },
94         {
95                 OPT_TST, "o", "set a mode for a output object",
96                 "<output_idx>@<mode>[&<refresh>]", "0@1920x1080"
97         },
98         {
99                 OPT_TST, "l", "set a layer object",
100                 "<layer_idx>[:<w>x<h>[+<x>+<y>][,<h>x<v>][@<format>]]~<w>x<h>[+<x>+<y>][*<transform>]", NULL
101         },
102         {
103                 OPT_TST, "p", "set a PP object.\n\t\t'-l' is used to show the result on screen.",
104                 "<w>x<h>[+<x>+<y>][,<h>x<v>][@<format>]~<w>x<h>[+<x>+<y>][,<h>x<v>][@<format>][*<transform>][&<fps>]", NULL
105         },
106         {
107                 OPT_TST, "c", "catpure a output object or a layer object.\n\t\t'-l' is used to show the result on screen.",
108                 "<output_idx>[,<layer_idx>]~<w>x<h>[+<x>+<y>][,<h>x<v>][@<format>][*<transform>][^stream]", NULL
109         },
110         {
111                 OPT_GEN, "w", "set the property of a object",
112                 "<prop_name>:<value>", NULL
113         },
114         {
115                 OPT_GEN, "b", "set the fill(smtpe,tiles,plain) and framebuffer type(scanout,noncachable,wc)",
116                 "<fill>[:<buf_flag>[,<buf_flag2>[,...]]]", NULL
117         },
118         {
119                 OPT_GEN, "v", "update layers every vblank",
120                 NULL, NULL
121         },
122 };
123
124 struct usagestring {
125         const char *string;
126         const char *desc;
127 };
128
129 static struct usagestring usages[] = {
130         {
131                 "-q",
132                 NULL
133         },
134         {
135                 "-a -b plain",
136                 "test all outputs, layers with plain buffers"
137         },
138         {
139                 "-o 0@1920x1080",
140                 "Set the \"1920x1080\" mode to the output 0. And show a buffer via a primary layer of the output 0"
141         },
142         {
143                 "-o 0@1920x1080 -l 1~640x480+50+100",
144                 "Create the 640x480 buffer and show it in the (50,100) pos of screen via the layer 1"
145         },
146         {
147                 "-p 320x240@NV12~480x360+80+40,640x480@AR24 -l 1~640x480+50+100",
148                 "Convert the 320x240@NV12 buffer to the 640x480@AR24 buffer(480x360+80+40) and show the result via the layer 1"
149         },
150 };
151
152 static void
153 usage(char *app_name)
154 {
155         int type_size = sizeof(typestrs) / sizeof(struct typestrings);
156         int opt_size = sizeof(optstrs) / sizeof(struct optstrings);
157         int usages_size = sizeof(usages) / sizeof(struct usagestring);
158         int t;
159
160         printf("usage: %s \n\n", app_name);
161
162         for (t = 0; t < type_size; t++) {
163                 int o, f = 1;
164
165                 for (o = 0; o < opt_size; o++)
166                         if (optstrs[o].type == typestrs[t].type) {
167                                 if (f == 1)
168                                         printf(" %s options: %s\n\n", typestrs[t].string, (typestrs[t].desc) ? : "");
169                                 printf("\t-%s\t%s\n", optstrs[o].opt, optstrs[o].desc);
170                                 if (optstrs[o].arg)
171                                         printf("\t\t  %s\n", optstrs[o].arg);
172                                 if (optstrs[o].ex)
173                                         printf("\t\t  ex) %s\n", optstrs[o].ex);
174                                 f = 0;
175                         }
176                 printf("\n");
177         }
178
179         printf(" For example)\n\n");
180
181         for (t = 0; t < usages_size; t++) {
182                 printf("    $ %s %s\n", app_name, usages[t].string);
183                 printf("\t%s\n", usages[t].desc);
184         }
185         printf("\n");
186         exit(0);
187 }
188
189 ////////////////////////////////////////////////////////////////////////////////
190
191 static const char *tdm_buf_flag_names[] = {
192         "scanout",
193         "noncachable",
194         "wc",
195 };
196 TDM_BIT_NAME_FB(buf_flag)
197
198 #define DEFAULT_FORMAT  TBM_FORMAT_ARGB8888
199
200 #define print_size(s) \
201         printf("%dx%d", (s)->h, (s)->v)
202 #define print_pos(p) \
203         printf("%dx%d+%d+%d", (p)->w, (p)->h, (p)->x, (p)->y)
204 #define print_format(f) \
205         if (f) printf("%c%c%c%c", FOURCC_STR(f)); \
206         else printf("NONE")
207 #define print_config(c) \
208         do { \
209                 print_size(&(c)->size); \
210                 printf(" "); \
211                 print_pos(&(c)->pos); \
212                 printf(" "); \
213                 print_format((c)->format); \
214         } while (0)
215 #define print_prop(w) \
216         printf("%s(%d)", (w)->name, ((w)->value).u32)
217
218 typedef struct _tdm_test_server tdm_test_server;
219 typedef struct _tdm_test_server_layer tdm_test_server_layer;
220 typedef struct _tdm_test_server_capture tdm_test_server_capture;
221
222 typedef struct _tdm_test_server_prop {
223         /* args */
224         char name[TDM_NAME_LEN];
225         tdm_value value;
226
227         /* variables for test */
228         struct list_head link;
229 } tdm_test_server_prop;
230
231 typedef struct _tdm_test_server_buffer {
232         /* variables for test */
233         tbm_surface_h b;
234         int in_use;
235         tdm_test_server_layer *l;
236
237         tdm_test_server_capture *c;
238         tdm_buffer_release_handler done;
239 } tdm_test_server_buffer;
240
241 typedef struct _tdm_test_server_output {
242         /* args */
243         int idx;
244         char mode[TDM_NAME_LEN];
245         int refresh;
246
247         /* variables for test */
248         struct list_head link;
249         struct list_head prop_list;
250         struct list_head layer_list;
251         tdm_test_server *data;
252         tdm_output *output;
253
254         int fill_primary_layer;
255 } tdm_test_server_output;
256
257 typedef struct _tdm_test_server_pp {
258         /* args */
259         tdm_info_pp info;
260         int fps;
261
262         /* variables for test */
263         struct list_head link;
264         tdm_test_server *data;
265         tdm_test_server_layer *l;
266         tdm_pp *pp;
267         tbm_surface_h bufs[6];
268         int buf_idx;
269
270         tdm_event_loop_source *timer_source;
271 } tdm_test_server_pp;
272
273 struct _tdm_test_server_capture {
274         /* args */
275         int output_idx;
276         int layer_idx;
277         tdm_info_capture info;
278
279         /* variables for test */
280         struct list_head link;
281         tdm_test_server *data;
282         tdm_test_server_layer *l;
283         tdm_capture *capture;
284 };
285
286 struct _tdm_test_server_layer {
287         /* args */
288         int idx;
289         tdm_info_layer info;
290
291         /* variables for test */
292         struct list_head link;
293         struct list_head prop_list;
294         tdm_test_server *data;
295         tdm_test_server_output *o;
296         tdm_layer *layer;
297         int is_primary;
298         tdm_test_server_pp *owner_p;
299         tdm_test_server_capture *owner_c;
300         tbm_surface_h bufs[3];
301         int buf_idx;
302 };
303
304 struct _tdm_test_server {
305         /* args */
306         int do_query;
307         int do_all;
308         int do_vblank;
309         int bflags;
310         int b_fill;
311
312         /* variables for test */
313         struct list_head output_list;
314         struct list_head pp_list;
315         struct list_head capture_list;
316         tdm_display *display;
317 };
318
319 static void run_test(tdm_test_server *data);
320 static void output_setup(tdm_test_server_output *o);
321 static void layer_show_buffer(tdm_test_server_layer *l, tbm_surface_h b);
322 static void capture_attach(tdm_test_server_capture *c, tbm_surface_h b);
323
324 static char*
325 parse_size(tdm_size *size, char *arg)
326 {
327         char *end;
328         size->h = strtol(arg, &end, 10);
329         TDM_EXIT_IF_FAIL(*end == 'x');
330         arg = end + 1;
331         size->v = strtol(arg, &end, 10);
332         return end;
333 }
334
335 static char*
336 parse_pos(tdm_pos *pos, char *arg)
337 {
338         char *end;
339         pos->w = strtol(arg, &end, 10);
340         TDM_EXIT_IF_FAIL(*end == 'x');
341         arg = end + 1;
342         pos->h = strtol(arg, &end, 10);
343         if (*end == '+') {
344                 arg = end + 1;
345                 pos->x = strtol(arg, &end, 10);
346                 TDM_EXIT_IF_FAIL(*end == '+');
347                 arg = end + 1;
348                 pos->y = strtol(arg, &end, 10);
349         }
350         return end;
351 }
352
353 static char*
354 parse_config(tdm_info_config *config, char *arg)
355 {
356         char *end;
357         end = parse_pos(&config->pos, arg);
358         if (*end == ',') {
359                 arg = end + 1;
360                 end = parse_size(&config->size, arg);
361         }
362         if (*end == '@') {
363                 char temp[32];
364                 arg = end + 1;
365                 end = strtostr(temp, 32, arg, TDM_DELIM);
366                 config->format = FOURCC_ID(temp);
367         }
368         return end;
369 }
370
371 static void
372 parse_arg_o(tdm_test_server_output *o, char *arg)
373 {
374         char *end;
375         TDM_EXIT_IF_FAIL(arg != NULL);
376         o->idx = strtol(arg, &end, 10);
377         TDM_EXIT_IF_FAIL(*end == '@');
378         arg = end + 1;
379         end = strtostr(o->mode, TDM_NAME_LEN, arg, TDM_DELIM);
380         if (*end == ',') {
381                 arg = end + 1;
382                 o->refresh = strtol(arg, &end, 10);
383         }
384 }
385
386 static void
387 parse_arg_p(tdm_test_server_pp *p, char *arg)
388 {
389         tdm_info_pp *pp_info = &p->info;
390         char *end;
391         TDM_EXIT_IF_FAIL(arg != NULL);
392         end = parse_config(&pp_info->src_config, arg);
393         TDM_EXIT_IF_FAIL(*end == '~');
394         arg = end + 1;
395         end = parse_config(&pp_info->dst_config, arg);
396         if (*end == '*') {
397                 arg = end + 1;
398                 pp_info->transform = strtol(arg, &end, 10);
399         }
400         if (*end == '&') {
401                 arg = end + 1;
402                 p->fps = strtol(arg, &end, 10);
403         }
404 }
405
406 static void
407 parse_arg_c(tdm_test_server_capture *c, char *arg)
408 {
409         tdm_info_capture *capture_info = &c->info;
410         char *end;
411         TDM_EXIT_IF_FAIL(arg != NULL);
412         c->output_idx = strtol(arg, &end, 10);
413         if (*end == ',') {
414                 arg = end + 1;
415                 c->layer_idx = strtol(arg, &end, 10);
416         }
417         TDM_EXIT_IF_FAIL(*end == '~');
418         arg = end + 1;
419         end = parse_config(&capture_info->dst_config, arg);
420         if (*end == '*') {
421                 arg = end + 1;
422                 capture_info->transform = strtol(arg, &end, 10);
423         }
424         if (*end == '^') {
425                 arg = end + 1;
426                 if (strtol(arg, &end, 10) > 0)
427                         capture_info->type = TDM_CAPTURE_TYPE_STREAM;
428                 else
429                         capture_info->type = TDM_CAPTURE_TYPE_ONESHOT;
430         }
431 }
432
433 static void
434 parse_arg_l(tdm_test_server_layer *l, char *arg)
435 {
436         tdm_info_layer *layer_info = &l->info;
437         char *end;
438         TDM_EXIT_IF_FAIL(arg != NULL);
439         l->idx = strtol(arg, &end, 10);
440         if (*end == ':') {
441                 arg = end + 1;
442                 end = parse_config(&layer_info->src_config, arg);
443         }
444         TDM_EXIT_IF_FAIL(*end == '~');
445         arg = end + 1;
446         end = parse_pos(&layer_info->dst_pos, arg);
447         if (*end == '*') {
448                 arg = end + 1;
449                 layer_info->transform = strtol(arg, &end, 10);
450         }
451 }
452
453 static void
454 parse_arg_w(tdm_test_server_prop *w, char *arg)
455 {
456         char *end;
457         TDM_EXIT_IF_FAIL(arg != NULL);
458         end = strtostr(w->name, TDM_PATH_LEN, arg, TDM_DELIM);
459         TDM_EXIT_IF_FAIL(*end == ':');
460         arg = end + 1;
461         w->value.u32 = strtol(arg, &end, 10);
462 }
463
464 static void
465 parse_arg_b(tdm_test_server *data, char *arg)
466 {
467         char *end = arg;
468         char temp[TDM_NAME_LEN] = {0,};
469         TDM_EXIT_IF_FAIL(arg != NULL);
470
471         end = strtostr(temp, 32, arg, TDM_DELIM);
472         if (!strncmp(temp, "smpte", 5))
473                 data->b_fill = PATTERN_SMPTE;
474         else if (!strncmp(temp, "tiles", 5))
475                 data->b_fill = PATTERN_TILES;
476         else if (!strncmp(temp, "plain", 5))
477                 data->b_fill = PATTERN_PLAIN;
478         else {
479                 printf("'%s': unknown flag\n", temp);
480                 exit(0);
481         }
482
483         if (*arg == ':') {
484                 data->bflags = 0;
485                 arg = end + 1;
486                 snprintf(temp, TDM_NAME_LEN, "%s", arg);
487                 arg = strtok_r(temp, ",", &end);
488                 while (arg) {
489                         if (!strncmp(arg, "default", 7))
490                                 printf("Ignore '%s' flag\n", arg);
491                         else if (!strncmp(arg, "scanout", 7))
492                                 data->bflags |= TBM_BO_SCANOUT;
493                         else if (!strncmp(arg, "noncachable", 11))
494                                 data->bflags |= TBM_BO_NONCACHABLE;
495                         else if (!strncmp(arg, "wc", 2))
496                                 data->bflags |= TBM_BO_WC;
497                         else {
498                                 printf("'%s': unknown flag\n", arg);
499                                 exit(0);
500                         }
501                         arg = strtok_r(NULL, ",", &end);
502                 }
503         }
504 }
505
506 static void
507 parse_args(tdm_test_server *data, int argc, char *argv[])
508 {
509         tdm_test_server_output *o = NULL;
510         tdm_test_server_layer *l = NULL;
511         tdm_test_server_pp *p = NULL;
512         tdm_test_server_capture *c = NULL;
513         tdm_test_server_prop *w = NULL;
514         void *last_option = NULL;
515         void *last_object = NULL;
516         int i;
517
518         if (argc < 2) {
519                 usage(argv[0]);
520                 exit(0);
521         }
522
523         for (i = 1; i < argc; i++) {
524                 if (!strncmp(argv[i] + 1, "q", 1)) {
525                         data->do_query = 1;
526                         return;
527                 } else if (!strncmp(argv[i] + 1, "a", 1)) {
528                         data->do_all = 1;
529                 } else if (!strncmp(argv[i] + 1, "o", 1)) {
530                         TDM_GOTO_IF_FAIL(data->do_all == 0, all);
531                         o = calloc(1, sizeof * o);
532                         TDM_EXIT_IF_FAIL(o != NULL);
533                         o->data = data;
534                         LIST_INITHEAD(&o->layer_list);
535                         LIST_INITHEAD(&o->prop_list);
536                         LIST_ADDTAIL(&o->link, &data->output_list);
537                         parse_arg_o(o, argv[++i]);
538                         last_object = o;
539                 } else if (!strncmp(argv[i] + 1, "p", 1)) {
540                         TDM_GOTO_IF_FAIL(data->do_all == 0, all);
541                         p = calloc(1, sizeof * p);
542                         TDM_EXIT_IF_FAIL(p != NULL);
543                         p->data = data;
544                         p->fps = 30;   /* default 30 fps */
545                         LIST_ADDTAIL(&p->link, &data->pp_list);
546                         parse_arg_p(p, argv[++i]);
547                         last_option = p;
548                 } else if (!strncmp(argv[i] + 1, "c", 1)) {
549                         TDM_GOTO_IF_FAIL(data->do_all == 0, all);
550                         c = calloc(1, sizeof * c);
551                         TDM_EXIT_IF_FAIL(c != NULL);
552                         c->data = data;
553                         c->output_idx = -1;
554                         c->layer_idx = -1;
555                         LIST_ADDTAIL(&c->link, &data->capture_list);
556                         parse_arg_c(c, argv[++i]);
557                         last_option = c;
558                 } else if (!strncmp(argv[i] + 1, "l", 1)) {
559                         TDM_GOTO_IF_FAIL(data->do_all == 0, all);
560                         if (!o) {
561                                 o = calloc(1, sizeof * o);
562                                 TDM_EXIT_IF_FAIL(o != NULL);
563                                 o->data = data;
564                                 LIST_INITHEAD(&o->layer_list);
565                                 LIST_INITHEAD(&o->prop_list);
566                                 LIST_ADDTAIL(&o->link, &data->output_list);
567                         }
568                         l = calloc(1, sizeof * l);
569                         TDM_EXIT_IF_FAIL(l != NULL);
570                         LIST_INITHEAD(&l->prop_list);
571                         LIST_ADDTAIL(&l->link, &o->layer_list);
572                         l->data = data;
573                         l->o = o;
574                         parse_arg_l(l, argv[++i]);
575                         if (p && last_option == p) {
576                                 p->l = l;
577                                 l->owner_p = p;
578                         } else if (c && last_option == c) {
579                                 c->l = l;
580                                 l->owner_c = c;
581                         }
582                         last_object = l;
583                 } else if (!strncmp(argv[i] + 1, "w", 1)) {
584                         TDM_GOTO_IF_FAIL(data->do_all == 0, all);
585                         if (!last_object)
586                                 goto no_object;
587                         w = calloc(1, sizeof * w);
588                         TDM_EXIT_IF_FAIL(w != NULL);
589                         if (o && last_object == o)
590                                 LIST_ADDTAIL(&w->link, &o->prop_list);
591                         else if (l && last_object == l)
592                                 LIST_ADDTAIL(&w->link, &l->prop_list);
593                         parse_arg_w(w, argv[++i]);
594                 } else if (!strncmp(argv[i] + 1, "b", 1)) {
595                         parse_arg_b(data, argv[++i]);
596                 } else if (!strncmp(argv[i] + 1, "v", 1)) {
597                         data->do_vblank = 1;
598                 } else {
599                         usage(argv[0]);
600                         exit(0);
601                 }
602         }
603
604         LIST_FOR_EACH_ENTRY(p, &data->pp_list, link) {
605                 if (!p->l)
606                         goto no_layer;
607         }
608         LIST_FOR_EACH_ENTRY(c, &data->capture_list, link) {
609                 if (!c->l)
610                         goto no_layer;
611         }
612
613         return;
614 no_layer:
615         printf("Use '-l' to set a layer for '-p' or '-c'.\n");
616         exit(0);
617 no_object:
618         printf("Use '-o' or '-l' to set a object first.\n");
619         exit(0);
620 all:
621         printf("Can't use '-%s' with '-a'.\n", argv[i] + 1);
622         exit(0);
623 }
624
625 static void
626 interpret_args(tdm_test_server *data)
627 {
628         tdm_test_server_output *o = NULL;
629         tdm_test_server_layer *l = NULL;
630         tdm_error ret;
631
632         /* create the objects of outputs */
633         if (data->do_all) {
634                 int i, output_count;
635
636                 ret = tdm_display_get_output_count(data->display, &output_count);
637                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
638
639                 for (i = 0; i < output_count; i++) {
640                         tdm_output *output = tdm_display_get_output(data->display, i, NULL);
641                         tdm_output_conn_status status;
642                         tdm_output_get_conn_status(output, &status);
643                         if (status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
644                                 continue;
645                         o = calloc(1, sizeof * o);
646                         TDM_EXIT_IF_FAIL(o != NULL);
647                         o->data = data;
648                         LIST_INITHEAD(&o->layer_list);
649                         LIST_INITHEAD(&o->prop_list);
650                         LIST_ADDTAIL(&o->link, &data->output_list);
651                         o->idx = i;
652                         o->fill_primary_layer = 1;
653                 }
654         }
655
656         /* check if the primary layer object exists */
657         LIST_FOR_EACH_ENTRY(o, &data->output_list, link) {
658                 tdm_output *output;
659                 const tdm_output_mode *mode;
660                 int j, layer_count, primary_index = 0;
661                 tdm_test_server_layer *primary_l = NULL;
662
663                 output_setup(o);
664
665                 output = tdm_display_get_output(data->display, o->idx, &ret);
666                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
667                 ret = tdm_output_get_mode(output, &mode);
668                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
669                 ret = tdm_output_get_layer_count(output, &layer_count);
670                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
671                 ret = tdm_output_get_primary_index(output, &primary_index);
672                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
673
674                 if (LIST_IS_EMPTY(&o->layer_list))
675                         o->fill_primary_layer = 1;
676                 else {
677                         LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
678                                 if (l->idx == primary_index) {
679                                         l->is_primary = 1;
680                                         o->fill_primary_layer = 1;
681                                         primary_l = l;
682                                         break;
683                                 }
684                         }
685                 }
686
687                 if (!primary_l || data->do_all) {
688                         for (j = 0; j < layer_count; j++) {
689                                 if (j != primary_index && !data->do_all)
690                                         continue;
691                                 l = calloc(1, sizeof * l);
692                                 TDM_EXIT_IF_FAIL(l != NULL);
693                                 LIST_INITHEAD(&l->prop_list);
694                                 LIST_ADDTAIL(&l->link, &o->layer_list);
695                                 l->data = data;
696                                 l->o = o;
697                                 l->idx = j;
698                                 if (j == primary_index) {
699                                         l->is_primary = 1;
700                                         l->info.dst_pos.w = mode->hdisplay;
701                                         l->info.dst_pos.h = mode->vdisplay;
702                                         primary_l = l;
703                                 } else {
704                                         l->info.dst_pos.w = TDM_ALIGN(mode->hdisplay / 3, 2);
705                                         l->info.dst_pos.h = TDM_ALIGN(mode->vdisplay / 3, 2);
706                                         l->info.dst_pos.x = TDM_ALIGN(((mode->hdisplay / 3) / layer_count) * j, 2);
707                                         l->info.dst_pos.y = TDM_ALIGN(((mode->vdisplay / 3) / layer_count) * j, 2);
708                                 }
709                         }
710                 }
711
712                 TDM_EXIT_IF_FAIL(primary_l != NULL);
713                 LIST_DEL(&primary_l->link);
714                 LIST_ADD(&primary_l->link, &o->layer_list);
715         }
716
717         /* fill the empty information of layers */
718         LIST_FOR_EACH_ENTRY(o, &data->output_list, link) {
719                 tdm_output *output;
720                 int minw, minh, maxw, maxh;
721
722                 output = tdm_display_get_output(data->display, o->idx, &ret);
723                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
724                 ret = tdm_output_get_available_size(output, &minw, &minh, &maxw, &maxh, NULL);
725                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
726
727                 /* l->info.src_config.size will be decided when a buffer shows really */
728                 LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
729                         if (minw > 0 && minh > 0) {
730                                 TDM_EXIT_IF_FAIL(l->info.dst_pos.w >= minw);
731                                 TDM_EXIT_IF_FAIL(l->info.dst_pos.h >= minh);
732                         }
733                         if (maxw > 0 && maxh > 0) {
734                                 TDM_EXIT_IF_FAIL(l->info.dst_pos.w <= maxw);
735                                 TDM_EXIT_IF_FAIL(l->info.dst_pos.h <= maxh);
736                         }
737
738                         if (l->owner_p) {
739                                 l->info.src_config.format = l->owner_p->info.dst_config.format;
740                                 if (l->info.src_config.pos.w == 0) {
741                                         TDM_EXIT_IF_FAIL(l->owner_p->info.dst_config.size.h > 0);
742                                         l->info.src_config.pos.w = l->owner_p->info.dst_config.size.h;
743                                         l->info.src_config.pos.h = l->owner_p->info.dst_config.size.v;
744                                 }
745                         } else if (l->owner_c) {
746                                 l->info.src_config.format = l->owner_c->info.dst_config.format;
747                                 if (l->info.src_config.pos.w == 0) {
748                                         TDM_EXIT_IF_FAIL(l->owner_c->info.dst_config.size.h > 0);
749                                         l->info.src_config.pos.w = l->owner_c->info.dst_config.size.h;
750                                         l->info.src_config.pos.h = l->owner_c->info.dst_config.size.v;
751                                 }
752                         } else {
753                                 if (l->info.src_config.pos.w == 0) {
754                                         TDM_EXIT_IF_FAIL(l->info.dst_pos.w > 0);
755                                         l->info.src_config.pos.w = l->info.dst_pos.w;
756                                         l->info.src_config.pos.h = l->info.dst_pos.h;
757                                 }
758                         }
759                 }
760         }
761 }
762
763 static tdm_test_server tts_data;
764 static int tts_buffer_key;
765 #define TTS_BUFFER_KEY ((unsigned long)&tts_buffer_key)
766
767 static tbm_surface_h
768 buffer_allocate(int width, int height, int format, int flags)
769 {
770         tdm_test_server_buffer *tb = calloc(1, sizeof *tb);
771         TDM_EXIT_IF_FAIL(tb != NULL);
772         tb->b = tbm_surface_internal_create_with_flags(width, height, format, flags);
773         TDM_EXIT_IF_FAIL(tb->b != NULL);
774         tdm_helper_clear_buffer(tb->b);
775         tbm_surface_internal_add_user_data(tb->b, TTS_BUFFER_KEY, free);
776         tbm_surface_internal_set_user_data(tb->b, TTS_BUFFER_KEY, tb);
777         return tb->b;
778 }
779
780 static tdm_test_server_buffer*
781 get_tts_buffer(tbm_surface_h b)
782 {
783         tdm_test_server_buffer *tb = NULL;
784         tbm_surface_internal_get_user_data(b, TTS_BUFFER_KEY, (void **)&tb);
785         return tb;
786 }
787
788 static void
789 destroy(tdm_test_server *data)
790 {
791         tdm_test_server_output *o = NULL, *oo = NULL;
792         tdm_test_server_layer *l = NULL, *ll = NULL;
793         tdm_test_server_pp *p = NULL, *pp = NULL;
794         tdm_test_server_capture *c = NULL, *cc = NULL;
795         tdm_test_server_prop *w = NULL, *ww = NULL;
796         int i;
797
798         LIST_FOR_EACH_ENTRY_SAFE(c, cc, &data->capture_list, link) {
799                 LIST_DEL(&c->link);
800                 tdm_capture_destroy(c->capture);
801                 free(c);
802         }
803
804         LIST_FOR_EACH_ENTRY_SAFE(p, pp, &data->pp_list, link) {
805                 tdm_display_lock(data->display);
806                 tdm_event_loop_source_remove(p->timer_source);
807                 tdm_display_unlock(data->display);
808
809                 tdm_pp_destroy(p->pp);
810         }
811
812         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &data->output_list, link) {
813                 LIST_FOR_EACH_ENTRY_SAFE(l, ll, &o->layer_list, link) {
814                         tdm_layer_unset_buffer(l->layer);
815                 }
816                 tdm_layer_commit(l->layer, NULL, NULL);
817         }
818
819         LIST_FOR_EACH_ENTRY_SAFE(p, pp, &data->pp_list, link) {
820                 LIST_DEL(&p->link);
821                 for (i = 0; i < TDM_ARRAY_SIZE(p->bufs); i++)
822                         tbm_surface_destroy(p->bufs[i]);
823                 free(p);
824         }
825
826         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &data->output_list, link) {
827                 LIST_DEL(&o->link);
828                 LIST_FOR_EACH_ENTRY_SAFE(l, ll, &o->layer_list, link) {
829                         LIST_DEL(&l->link);
830                         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &l->prop_list, link) {
831                                 LIST_DEL(&w->link);
832                                 free(w);
833                         }
834                         for (i = 0; i < TDM_ARRAY_SIZE(l->bufs); i++)
835                                 tbm_surface_destroy(l->bufs[i]);
836                         free(l);
837                 }
838                 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &o->prop_list, link) {
839                         LIST_DEL(&w->link);
840                         free(w);
841                 }
842
843                 free(o);
844         }
845
846         if (data->display)
847                 tdm_display_deinit(data->display);
848
849         exit(0);
850 }
851
852 int
853 main(int argc, char *argv[])
854 {
855         tdm_test_server *data = &tts_data;
856         char temp[TDM_SERVER_REPLY_MSG_LEN];
857         int len = sizeof temp;
858         tdm_error ret;
859
860 #if 1 /* for testing */
861         const char *s = (const char*)getenv("XDG_RUNTIME_DIR");
862         if (!s) {
863                 char buf[32];
864                 snprintf(buf, sizeof(buf), "/run");
865                 int ret = setenv("XDG_RUNTIME_DIR", (const char*)buf, 1);
866                 if (ret != 0)
867                         exit(0);
868         }
869
870         s = (const char*)getenv("TBM_DISPLAY_SERVER");
871         if (!s) {
872                 char buf[32];
873                 snprintf(buf, sizeof(buf), "1");
874                 int ret = setenv("TBM_DISPLAY_SERVER", (const char*)buf, 1);
875                 if (ret != 0)
876                         exit(0);
877         }
878 #endif
879
880         memset(data, 0, sizeof * data);
881         LIST_INITHEAD(&data->output_list);
882         LIST_INITHEAD(&data->pp_list);
883         LIST_INITHEAD(&data->capture_list);
884
885         /* init value */
886         data->bflags = TBM_BO_SCANOUT;
887         data->b_fill = PATTERN_SMPTE;
888
889         data->display = tdm_display_init(&ret);
890         TDM_EXIT_IF_FAIL(data->display != NULL);
891
892         parse_args(data, argc, argv);
893         interpret_args(data);
894
895         if (data->do_query) {
896                 tdm_helper_get_display_information(data->display, temp, &len);
897                 printf("%s", temp);
898                 goto done;
899         }
900
901         run_test(data);
902
903 done:
904         tdm_display_deinit(data->display);
905
906         return 0;
907 }
908
909 static void
910 output_setup(tdm_test_server_output *o)
911 {
912         tdm_test_server *data = o->data;
913         const tdm_output_mode *modes, *found = NULL, *best = NULL, *prefer = NULL;
914         tdm_test_server_prop *w = NULL;
915         const tdm_prop *props;
916         int i, count;
917         tdm_error ret;
918
919         o->output = tdm_display_get_output(data->display, o->idx, &ret);
920         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
921
922         ret = tdm_output_get_available_modes(o->output, &modes, &count);
923         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
924
925         for (i = 0; i < count; i++) {
926                 if (!strncmp(o->mode, modes[i].name, TDM_NAME_LEN) && o->refresh == modes[i].vrefresh) {
927                         found = &modes[i];
928                         printf("found mode: %dx%d %d\n", found->hdisplay, found->vdisplay, found->vrefresh);
929                         break;
930                 }
931                 if (!best)
932                         best = &modes[i];
933                 if (modes[i].type & TDM_OUTPUT_MODE_TYPE_PREFERRED)
934                         prefer = &modes[i];
935         }
936         if (!found && prefer) {
937                 found = prefer;
938                 printf("found prefer mode: %dx%d %d\n", found->hdisplay, found->vdisplay, found->vrefresh);
939         }
940         if (!found && best) {
941                 found = best;
942                 printf("found best mode: %dx%d %d\n", found->hdisplay, found->vdisplay, found->vrefresh);
943         }
944
945         if (!found) {
946                 printf("couldn't find any mode\n");
947                 exit(0);
948         }
949
950         ret = tdm_output_set_mode(o->output, found);
951         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
952
953         printf("output %d: %s %d\n", o->idx, found->name, found->vrefresh);
954
955         ret = tdm_output_get_available_properties(o->output, &props, &count);
956         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
957
958         LIST_FOR_EACH_ENTRY(w, &o->prop_list, link) {
959                 for (i = 0; i < count; i++) {
960                         if (strncmp(w->name, props[i].name, TDM_NAME_LEN))
961                                 continue;
962                         ret = tdm_output_set_property(o->output, props[i].id, w->value);
963                         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
964                         printf("\tprop '%s': %d\n", props[i].name, w->value.u32);
965                         break;
966                 }
967         }
968
969         /* DPMS on forcely at the first time. */
970         ret = tdm_output_set_dpms(o->output, TDM_OUTPUT_DPMS_ON);
971         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
972 }
973
974 static tbm_surface_h
975 layer_get_buffer(tdm_test_server_layer *l)
976 {
977         int i, size = TDM_ARRAY_SIZE(l->bufs);
978         if (!l->bufs[0]) {
979                 for (i = 0; i < size; i++) {
980                         int width = (l->info.src_config.size.h) ? : l->info.src_config.pos.w;
981                         int height = (l->info.src_config.size.v) ? : l->info.src_config.pos.h;
982                         unsigned int format = (l->info.src_config.format) ? : DEFAULT_FORMAT;
983                         int flags = l->o->data->bflags;
984                         tbm_surface_h b = buffer_allocate(width, height, format, flags);
985                         TDM_EXIT_IF_FAIL(b != NULL);
986                         l->bufs[i] = b;
987                 }
988         }
989         for (i = 0; i < size; i++) {
990                 tdm_test_server_buffer *tb = get_tts_buffer(l->bufs[i]);
991                 TDM_EXIT_IF_FAIL(tb != NULL);
992                 if (!tb->in_use)
993                         return l->bufs[i];
994         }
995         printf("no available layer buffer.\n");
996         exit(0);
997 }
998
999 static void
1000 layer_cb_commit(tdm_layer *layer, unsigned int sequence,
1001                                 unsigned int tv_sec, unsigned int tv_usec,
1002                                 void *user_data)
1003 {
1004         tdm_test_server_layer *l = user_data;
1005         tbm_surface_h b = layer_get_buffer(l);
1006         TDM_EXIT_IF_FAIL(b != NULL);
1007
1008         if (!l->is_primary || l->o->fill_primary_layer)
1009                 tdm_test_buffer_fill(b, l->data->b_fill);
1010
1011         if (!l->is_primary || l->o->fill_primary_layer)
1012                 layer_show_buffer(l, b);
1013 }
1014
1015 static void
1016 layer_cb_buffer_release(tbm_surface_h b, void *user_data)
1017 {
1018         tdm_test_server_buffer *tb = get_tts_buffer(b);
1019         TDM_EXIT_IF_FAIL(tb != NULL);
1020
1021         tb->in_use = 0;
1022         tdm_buffer_remove_release_handler(b, layer_cb_buffer_release, NULL);
1023         if (tb->done)
1024                 tb->done(b, user_data);
1025 }
1026
1027 static void
1028 layer_show_buffer(tdm_test_server_layer *l, tbm_surface_h b)
1029 {
1030         tdm_test_server *data = l->o->data;
1031         tdm_test_server_buffer *tb;
1032         tdm_error ret;
1033
1034         ret = tdm_layer_set_buffer(l->layer, b);
1035         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1036
1037         tb = get_tts_buffer(b);
1038         TDM_EXIT_IF_FAIL(tb != NULL);
1039
1040         tb->in_use = 1;
1041         tdm_buffer_add_release_handler(b, layer_cb_buffer_release, NULL);
1042
1043         if (data->do_vblank)
1044                 ret = tdm_layer_commit(l->layer, layer_cb_commit, l);
1045         else
1046                 ret = tdm_layer_commit(l->layer, NULL, NULL);
1047         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1048
1049         printf("show:\tl(%p) b(%p)\n", l, b);
1050 }
1051
1052 static void
1053 layer_setup(tdm_test_server_layer *l, tbm_surface_h b)
1054 {
1055         tdm_test_server_prop *w = NULL;
1056         const tdm_prop *props;
1057         int i, count;
1058         tdm_error ret;
1059         tbm_surface_info_s info;
1060
1061         l->layer = tdm_output_get_layer(l->o->output, l->idx, &ret);
1062         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1063
1064         /* The size and format information should be same with buffer's */
1065         tbm_surface_get_info(b, &info);
1066         if (IS_RGB(info.format)) {
1067                 l->info.src_config.size.h = info.planes[0].stride >> 2;
1068                 l->info.src_config.size.v = info.height;
1069         } else {
1070                 l->info.src_config.size.h = info.planes[0].stride;
1071                 l->info.src_config.size.v = info.height;
1072         }
1073         l->info.src_config.format = info.format;
1074
1075         ret = tdm_layer_set_info(l->layer, &l->info);
1076         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1077
1078         printf("layer %d: output(%d) ", l->idx, l->o->idx);
1079         print_config(&l->info.src_config);
1080         printf(" ! ");
1081         print_pos(&l->info.dst_pos);
1082         printf(" transform(%s)\n", tdm_transform_str(l->info.transform));
1083
1084         ret = tdm_layer_get_available_properties(l->layer, &props, &count);
1085         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1086
1087         LIST_FOR_EACH_ENTRY(w, &l->prop_list, link) {
1088                 for (i = 0; i < count; i++) {
1089                         if (strncmp(w->name, props[i].name, TDM_NAME_LEN))
1090                                 continue;
1091                         ret = tdm_layer_set_property(l->layer, props[i].id, w->value);
1092                         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1093                         printf("\tprop '%s': %d\n", props[i].name, w->value.u32);
1094                         break;
1095                 }
1096         }
1097 }
1098
1099 static tbm_surface_h
1100 pp_get_buffer(tdm_test_server_pp *p)
1101 {
1102         int i, size = TDM_ARRAY_SIZE(p->bufs);
1103         if (!p->bufs[0]) {
1104                 for (i = 0; i < size; i++) {
1105                         int width = (p->info.src_config.size.h) ? : p->info.src_config.pos.w;
1106                         int height = (p->info.src_config.size.v) ? : p->info.src_config.pos.h;
1107                         unsigned int format = (p->info.src_config.format) ? : DEFAULT_FORMAT;
1108                         tbm_surface_h b = buffer_allocate(width, height, format, 0);
1109                         TDM_EXIT_IF_FAIL(b != NULL);
1110                         p->bufs[i] = b;
1111                 }
1112         }
1113         for (i = 0; i < size; i++) {
1114                 tdm_test_server_buffer *tb = get_tts_buffer(p->bufs[i]);
1115
1116                 if (tb == NULL)
1117                         continue;
1118
1119                 if (!tb->in_use) {
1120                         tdm_test_buffer_fill(p->bufs[i], p->data->b_fill);
1121                         return p->bufs[i];
1122                 }
1123         }
1124         printf("no available pp buffer.\n");
1125         exit(0);
1126 }
1127
1128 static void
1129 pp_cb_done(tdm_pp *pp, tbm_surface_h sb, tbm_surface_h db, void *user_data)
1130 {
1131         tdm_test_server_buffer *stb, *dtb;
1132
1133         stb = get_tts_buffer(sb);
1134         TDM_EXIT_IF_FAIL(stb != NULL);
1135
1136         dtb = get_tts_buffer(db);
1137         TDM_EXIT_IF_FAIL(dtb != NULL);
1138
1139         stb->in_use = dtb->in_use = 0;
1140
1141         layer_show_buffer(dtb->l, db);
1142 }
1143
1144 static void
1145 pp_convert_buffer(tdm_test_server_pp *p, tbm_surface_h sb, tbm_surface_h db)
1146 {
1147         tdm_test_server_buffer *stb, *dtb;
1148         tdm_error ret;
1149
1150         stb = get_tts_buffer(sb);
1151         TDM_EXIT_IF_FAIL(stb != NULL);
1152
1153         dtb = get_tts_buffer(db);
1154         TDM_EXIT_IF_FAIL(dtb != NULL);
1155
1156         stb->in_use = dtb->in_use = 1;
1157         dtb->l = p->l;
1158
1159         ret = tdm_pp_attach(p->pp, sb, db);
1160         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1161
1162         ret = tdm_pp_commit(p->pp);
1163         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1164
1165         printf("convt:\tp(%p) sb(%p) db(%p)\n", p, sb, db);
1166 }
1167
1168 /* tdm_event_loop_xxx() function is not for the display server. It's for TDM
1169  * backend module. I use them only for simulating the video play. When we call
1170  * tdm_event_loop_xxx() outside of TDM backend module, we have to lock/unlock
1171  * the TDM display. And when the callback function of tdm_event_loop_xxx() is
1172  * called, the display has been already locked. So in this test application,
1173  * we have to unlock/lock the display for testing.
1174  */
1175 static tdm_error
1176 pp_cb_timeout(void *user_data)
1177 {
1178         tdm_test_server_pp *p = user_data;
1179         tdm_test_server *data = p->l->o->data;
1180         tbm_surface_h sb, db;
1181         tdm_error ret;
1182
1183         tdm_display_unlock(data->display);
1184
1185         sb = pp_get_buffer(p);
1186         TDM_EXIT_IF_FAIL(sb != NULL);
1187         db = layer_get_buffer(p->l);
1188         TDM_EXIT_IF_FAIL(db != NULL);
1189
1190         pp_convert_buffer(p, sb, db);
1191
1192         tdm_display_lock(data->display);
1193         ret = tdm_event_loop_source_timer_update(p->timer_source, 1000 / p->fps);
1194         tdm_display_unlock(data->display);
1195         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1196
1197         tdm_display_lock(data->display);
1198
1199         return TDM_ERROR_NONE;
1200 }
1201
1202 static void
1203 pp_setup(tdm_test_server_pp *p, tbm_surface_h sb, tbm_surface_h db)
1204 {
1205         tdm_test_server *data;
1206         tbm_surface_info_s info;
1207         tdm_error ret;
1208
1209         if (!p || !p->l || !p->l->o || !p->l->o->data) {
1210                 TDM_ERR("invalid parameter failed");
1211                 exit(0);
1212         }
1213         data = p->l->o->data;
1214
1215         p->pp = tdm_display_create_pp(data->display, &ret);
1216         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1217
1218         /* The size and format information should be same with buffer's */
1219         tbm_surface_get_info(sb, &info);
1220         if (IS_RGB(info.format)) {
1221                 p->info.src_config.size.h = info.planes[0].stride >> 2;
1222                 p->info.src_config.size.v = info.height;
1223         } else {
1224                 p->info.src_config.size.h = info.planes[0].stride;
1225                 p->info.src_config.size.v = info.height;
1226         }
1227         p->info.src_config.format = info.format;
1228
1229         /* The size and format information should be same with buffer's */
1230         tbm_surface_get_info(db, &info);
1231         if (IS_RGB(info.format)) {
1232                 p->info.dst_config.size.h = info.planes[0].stride >> 2;
1233                 p->info.dst_config.size.v = info.height;
1234         } else {
1235                 p->info.dst_config.size.h = info.planes[0].stride;
1236                 p->info.dst_config.size.v = info.height;
1237         }
1238         p->info.dst_config.format = info.format;
1239
1240         ret = tdm_pp_set_info(p->pp, &p->info);
1241         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1242
1243         ret = tdm_pp_set_done_handler(p->pp, pp_cb_done, NULL);
1244         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1245
1246         printf("pp: ");
1247         print_config(&p->info.src_config);
1248         printf(" ! ");
1249         print_config(&p->info.dst_config);
1250         printf(" fps(%d) transform(%s)\n", p->fps, tdm_transform_str(p->info.transform));
1251         printf("\toutput_idx(%d) layer_idx(%d)\n", p->l->o->idx, p->l->idx);
1252
1253         layer_setup(p->l, db);
1254
1255         /* tdm_event_loop_xxx() function is not for the display server. It's for TDM
1256          * backend module. I use them only for simulating the video play. When we call
1257          * tdm_event_loop_xxx() outside of TDM backend module, we have to lock/unlock
1258          * the TDM display. And when the callback function of tdm_event_loop_xxx() is
1259          * called, the display has been already locked. So in this test application,
1260          * we have to unlock/lock the display for testing.
1261          */
1262         tdm_display_lock(data->display);
1263         p->timer_source = tdm_event_loop_add_timer_handler(data->display, pp_cb_timeout, p, &ret);
1264         tdm_display_unlock(data->display);
1265         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1266
1267         tdm_display_lock(data->display);
1268         ret = tdm_event_loop_source_timer_update(p->timer_source, 1000 / p->fps);
1269         tdm_display_unlock(data->display);
1270         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1271 }
1272
1273 static void
1274 capture_cb_buffer_done(tbm_surface_h b, void *user_data)
1275 {
1276         tdm_test_server_buffer *tb;
1277
1278         tb = get_tts_buffer(b);
1279         TDM_EXIT_IF_FAIL(tb != NULL);
1280
1281         capture_attach(tb->c, b);
1282 }
1283
1284 static void
1285 capture_cb_done(tdm_capture *capture, tbm_surface_h b, void *user_data)
1286 {
1287         tdm_test_server_buffer *tb;
1288
1289         tb = get_tts_buffer(b);
1290         TDM_EXIT_IF_FAIL(tb != NULL);
1291
1292         tb->in_use = 0;
1293
1294         tb->done = capture_cb_buffer_done;
1295         layer_show_buffer(tb->l, b);
1296 }
1297
1298 static void
1299 capture_attach(tdm_test_server_capture *c, tbm_surface_h b)
1300 {
1301         tdm_error ret;
1302         tdm_test_server_buffer *tb;
1303
1304         tb = get_tts_buffer(b);
1305         TDM_EXIT_IF_FAIL(tb != NULL);
1306
1307         tb->in_use = 1;
1308         tb->l = c->l;
1309         tb->c = c;
1310
1311         ret = tdm_capture_attach(c->capture, b);
1312         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1313
1314         printf("capture:\tc(%p) b(%p)\n", c, b);
1315
1316         ret = tdm_capture_commit(c->capture);
1317         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1318 }
1319
1320 static void
1321 capture_setup(tdm_test_server_capture *c, tbm_surface_h b)
1322 {
1323         tdm_test_server *data;
1324         tdm_output *output;
1325         tdm_layer *layer;
1326         tbm_surface_info_s info;
1327         tdm_error ret;
1328
1329         if (!c || !c->l || !c->l->o || !c->l->o->data) {
1330                 TDM_ERR("invalid parameter failed");
1331                 exit(0);
1332         }
1333         data = c->l->o->data;
1334
1335         if (c->output_idx != -1 && c->layer_idx == -1) {
1336                 output = tdm_display_get_output(data->display, c->output_idx, &ret);
1337                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1338                 c->capture = tdm_output_create_capture(output, &ret);
1339                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1340         } else if (c->output_idx != -1 && c->layer_idx != -1) {
1341                 output = tdm_display_get_output(data->display, c->output_idx, &ret);
1342                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1343                 layer = tdm_output_get_layer(output, c->layer_idx, &ret);
1344                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1345                 c->capture = tdm_layer_create_capture(layer, &ret);
1346                 TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1347         }
1348
1349         TDM_EXIT_IF_FAIL(c->capture != NULL);
1350
1351         /* The size and format information should be same with buffer's */
1352         tbm_surface_get_info(b, &info);
1353         if (IS_RGB(info.format)) {
1354                 c->info.dst_config.size.h = info.planes[0].stride >> 2;
1355                 c->info.dst_config.size.v = info.height;
1356         } else {
1357                 c->info.dst_config.size.h = info.planes[0].stride;
1358                 c->info.dst_config.size.v = info.height;
1359         }
1360         c->info.dst_config.format = info.format;
1361
1362         ret = tdm_capture_set_info(c->capture, &c->info);
1363         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1364
1365         ret = tdm_capture_set_done_handler(c->capture, capture_cb_done, NULL);
1366         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1367
1368         printf("capture: o(%d) l(%d) ", c->output_idx, c->layer_idx);
1369         print_config(&c->info.dst_config);
1370         printf(" transform(%s)\n", tdm_transform_str(c->info.transform));
1371         printf("\toutput_idx(%d) layer_idx(%d)\n", c->l->o->idx, c->l->idx);
1372
1373         layer_setup(c->l, b);
1374 }
1375
1376 static void
1377 run_test(tdm_test_server *data)
1378 {
1379         tdm_test_server_output *o = NULL;
1380         tdm_test_server_layer *l = NULL;
1381         tdm_test_server_pp *p = NULL;
1382         tdm_test_server_capture *c = NULL;
1383         tdm_display_capability caps;
1384         tdm_error ret;
1385
1386         ret = tdm_display_get_capabilities(data->display, &caps);
1387         TDM_EXIT_IF_FAIL(ret == TDM_ERROR_NONE);
1388
1389         LIST_FOR_EACH_ENTRY(o, &data->output_list, link) {
1390                 LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
1391                         if (!l->owner_p && !l->owner_c) {
1392                                 tbm_surface_h b;
1393                                 b = layer_get_buffer(l);
1394                                 if (!l->is_primary || l->o->fill_primary_layer)
1395                                         tdm_test_buffer_fill(b, data->b_fill);
1396                                 layer_setup(l, b);
1397                                 layer_show_buffer(l, b);
1398                         }
1399                 }
1400         }
1401
1402         LIST_FOR_EACH_ENTRY(p, &data->pp_list, link) {
1403                 tbm_surface_h sb, db;
1404                 TDM_GOTO_IF_FAIL(caps & TDM_DISPLAY_CAPABILITY_PP, no_pp);
1405                 sb = pp_get_buffer(p);
1406                 TDM_EXIT_IF_FAIL(sb != NULL);
1407                 db = layer_get_buffer(p->l);
1408                 TDM_EXIT_IF_FAIL(db != NULL);
1409                 pp_setup(p, sb, db);
1410                 pp_convert_buffer(p, sb, db);
1411         }
1412
1413         LIST_FOR_EACH_ENTRY(c, &data->capture_list, link) {
1414                 TDM_GOTO_IF_FAIL(caps & TDM_DISPLAY_CAPABILITY_CAPTURE, no_capture);
1415                 tbm_surface_h b;
1416                 b = layer_get_buffer(c->l);
1417                 capture_setup(c, b);
1418                 capture_attach(c, b);
1419                 b = layer_get_buffer(c->l);
1420                 capture_attach(c, b);
1421                 b = layer_get_buffer(c->l);
1422                 capture_attach(c, b);
1423         }
1424
1425         printf("enter test loop\n");
1426
1427         while (1)
1428                 tdm_display_handle_events(data->display);
1429
1430         destroy(data);
1431
1432         return;
1433 no_pp:
1434         printf("no PP capability\n");
1435         exit(0);
1436 no_capture:
1437         printf("no Capture capability\n");
1438         exit(0);
1439 }