dmabuftest: Use 6 buffers instead of 3
[glsdk/omapdrmtest.git] / dmabuftest.c
1 /*
2  * Copyright (C) 2011 Texas Instruments
3  * Author: Rob Clark <rob.clark@linaro.org>
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
19 #include <pthread.h>
20 #include "util.h"
22 #define NBUF 6
23 #define CNT  500000
25 enum display_area {
26         FULL,
27         OVERLAY
28 };
30 struct thr_data {
31         struct display *disp;
32         struct v4l2 *v4l2;
33         uint32_t fourcc, width, height;
34         enum display_area area;
35 };
37 static void
38 usage(char *name)
39 {
40         MSG("Usage: %s [OPTION]...", name);
41         MSG("Test of buffer passing between v4l2 camera and display.");
42         MSG("");
43         disp_usage();
44         v4l2_usage();
45 }
47 void *
48 capture_loop(void *arg)
49 {
50         struct thr_data *data = (struct thr_data *)arg;
51         struct display *disp = data->disp;
52         struct v4l2 *v4l2 = data->v4l2;
53         uint32_t fourcc = data->fourcc;
54         uint32_t width = data->width, height = data->height;
56         struct buffer **buffers, *capt;
57         int ret, i;
59         buffers = disp_get_vid_buffers(disp, NBUF, fourcc, width, height);
60         if (!buffers) {
61                 return NULL;
62         }
64         ret = v4l2_reqbufs(v4l2, buffers, NBUF);
65         if (ret) {
66                 return NULL;
67         }
69         if(data->area == OVERLAY) {
70                 for (i = 0; i < NBUF; i++) {
71                         buffers[i]->noScale = true;
72                         get_overlay_plane(disp, buffers[i]);
73                 }
74         }
76         for (i = 0; i < NBUF; i++) {
77                 v4l2_qbuf(v4l2, buffers[i]);
78         }
80         v4l2_streamon(v4l2);
81         for (i = 1; i < CNT; i++) {
83                 capt = v4l2_dqbuf(v4l2);
84                 switch(data->area) {
85                 case FULL:
86                         ret = disp_post_vid_buffer(disp, capt,
87                                 0, 0, width, height);
88                 break;
89                 case OVERLAY:
90                         ret = disp_post_vid_buffer(disp, capt,
91                                 0, 0, width, height);
92                 break;
93                 }
94                 if (ret) {
95                         return NULL;
96                 }
97                 v4l2_qbuf(v4l2, capt);
98         }
99         v4l2_streamoff(v4l2);
101         MSG("Ok!");
102         return disp;
105 int
106 main(int argc, char **argv)
108         struct display *disp;
109         struct v4l2 *v4l2;
110         pthread_t threads[2];
111         struct thr_data tdata[2];
112         void *result = NULL;
113         int ret = 0, i, dual = 0;
115         MSG("Opening Display..");
116         disp = disp_open(argc, argv);
117         if (!disp) {
118                 usage(argv[0]);
119                 return 1;
120         }
122         for (i = 1; i < argc; i++) {
123                 if (!argv[i])
124                         continue;
126                 if (!strcmp("--dual", argv[i])) {
127                         dual = 1;
128                         argv[i] = NULL;
129                 }
130         }
132         MSG("Opening V4L2..");
133         v4l2 = v4l2_open(argc, argv, &tdata[0].fourcc,
134                 &tdata[0].width, &tdata[0].height);
135         if (!v4l2) {
136                 usage(argv[0]);
137                 return 1;
138         }
139         tdata[0].disp = disp;
140         tdata[0].v4l2 = v4l2;
141         tdata[0].area = FULL;
143         if(dual) {
144                 MSG("Opening second V4L2..");
145                 v4l2 = v4l2_open(argc, argv, &tdata[1].fourcc,
146                         &tdata[1].width, &tdata[1].height);
147                 if (!v4l2) {
148                         usage(argv[0]);
149                         return 1;
150                 }
151                 tdata[1].disp = disp;
152                 tdata[1].v4l2 = v4l2;
153                 tdata[1].area = OVERLAY;
154         }
156         if (check_args(argc, argv)) {
157                 /* remaining args.. print usage msg */
158                 usage(argv[0]);
159                 return 0;
160         }
162         if(dual) {
163                 ret = pthread_create(&threads[0], NULL, capture_loop, &tdata[0]);
164                 if(ret) {
165                         MSG("Failed creating thread");
166                 }
167                 ret = pthread_create(&threads[1], NULL, capture_loop, &tdata[1]);
168                 if(ret) {
169                         MSG("Failed creating thread");
170                 }
171         } else {
172                 capture_loop(&tdata[0]);
173         }
175         pthread_join(threads[0], &result);
176         pthread_join(threads[1], &result);
178         disp_close(disp);
180         return ret;