util: silence the compiler
[glsdk/omapdrmtest.git] / util / util.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  */
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
22 #include "util.h"
24 #include <drm.h>
26 void disp_kms_usage(void);
27 struct display * disp_kms_open(int argc, char **argv);
29 #ifdef HAVE_X11
30 void disp_x11_usage(void);
31 struct display * disp_x11_open(int argc, char **argv);
32 #endif
34 void
35 disp_usage(void)
36 {
37 #ifdef HAVE_X11
38         disp_x11_usage();
39 #endif
40         disp_kms_usage();
41 }
43 struct display *
44 disp_open(int argc, char **argv)
45 {
46         struct display *disp;
48 #ifdef HAVE_X11
49         disp = disp_x11_open(argc, argv);
50         if (disp)
51                 return disp;
52 #endif
54         disp = disp_kms_open(argc, argv);
56         if (!disp) {
57                 ERROR("unable to create display");
58         }
60         return disp;
61 }
63 struct buffer **
64 disp_get_vid_buffers(struct display *disp, uint32_t n,
65                 uint32_t fourcc, uint32_t w, uint32_t h)
66 {
67         struct buffer **buffers;
68         unsigned int i;
70         buffers = disp->get_vid_buffers(disp, n, fourcc, w, h);
71         if (buffers) {
72                 /* if allocation succeeded, store in the unlocked
73                  * video buffer list
74                  */
75                 list_init(&disp->unlocked);
76                 for (i = 0; i < n; i++)
77                         list_add(&buffers[i]->unlocked, &disp->unlocked);
78         }
80         return buffers;
81 }
83 struct buffer *
84 disp_get_vid_buffer(struct display *disp)
85 {
86         struct buffer *buf = NULL;
87         if (!list_is_empty(&disp->unlocked)) {
88                 buf = list_last_entry(&disp->unlocked, struct buffer, unlocked);
89                 list_del(&buf->unlocked);
91                 /* barrier.. if we are using GPU blitting, we need to make sure
92                  * that the GPU is finished:
93                  */
94                 omap_bo_cpu_prep(buf->bo[0], OMAP_GEM_WRITE);
95                 omap_bo_cpu_fini(buf->bo[0], OMAP_GEM_WRITE);
96         }
97         return buf;
98 }
100 void
101 disp_put_vid_buffer(struct display *disp, struct buffer *buf)
103         list_add(&buf->unlocked, &disp->unlocked);
106 struct buffer *
107 disp_get_fb(struct display *disp)
109         struct buffer **bufs = disp_get_buffers(disp, 1);
110         if (!bufs)
111                 return NULL;
112         fill(bufs[0], 42);
113         disp_post_buffer(disp, bufs[0]);
114         return bufs[0];
118 int
119 check_args(int argc, char **argv)
121         int i;
122         for (i = 1; i < argc; i++) {
123                 if (argv[i]) {
124                         ERROR("invalid arg: %s", argv[i]);
125                         return -1;
126                 }
127         }
128         return 0;
131 /* stolen from modetest.c */
132 static void
133 fillRGB4(char *virtual, int n, int width, int height, int stride)
135         int i, j;
136         /* paint the buffer with colored tiles */
137         for (j = 0; j < height; j++) {
138                 uint32_t *fb_ptr = (uint32_t*)((char*)virtual + j * stride);
139                 for (i = 0; i < width; i++) {
140                         div_t d = div(n+i+j, width);
141                         fb_ptr[i] =
142                                         0x00130502 * (d.quot >> 6) +
143                                         0x000a1120 * (d.rem >> 6);
144                 }
145         }
149 /* swap these for big endian.. */
150 #define RED   2
151 #define GREEN 1
152 #define BLUE  0
154 static void
155 fill420(unsigned char *y, unsigned char *u, unsigned char *v,
156                 int cs /*chroma pixel stride */,
157                 int n, int width, int height, int stride)
159         int i, j;
161         /* paint the buffer with colored tiles, in blocks of 2x2 */
162         for (j = 0; j < height; j+=2) {
163                 unsigned char *y1p = y + j * stride;
164                 unsigned char *y2p = y1p + stride;
165                 unsigned char *up = u + (j/2) * stride * cs / 2;
166                 unsigned char *vp = v + (j/2) * stride * cs / 2;
168                 for (i = 0; i < width; i+=2) {
169                         div_t d = div(n+i+j, width);
170                         uint32_t rgb = 0x00130502 * (d.quot >> 6) + 0x000a1120 * (d.rem >> 6);
171                         unsigned char *rgbp = (unsigned char *)&rgb;
172                         unsigned char y = (0.299 * rgbp[RED]) + (0.587 * rgbp[GREEN]) + (0.114 * rgbp[BLUE]);
174                         *(y2p++) = *(y1p++) = y;
175                         *(y2p++) = *(y1p++) = y;
177                         *up = (rgbp[BLUE] - y) * 0.565 + 128;
178                         *vp = (rgbp[RED] - y) * 0.713 + 128;
179                         up += cs;
180                         vp += cs;
181                 }
182         }
185 static void
186 fill422(unsigned char *virtual, int n, int width, int height, int stride)
188         int i, j;
189         /* paint the buffer with colored tiles */
190         for (j = 0; j < height; j++) {
191                 uint8_t *ptr = (uint8_t*)((char*)virtual + j * stride);
192                 for (i = 0; i < width; i++) {
193                         div_t d = div(n+i+j, width);
194                         uint32_t rgb = 0x00130502 * (d.quot >> 6) + 0x000a1120 * (d.rem >> 6);
195                         unsigned char *rgbp = (unsigned char *)&rgb;
196                         unsigned char y = (0.299 * rgbp[RED]) + (0.587 * rgbp[GREEN]) + (0.114 * rgbp[BLUE]);
198                         *(ptr++) = y;
199                         *(ptr++) = (rgbp[BLUE] - y) * 0.565 + 128;
200                         *(ptr++) = y;
201                         *(ptr++) = (rgbp[RED] - y) * 0.713 + 128;
202                 }
203         }
207 void
208 fill(struct buffer *buf, int n)
210         int i;
212         for (i = 0; i < buf->nbo; i++)
213                 omap_bo_cpu_prep(buf->bo[i], OMAP_GEM_WRITE);
215         switch(buf->fourcc) {
216         case 0: {
217                 assert(buf->nbo == 1);
218                 fillRGB4(omap_bo_map(buf->bo[0]), n,
219                                 buf->width, buf->height, buf->pitches[0]);
220                 break;
221         }
222         case FOURCC('Y','U','Y','V'): {
223                 assert(buf->nbo == 1);
224                 fill422(omap_bo_map(buf->bo[0]), n,
225                                 buf->width, buf->height, buf->pitches[0]);
226                 break;
227         }
228         case FOURCC('N','V','1','2'): {
229                 unsigned char *y, *u, *v;
230                 assert(buf->nbo == 2);
231                 y = omap_bo_map(buf->bo[0]);
232                 u = omap_bo_map(buf->bo[1]);
233                 v = u + 1;
234                 fill420(y, u, v, 2, n, buf->width, buf->height, buf->pitches[0]);
235                 break;
236         }
237         case FOURCC('I','4','2','0'): {
238                 unsigned char *y, *u, *v;
239                 assert(buf->nbo == 3);
240                 y = omap_bo_map(buf->bo[0]);
241                 u = omap_bo_map(buf->bo[1]);
242                 v = omap_bo_map(buf->bo[2]);
243                 fill420(y, u, v, 1, n, buf->width, buf->height, buf->pitches[0]);
244                 break;
245         }
246         default:
247                 ERROR("invalid format: 0x%08x", buf->fourcc);
248                 break;
249         }
251         for (i = 0; i < buf->nbo; i++)
252                 omap_bo_cpu_fini(buf->bo[i], OMAP_GEM_WRITE);