1/**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28#include "pipe/p_format.h"
29#include "pipe/p_defines.h"
30#include "pipe/p_screen.h"
31
32#include "util/format/u_format.h"
33#include "util/u_debug.h"
34#include "util/u_memory.h"
35
36#include <GL/gl.h>
37#include "gldrv.h"
38#include "stw_device.h"
39#include "stw_pixelformat.h"
40#include "stw_tls.h"
41#include "stw_winsys.h"
42
43
44struct stw_pf_color_info
45{
46   enum pipe_format format;
47   struct {
48      unsigned char red;
49      unsigned char green;
50      unsigned char blue;
51      unsigned char alpha;
52   } bits;
53   struct {
54      unsigned char red;
55      unsigned char green;
56      unsigned char blue;
57      unsigned char alpha;
58   } shift;
59};
60
61struct stw_pf_depth_info
62{
63   enum pipe_format format;
64   struct {
65      unsigned char depth;
66      unsigned char stencil;
67   } bits;
68};
69
70
71/* NOTE: order matters, since in otherwise equal circumstances the first
72 * format listed will get chosen */
73
74static const struct stw_pf_color_info
75stw_pf_color[] = {
76   /* no-alpha */
77   { PIPE_FORMAT_B8G8R8X8_UNORM,    { 8,  8,  8,  0}, {16,  8,  0,  0} },
78   { PIPE_FORMAT_X8R8G8B8_UNORM,    { 8,  8,  8,  0}, { 8, 16, 24,  0} },
79   /* alpha */
80   { PIPE_FORMAT_B8G8R8A8_UNORM,    { 8,  8,  8,  8}, {16,  8,  0, 24} },
81   { PIPE_FORMAT_A8R8G8B8_UNORM,    { 8,  8,  8,  8}, { 8, 16, 24,  0} },
82   /* shallow bit depths */
83   { PIPE_FORMAT_B5G6R5_UNORM,      { 5,  6,  5,  0}, {11,  5,  0,  0} },
84#if 0
85   { PIPE_FORMAT_R10G10B10A2_UNORM, {10, 10, 10,  2}, { 0, 10, 20, 30} },
86#endif
87   { PIPE_FORMAT_B5G5R5A1_UNORM,    { 5,  5,  5,  1}, {10,  5,  0, 15} },
88   { PIPE_FORMAT_B4G4R4A4_UNORM,    { 4,  4,  4,  4}, {16,  4,  0, 12} }
89};
90
91static const struct stw_pf_color_info
92stw_pf_color_extended[] = {
93   { PIPE_FORMAT_R32G32B32A32_FLOAT, {32, 32, 32, 32}, {0, 32, 64, 96} }
94};
95
96static const struct stw_pf_depth_info
97stw_pf_depth_stencil[] = {
98   /* pure depth */
99   { PIPE_FORMAT_Z32_UNORM,   {32, 0} },
100   { PIPE_FORMAT_X8Z24_UNORM, {24, 0} },
101   { PIPE_FORMAT_Z24X8_UNORM, {24, 0} },
102   { PIPE_FORMAT_Z16_UNORM,   {16, 0} },
103   /* combined depth-stencil */
104   { PIPE_FORMAT_Z24_UNORM_S8_UINT, {24, 8} },
105   { PIPE_FORMAT_S8_UINT_Z24_UNORM, {24, 8} }
106};
107
108
109static const boolean
110stw_pf_doublebuffer[] = {
111   FALSE,
112   TRUE,
113};
114
115
116static const stw_pfd_flag
117stw_pf_flag[] = {
118   stw_pfd_double_buffer,
119   stw_pfd_gdi_support,
120};
121
122
123const unsigned
124stw_pf_multisample[] = {
125   0,
126   4,
127   8,
128   16
129};
130
131
132static void
133stw_pixelformat_add(struct stw_device *stw_dev,
134                    boolean extended,
135                    const struct stw_pf_color_info *color,
136                    const struct stw_pf_depth_info *depth,
137                    unsigned accum,
138                    boolean doublebuffer,
139                    boolean gdi,
140                    unsigned samples)
141{
142   struct stw_pixelformat_info *pfi;
143
144   assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 0) == color->bits.red);
145   assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 1) == color->bits.green);
146   assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 2) == color->bits.blue);
147   assert(util_format_get_component_bits(color->format, UTIL_FORMAT_COLORSPACE_RGB, 3) == color->bits.alpha);
148   assert(util_format_get_component_bits(depth->format, UTIL_FORMAT_COLORSPACE_ZS, 0) == depth->bits.depth);
149   assert(util_format_get_component_bits(depth->format, UTIL_FORMAT_COLORSPACE_ZS, 1) == depth->bits.stencil);
150
151   pfi = util_dynarray_grow(&stw_dev->pixelformats,
152                            struct stw_pixelformat_info,
153                            1);
154
155   memset(pfi, 0, sizeof *pfi);
156
157   pfi->iPixelFormat = util_dynarray_num_elements(&stw_dev->pixelformats, struct stw_pixelformat_info);
158   pfi->pfd.nSize = sizeof pfi->pfd;
159   pfi->pfd.nVersion = 1;
160
161   pfi->pfd.dwFlags = PFD_SUPPORT_OPENGL;
162
163   /* TODO: also support non-native pixel formats */
164   if (!extended) {
165      pfi->pfd.dwFlags |= PFD_DRAW_TO_WINDOW;
166   }
167
168   /* See http://www.opengl.org/pipeline/article/vol003_7/ */
169   pfi->pfd.dwFlags |= PFD_SUPPORT_COMPOSITION;
170
171   if (doublebuffer)
172      pfi->pfd.dwFlags |= PFD_DOUBLEBUFFER | PFD_SWAP_EXCHANGE;
173
174   if (gdi)
175      pfi->pfd.dwFlags |= PFD_SUPPORT_GDI;
176
177   pfi->pfd.iPixelType = PFD_TYPE_RGBA;
178
179   pfi->pfd.cColorBits =
180      color->bits.red + color->bits.green + color->bits.blue + color->bits.alpha;
181   pfi->pfd.cRedBits = color->bits.red;
182   pfi->pfd.cRedShift = color->shift.red;
183   pfi->pfd.cGreenBits = color->bits.green;
184   pfi->pfd.cGreenShift = color->shift.green;
185   pfi->pfd.cBlueBits = color->bits.blue;
186   pfi->pfd.cBlueShift = color->shift.blue;
187   pfi->pfd.cAlphaBits = color->bits.alpha;
188   pfi->pfd.cAlphaShift = color->shift.alpha;
189   pfi->pfd.cAccumBits = 4*accum;
190   pfi->pfd.cAccumRedBits = accum;
191   pfi->pfd.cAccumGreenBits = accum;
192   pfi->pfd.cAccumBlueBits = accum;
193   pfi->pfd.cAccumAlphaBits = accum;
194   pfi->pfd.cDepthBits = depth->bits.depth;
195   pfi->pfd.cStencilBits = depth->bits.stencil;
196   pfi->pfd.cAuxBuffers = 0;
197   pfi->pfd.iLayerType = 0;
198   pfi->pfd.bReserved = 0;
199   pfi->pfd.dwLayerMask = 0;
200   pfi->pfd.dwVisibleMask = 0;
201   pfi->pfd.dwDamageMask = 0;
202
203   /*
204    * since gallium frontend can allocate depth/stencil/accum buffers, we provide
205    * only color buffers here
206    */
207   pfi->stvis.buffer_mask = ST_ATTACHMENT_FRONT_LEFT_MASK;
208   if (doublebuffer)
209      pfi->stvis.buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
210
211   pfi->stvis.color_format = color->format;
212   pfi->stvis.depth_stencil_format = depth->format;
213
214   pfi->stvis.accum_format = (accum) ?
215      PIPE_FORMAT_R16G16B16A16_SNORM : PIPE_FORMAT_NONE;
216
217   pfi->stvis.samples = samples;
218
219   /* WGL_ARB_render_texture */
220   if (color->bits.alpha)
221      pfi->bindToTextureRGBA = TRUE;
222
223   pfi->bindToTextureRGB = TRUE;
224
225   if (!extended) {
226      ++stw_dev->pixelformat_count;
227      assert(stw_dev->pixelformat_count ==
228             util_dynarray_num_elements(&stw_dev->pixelformats,
229                                        struct stw_pixelformat_info));
230   }
231}
232
233
234/**
235 * Add the depth/stencil/accum/ms variants for a list of color formats.
236 */
237static unsigned
238add_color_format_variants(const struct stw_pf_color_info *color_formats,
239                          unsigned num_color_formats, boolean extended)
240{
241   struct pipe_screen *screen = stw_dev->screen;
242   unsigned cfmt, ms, db, ds, acc, f;
243   unsigned bind_flags = PIPE_BIND_RENDER_TARGET;
244   unsigned num_added = 0;
245   int force_samples = 0;
246
247   unsigned supported_flags = 0;
248   if (stw_dev->stw_winsys && stw_dev->stw_winsys->get_pfd_flags)
249      supported_flags = stw_dev->stw_winsys->get_pfd_flags(screen);
250
251   /* Since GLUT for Windows doesn't support MSAA we have an env var
252    * to force all pixel formats to have a particular number of samples.
253    */
254   {
255      const char *samples= getenv("SVGA_FORCE_MSAA");
256      if (samples)
257         force_samples = atoi(samples);
258   }
259
260   if (!extended) {
261      bind_flags |= PIPE_BIND_DISPLAY_TARGET;
262   }
263
264   for (ms = 0; ms < ARRAY_SIZE(stw_pf_multisample); ms++) {
265      unsigned samples = stw_pf_multisample[ms];
266
267      if (force_samples && samples != force_samples)
268         continue;
269
270      for (cfmt = 0; cfmt < num_color_formats; cfmt++) {
271         if (!screen->is_format_supported(screen, color_formats[cfmt].format,
272                                          PIPE_TEXTURE_2D, samples, samples,
273                                          bind_flags)) {
274            continue;
275         }
276
277         for (db = 0; db < ARRAY_SIZE(stw_pf_doublebuffer); db++) {
278            unsigned doublebuffer = stw_pf_doublebuffer[db];
279
280            for (ds = 0; ds < ARRAY_SIZE(stw_pf_depth_stencil); ds++) {
281               const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[ds];
282
283               if (!screen->is_format_supported(screen, depth->format,
284                                                PIPE_TEXTURE_2D, samples,
285                                                samples,
286                                                PIPE_BIND_DEPTH_STENCIL)) {
287                  continue;
288               }
289
290               for (f = 0; f < ARRAY_SIZE(stw_pf_flag); f++) {
291                  stw_pfd_flag flag = stw_pf_flag[f];
292                  if (!(supported_flags & flag) || (flag == stw_pfd_double_buffer && !doublebuffer))
293                     continue;
294                  for (acc = 0; acc < 2; acc++) {
295                     stw_pixelformat_add(stw_dev, extended, &color_formats[cfmt],
296                                         depth, acc * 16, doublebuffer,
297                                         (flag == stw_pfd_gdi_support), samples);
298                     num_added++;
299                  }
300               }
301            }
302         }
303      }
304   }
305
306   return num_added;
307}
308
309
310void
311stw_pixelformat_init(void)
312{
313   unsigned num_formats;
314
315   assert(!stw_dev->pixelformat_count);
316
317   util_dynarray_init(&stw_dev->pixelformats, NULL);
318
319   /* normal, displayable formats */
320   num_formats = add_color_format_variants(stw_pf_color,
321                                           ARRAY_SIZE(stw_pf_color), FALSE);
322   assert(num_formats > 0);
323
324   /* extended, pbuffer-only formats */
325   add_color_format_variants(stw_pf_color_extended,
326                             ARRAY_SIZE(stw_pf_color_extended), TRUE);
327
328   assert(stw_dev->pixelformat_count <=
329          util_dynarray_num_elements(&stw_dev->pixelformats,
330                                     struct stw_pixelformat_info));
331}
332
333
334uint
335stw_pixelformat_get_count(HDC hdc)
336{
337   if (!stw_init_screen(hdc))
338      return 0;
339
340   return stw_dev->pixelformat_count;
341}
342
343
344uint
345stw_pixelformat_get_extended_count(HDC hdc)
346{
347   if (!stw_init_screen(hdc))
348      return 0;
349
350   return util_dynarray_num_elements(&stw_dev->pixelformats,
351                                     struct stw_pixelformat_info);
352}
353
354
355const struct stw_pixelformat_info *
356stw_pixelformat_get_info(int iPixelFormat)
357{
358   unsigned index;
359
360   if (iPixelFormat <= 0) {
361      return NULL;
362   }
363
364   index = iPixelFormat - 1;
365   if (index >= util_dynarray_num_elements(&stw_dev->pixelformats,
366                                           struct stw_pixelformat_info)) {
367      return NULL;
368   }
369
370   return util_dynarray_element(&stw_dev->pixelformats,
371                                struct stw_pixelformat_info,
372                                index);
373}
374
375
376LONG APIENTRY
377DrvDescribePixelFormat(HDC hdc, INT iPixelFormat, ULONG cjpfd,
378                       PIXELFORMATDESCRIPTOR *ppfd)
379{
380   uint count;
381   const struct stw_pixelformat_info *pfi;
382
383   if (!stw_dev)
384      return 0;
385
386   count = stw_pixelformat_get_count(hdc);
387
388   if (ppfd == NULL)
389      return count;
390
391   if (cjpfd != sizeof(PIXELFORMATDESCRIPTOR))
392      return 0;
393
394   pfi = stw_pixelformat_get_info(iPixelFormat);
395   if (!pfi) {
396      return 0;
397   }
398
399   memcpy(ppfd, &pfi->pfd, sizeof(PIXELFORMATDESCRIPTOR));
400
401   return count;
402}
403
404
405BOOL APIENTRY
406DrvDescribeLayerPlane(HDC hdc, INT iPixelFormat, INT iLayerPlane,
407                      UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
408{
409   assert(0);
410   return FALSE;
411}
412
413
414int APIENTRY
415DrvGetLayerPaletteEntries(HDC hdc, INT iLayerPlane, INT iStart,
416                          INT cEntries, COLORREF *pcr)
417{
418   assert(0);
419   return 0;
420}
421
422
423int APIENTRY
424DrvSetLayerPaletteEntries(HDC hdc, INT iLayerPlane, INT iStart,
425                          INT cEntries, CONST COLORREF *pcr)
426{
427   assert(0);
428   return 0;
429}
430
431
432BOOL APIENTRY
433DrvRealizeLayerPalette(HDC hdc, INT iLayerPlane, BOOL bRealize)
434{
435   assert(0);
436   return FALSE;
437}
438
439
440/* Only used by the wgl code, but have it here to avoid exporting the
441 * pixelformat.h functionality.
442 */
443int
444stw_pixelformat_choose(HDC hdc, CONST PIXELFORMATDESCRIPTOR *ppfd)
445{
446   uint count;
447   uint index;
448   uint bestindex;
449   uint bestdelta;
450
451   count = stw_pixelformat_get_extended_count(hdc);
452   bestindex = 0;
453   bestdelta = ~0U;
454
455   for (index = 1; index <= count; index++) {
456      uint delta = 0;
457      const struct stw_pixelformat_info *pfi = stw_pixelformat_get_info(index);
458
459      if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
460          !!(ppfd->dwFlags & PFD_DOUBLEBUFFER) !=
461          !!(pfi->pfd.dwFlags & PFD_DOUBLEBUFFER))
462         continue;
463
464      /* Selection logic:
465      * - Enabling a feature (depth, stencil...) is given highest priority.
466      * - Giving as many bits as requested is given medium priority.
467      * - Giving no more bits than requested is given lowest priority.
468      */
469
470      /* FIXME: Take in account individual channel bits */
471      if (ppfd->cColorBits && !pfi->pfd.cColorBits)
472         delta += 10000;
473      else if (ppfd->cColorBits > pfi->pfd.cColorBits)
474         delta += 100;
475      else if (ppfd->cColorBits < pfi->pfd.cColorBits)
476         delta++;
477
478      if (ppfd->cDepthBits && !pfi->pfd.cDepthBits)
479         delta += 10000;
480      else if (ppfd->cDepthBits > pfi->pfd.cDepthBits)
481         delta += 200;
482      else if (ppfd->cDepthBits < pfi->pfd.cDepthBits)
483         delta += 2;
484
485      if (ppfd->cStencilBits && !pfi->pfd.cStencilBits)
486         delta += 10000;
487      else if (ppfd->cStencilBits > pfi->pfd.cStencilBits)
488         delta += 400;
489      else if (ppfd->cStencilBits < pfi->pfd.cStencilBits)
490         delta++;
491
492      if (ppfd->cAlphaBits && !pfi->pfd.cAlphaBits)
493         delta += 10000;
494      else if (ppfd->cAlphaBits > pfi->pfd.cAlphaBits)
495         delta += 100;
496      else if (ppfd->cAlphaBits < pfi->pfd.cAlphaBits)
497         delta++;
498
499      if (delta < bestdelta) {
500         bestindex = index;
501         bestdelta = delta;
502         if (bestdelta == 0)
503            break;
504      }
505   }
506
507   return bestindex;
508}
509