xorg_exa.c revision f44f6473e60fdcde24b0d8b166fce8a2ffe366b7 
1/*
2 * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
3 * All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
12 *
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
15 * of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 *
25 *
26 * Author: Alan Hourihane <alanh@tungstengraphics.com>
27 * Author: Jakob Bornecrantz <wallbraker@gmail.com>
28 *
29 */
30
31#include "xorg_exa.h"
32#include "xorg_tracker.h"
33#include "xorg_composite.h"
34#include "xorg_exa_tgsi.h"
35
36#include <xorg-server.h>
37#include <xf86.h>
38#include <picturestr.h>
39#include <picture.h>
40
41#include "pipe/p_format.h"
42#include "pipe/p_context.h"
43#include "pipe/p_state.h"
44#include "pipe/p_inlines.h"
45
46#include "util/u_rect.h"
47#include "util/u_math.h"
48#include "util/u_debug.h"
49
50#define DEBUG_PRINT 0
51#define ROUND_UP_TEXTURES 1
52
53/*
54 * Helper functions
55 */
56struct render_format_str {
57   int format;
58   const char *name;
59};
60static const struct render_format_str formats_info[] =
61{
62   {PICT_a8r8g8b8, "PICT_a8r8g8b8"},
63   {PICT_x8r8g8b8, "PICT_x8r8g8b8"},
64   {PICT_a8b8g8r8, "PICT_a8b8g8r8"},
65   {PICT_x8b8g8r8, "PICT_x8b8g8r8"},
66#ifdef PICT_TYPE_BGRA
67   {PICT_b8g8r8a8, "PICT_b8g8r8a8"},
68   {PICT_b8g8r8x8, "PICT_b8g8r8x8"},
69   {PICT_a2r10g10b10, "PICT_a2r10g10b10"},
70   {PICT_x2r10g10b10, "PICT_x2r10g10b10"},
71   {PICT_a2b10g10r10, "PICT_a2b10g10r10"},
72   {PICT_x2b10g10r10, "PICT_x2b10g10r10"},
73#endif
74   {PICT_r8g8b8, "PICT_r8g8b8"},
75   {PICT_b8g8r8, "PICT_b8g8r8"},
76   {PICT_r5g6b5, "PICT_r5g6b5"},
77   {PICT_b5g6r5, "PICT_b5g6r5"},
78   {PICT_a1r5g5b5, "PICT_a1r5g5b5"},
79   {PICT_x1r5g5b5, "PICT_x1r5g5b5"},
80   {PICT_a1b5g5r5, "PICT_a1b5g5r5"},
81   {PICT_x1b5g5r5, "PICT_x1b5g5r5"},
82   {PICT_a4r4g4b4, "PICT_a4r4g4b4"},
83   {PICT_x4r4g4b4, "PICT_x4r4g4b4"},
84   {PICT_a4b4g4r4, "PICT_a4b4g4r4"},
85   {PICT_x4b4g4r4, "PICT_x4b4g4r4"},
86   {PICT_a8, "PICT_a8"},
87   {PICT_r3g3b2, "PICT_r3g3b2"},
88   {PICT_b2g3r3, "PICT_b2g3r3"},
89   {PICT_a2r2g2b2, "PICT_a2r2g2b2"},
90   {PICT_a2b2g2r2, "PICT_a2b2g2r2"},
91   {PICT_c8, "PICT_c8"},
92   {PICT_g8, "PICT_g8"},
93   {PICT_x4a4, "PICT_x4a4"},
94   {PICT_x4c4, "PICT_x4c4"},
95   {PICT_x4g4, "PICT_x4g4"},
96   {PICT_a4, "PICT_a4"},
97   {PICT_r1g2b1, "PICT_r1g2b1"},
98   {PICT_b1g2r1, "PICT_b1g2r1"},
99   {PICT_a1r1g1b1, "PICT_a1r1g1b1"},
100   {PICT_a1b1g1r1, "PICT_a1b1g1r1"},
101   {PICT_c4, "PICT_c4"},
102   {PICT_g4, "PICT_g4"},
103   {PICT_a1, "PICT_a1"},
104   {PICT_g1, "PICT_g1"}
105};
106static const char *render_format_name(int format)
107{
108   int i = 0;
109   for (i = 0; i < sizeof(formats_info)/sizeof(formats_info[0]); ++i) {
110      if (formats_info[i].format == format)
111         return formats_info[i].name;
112   }
113   return NULL;
114}
115
116static void
117exa_get_pipe_format(int depth, enum pipe_format *format, int *bbp, int *picture_format)
118{
119    switch (depth) {
120    case 32:
121	*format = PIPE_FORMAT_A8R8G8B8_UNORM;
122	*picture_format = PICT_a8r8g8b8;
123	assert(*bbp == 32);
124	break;
125    case 24:
126	*format = PIPE_FORMAT_X8R8G8B8_UNORM;
127	*picture_format = PICT_x8r8g8b8;
128	assert(*bbp == 32);
129	break;
130    case 16:
131	*format = PIPE_FORMAT_R5G6B5_UNORM;
132	*picture_format = PICT_r5g6b5;
133	assert(*bbp == 16);
134	break;
135    case 15:
136	*format = PIPE_FORMAT_A1R5G5B5_UNORM;
137	*picture_format = PICT_x1r5g5b5;
138	assert(*bbp == 16);
139	break;
140    case 8:
141	*format = PIPE_FORMAT_L8_UNORM;
142	*picture_format = PICT_a8;
143	assert(*bbp == 8);
144	break;
145    case 4:
146    case 1:
147	*format = PIPE_FORMAT_A8R8G8B8_UNORM; /* bad bad bad */
148	break;
149    default:
150	assert(0);
151	break;
152    }
153}
154
155
156/*
157 * Static exported EXA functions
158 */
159
160static void
161ExaWaitMarker(ScreenPtr pScreen, int marker)
162{
163   /* Nothing to do, handled in the PrepareAccess hook */
164}
165
166static int
167ExaMarkSync(ScreenPtr pScreen)
168{
169   return 1;
170}
171
172
173/***********************************************************************
174 * Screen upload/download
175 */
176
177static Bool
178ExaDownloadFromScreen(PixmapPtr pPix, int x,  int y, int w,  int h, char *dst,
179		      int dst_pitch)
180{
181    ScreenPtr pScreen = pPix->drawable.pScreen;
182    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
183    modesettingPtr ms = modesettingPTR(pScrn);
184    struct exa_context *exa = ms->exa;
185    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
186    struct pipe_transfer *transfer;
187
188    if (!priv || !priv->tex)
189	return FALSE;
190
191    if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
192	PIPE_REFERENCED_FOR_WRITE)
193	exa->pipe->flush(exa->pipe, 0, NULL);
194
195    transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
196					   PIPE_TRANSFER_READ, x, y, w, h);
197    if (!transfer)
198	return FALSE;
199
200#if DEBUG_PRINT
201    debug_printf("------ ExaDownloadFromScreen(%d, %d, %d, %d, %d)\n",
202                 x, y, w, h, dst_pitch);
203#endif
204
205    util_copy_rect((unsigned char*)dst, &priv->tex->block, dst_pitch, 0, 0,
206		   w, h, exa->scrn->transfer_map(exa->scrn, transfer),
207		   transfer->stride, 0, 0);
208
209    exa->scrn->transfer_unmap(exa->scrn, transfer);
210    exa->scrn->tex_transfer_destroy(transfer);
211
212    return TRUE;
213}
214
215static Bool
216ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src,
217		  int src_pitch)
218{
219    ScreenPtr pScreen = pPix->drawable.pScreen;
220    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
221    modesettingPtr ms = modesettingPTR(pScrn);
222    struct exa_context *exa = ms->exa;
223    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix);
224    struct pipe_transfer *transfer;
225
226    if (!priv || !priv->tex)
227	return FALSE;
228
229    /* make sure that any pending operations are flushed to hardware */
230    if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
231	(PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE))
232	xorg_exa_flush(exa, 0, NULL);
233
234    transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
235					   PIPE_TRANSFER_WRITE, x, y, w, h);
236    if (!transfer)
237	return FALSE;
238
239#if DEBUG_PRINT
240    debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n",
241                 x, y, w, h, src_pitch);
242#endif
243
244    util_copy_rect(exa->scrn->transfer_map(exa->scrn, transfer),
245		   &priv->tex->block, transfer->stride, 0, 0, w, h,
246		   (unsigned char*)src, src_pitch, 0, 0);
247
248    exa->scrn->transfer_unmap(exa->scrn, transfer);
249    exa->scrn->tex_transfer_destroy(transfer);
250
251    return TRUE;
252}
253
254static Bool
255ExaPrepareAccess(PixmapPtr pPix, int index)
256{
257    ScreenPtr pScreen = pPix->drawable.pScreen;
258    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
259    modesettingPtr ms = modesettingPTR(pScrn);
260    struct exa_context *exa = ms->exa;
261    struct exa_pixmap_priv *priv;
262
263    priv = exaGetPixmapDriverPrivate(pPix);
264
265    if (!priv)
266	return FALSE;
267
268    if (!priv->tex)
269	return FALSE;
270
271    if (priv->map_count == 0)
272    {
273	if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) &
274	    PIPE_REFERENCED_FOR_WRITE)
275	    exa->pipe->flush(exa->pipe, 0, NULL);
276
277        assert(pPix->drawable.width <= priv->tex->width[0]);
278        assert(pPix->drawable.height <= priv->tex->height[0]);
279
280	priv->map_transfer =
281	    exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0,
282#ifdef EXA_MIXED_PIXMAPS
283					PIPE_TRANSFER_MAP_DIRECTLY |
284#endif
285					PIPE_TRANSFER_READ_WRITE,
286					0, 0,
287                                        pPix->drawable.width,
288                                        pPix->drawable.height );
289	if (!priv->map_transfer)
290#ifdef EXA_MIXED_PIXMAPS
291	    return FALSE;
292#else
293	    FatalError("failed to create transfer\n");
294#endif
295
296	pPix->devPrivate.ptr =
297	    exa->scrn->transfer_map(exa->scrn, priv->map_transfer);
298	pPix->devKind = priv->map_transfer->stride;
299    }
300
301    priv->map_count++;
302
303    return TRUE;
304}
305
306static void
307ExaFinishAccess(PixmapPtr pPix, int index)
308{
309    ScreenPtr pScreen = pPix->drawable.pScreen;
310    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
311    modesettingPtr ms = modesettingPTR(pScrn);
312    struct exa_context *exa = ms->exa;
313    struct exa_pixmap_priv *priv;
314    priv = exaGetPixmapDriverPrivate(pPix);
315
316    if (!priv)
317	return;
318
319    if (!priv->map_transfer)
320	return;
321
322    if (--priv->map_count == 0) {
323	assert(priv->map_transfer);
324	exa->scrn->transfer_unmap(exa->scrn, priv->map_transfer);
325	exa->scrn->tex_transfer_destroy(priv->map_transfer);
326	priv->map_transfer = NULL;
327	pPix->devPrivate.ptr = NULL;
328    }
329}
330
331/***********************************************************************
332 * Solid Fills
333 */
334
335static Bool
336ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
337{
338    ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
339    modesettingPtr ms = modesettingPTR(pScrn);
340    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
341    struct exa_context *exa = ms->exa;
342
343#if DEBUG_PRINT
344    debug_printf("ExaPrepareSolid(0x%x)\n", fg);
345#endif
346    if (!exa->accel)
347	return FALSE;
348
349    if (!exa->pipe)
350	XORG_FALLBACK("accle not enabled");
351
352    if (!priv || !priv->tex)
353	XORG_FALLBACK("%s", !priv ? "!priv" : "!priv->tex");
354
355    if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask))
356	XORG_FALLBACK("planeMask is not solid");
357
358    if (alu != GXcopy)
359	XORG_FALLBACK("not GXcopy");
360
361    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
362                                        priv->tex->target,
363                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0)) {
364	XORG_FALLBACK("format %s", pf_name(priv->tex->format));
365    }
366
367    return xorg_solid_bind_state(exa, priv, fg);
368}
369
370static void
371ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1)
372{
373    ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
374    modesettingPtr ms = modesettingPTR(pScrn);
375    struct exa_context *exa = ms->exa;
376    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
377
378#if DEBUG_PRINT
379    debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1);
380#endif
381
382    if (x0 == 0 && y0 == 0 &&
383        x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) {
384       exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, exa->solid_color, 0.0, 0);
385       return;
386    }
387
388    xorg_solid(exa, priv, x0, y0, x1, y1) ;
389}
390
391
392static void
393ExaDoneSolid(PixmapPtr pPixmap)
394{
395    ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
396    modesettingPtr ms = modesettingPTR(pScrn);
397    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
398    struct exa_context *exa = ms->exa;
399
400    if (!priv)
401	return;
402
403    xorg_composite_done(exa);
404}
405
406/***********************************************************************
407 * Copy Blits
408 */
409
410static Bool
411ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
412	       int ydir, int alu, Pixel planeMask)
413{
414    ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
415    modesettingPtr ms = modesettingPTR(pScrn);
416    struct exa_context *exa = ms->exa;
417    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
418    struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap);
419
420#if DEBUG_PRINT
421    debug_printf("ExaPrepareCopy\n");
422#endif
423
424    if (!exa->accel)
425	return FALSE;
426
427    if (!exa->pipe)
428	XORG_FALLBACK("accle not enabled");
429
430    if (!priv || !priv->tex)
431	XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex");
432
433    if (!src_priv || !src_priv->tex)
434	XORG_FALLBACK("pSrc %s", !src_priv ? "!priv" : "!priv->tex");
435
436    if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask))
437	XORG_FALLBACK("planeMask is not solid");
438
439    if (alu != GXcopy)
440	XORG_FALLBACK("alu not GXcopy");
441
442    if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
443                                        priv->tex->target,
444                                        PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
445	XORG_FALLBACK("pDst format %s", pf_name(priv->tex->format));
446
447    if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
448                                        src_priv->tex->target,
449                                        PIPE_TEXTURE_USAGE_SAMPLER, 0))
450	XORG_FALLBACK("pSrc format %s", pf_name(src_priv->tex->format));
451
452    exa->copy.src = src_priv;
453    exa->copy.dst = priv;
454
455    /* For same-surface copies, the pipe->surface_copy path is clearly
456     * superior, providing it is implemented.  In other cases it's not
457     * clear what the better path would be, and eventually we'd
458     * probably want to gather timings and choose dynamically.
459     */
460    if (exa->pipe->surface_copy &&
461        exa->copy.src == exa->copy.dst) {
462
463       exa->copy.use_surface_copy = TRUE;
464
465       exa->copy.src_surface =
466          exa->scrn->get_tex_surface( exa->scrn,
467                                      exa->copy.src->tex,
468                                      0, 0, 0,
469                                      PIPE_BUFFER_USAGE_GPU_READ);
470
471       exa->copy.dst_surface =
472          exa->scrn->get_tex_surface( exa->scrn,
473                                      exa->copy.dst->tex,
474                                      0, 0, 0,
475                                      PIPE_BUFFER_USAGE_GPU_WRITE );
476    }
477    else {
478       exa->copy.use_surface_copy = FALSE;
479
480       if (exa->copy.dst == exa->copy.src)
481          exa->copy.src_texture = renderer_clone_texture( exa->renderer,
482                                                          exa->copy.src->tex );
483       else
484          pipe_texture_reference(&exa->copy.src_texture,
485                                 exa->copy.src->tex);
486
487       exa->copy.dst_surface =
488          exa->scrn->get_tex_surface(exa->scrn,
489                                     exa->copy.dst->tex,
490                                     0, 0, 0,
491                                     PIPE_BUFFER_USAGE_GPU_WRITE);
492
493
494       renderer_copy_prepare(exa->renderer,
495                             exa->copy.dst_surface,
496                             exa->copy.src_texture );
497    }
498
499
500    return TRUE;
501}
502
503static void
504ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY,
505	int width, int height)
506{
507   ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum];
508   modesettingPtr ms = modesettingPTR(pScrn);
509   struct exa_context *exa = ms->exa;
510   struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap);
511
512#if DEBUG_PRINT
513   debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n",
514                srcX, srcY, dstX, dstY, width, height);
515#endif
516
517   debug_assert(priv == exa->copy.dst);
518
519   if (exa->copy.use_surface_copy) {
520      /* XXX: consider exposing >1 box in surface_copy interface.
521       */
522      exa->pipe->surface_copy( exa->pipe,
523                             exa->copy.dst_surface,
524                             dstX, dstY,
525                             exa->copy.src_surface,
526                             srcX, srcY,
527                             width, height );
528   }
529   else {
530      renderer_copy_pixmap(exa->renderer,
531                           dstX, dstY,
532                           srcX, srcY,
533                           width, height,
534                           exa->copy.src_texture->width[0],
535                           exa->copy.src_texture->height[0]);
536   }
537}
538
539static void
540ExaDoneCopy(PixmapPtr pPixmap)
541{
542    ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
543    modesettingPtr ms = modesettingPTR(pScrn);
544    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
545    struct exa_context *exa = ms->exa;
546
547    if (!priv)
548	return;
549
550   renderer_draw_flush(exa->renderer);
551
552   exa->copy.src = NULL;
553   exa->copy.dst = NULL;
554   pipe_surface_reference(&exa->copy.src_surface, NULL);
555   pipe_surface_reference(&exa->copy.dst_surface, NULL);
556   pipe_texture_reference(&exa->copy.src_texture, NULL);
557}
558
559
560
561static Bool
562picture_check_formats(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture)
563{
564   if (pSrc->picture_format == pSrcPicture->format)
565      return TRUE;
566
567   if (pSrc->picture_format != PICT_a8r8g8b8)
568      return FALSE;
569
570   /* pSrc->picture_format == PICT_a8r8g8b8 */
571   switch (pSrcPicture->format) {
572   case PICT_a8r8g8b8:
573   case PICT_x8r8g8b8:
574   case PICT_a8b8g8r8:
575   case PICT_x8b8g8r8:
576   /* just treat these two as x8... */
577   case PICT_r8g8b8:
578   case PICT_b8g8r8:
579      return TRUE;
580#ifdef PICT_TYPE_BGRA
581   case PICT_b8g8r8a8:
582   case PICT_b8g8r8x8:
583      return FALSE; /* does not support swizzleing the alpha channel yet */
584   case PICT_a2r10g10b10:
585   case PICT_x2r10g10b10:
586   case PICT_a2b10g10r10:
587   case PICT_x2b10g10r10:
588      return FALSE;
589#endif
590   default:
591      return FALSE;
592   }
593   return FALSE;
594}
595
596/***********************************************************************
597 * Composite entrypoints
598 */
599
600static Bool
601ExaCheckComposite(int op,
602		  PicturePtr pSrcPicture, PicturePtr pMaskPicture,
603		  PicturePtr pDstPicture)
604{
605   ScrnInfoPtr pScrn = xf86Screens[pDstPicture->pDrawable->pScreen->myNum];
606   modesettingPtr ms = modesettingPTR(pScrn);
607   struct exa_context *exa = ms->exa;
608
609#if DEBUG_PRINT
610   debug_printf("ExaCheckComposite(%d, %p, %p, %p) = %d\n",
611                op, pSrcPicture, pMaskPicture, pDstPicture, accelerated);
612#endif
613
614   if (!exa->accel)
615       return FALSE;
616
617   return xorg_composite_accelerated(op,
618				     pSrcPicture,
619				     pMaskPicture,
620				     pDstPicture);
621}
622
623
624static Bool
625ExaPrepareComposite(int op, PicturePtr pSrcPicture,
626		    PicturePtr pMaskPicture, PicturePtr pDstPicture,
627		    PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst)
628{
629   ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
630   modesettingPtr ms = modesettingPTR(pScrn);
631   struct exa_context *exa = ms->exa;
632   struct exa_pixmap_priv *priv;
633
634   if (!exa->accel)
635       return FALSE;
636
637#if DEBUG_PRINT
638   debug_printf("ExaPrepareComposite(%d, src=0x%p, mask=0x%p, dst=0x%p)\n",
639                op, pSrcPicture, pMaskPicture, pDstPicture);
640   debug_printf("\tFormats: src(%s), mask(%s), dst(%s)\n",
641                pSrcPicture ? render_format_name(pSrcPicture->format) : "none",
642                pMaskPicture ? render_format_name(pMaskPicture->format) : "none",
643                pDstPicture ? render_format_name(pDstPicture->format) : "none");
644#endif
645   if (!exa->pipe)
646      XORG_FALLBACK("accle not enabled");
647
648   priv = exaGetPixmapDriverPrivate(pDst);
649   if (!priv || !priv->tex)
650      XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex");
651
652   if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
653                                       priv->tex->target,
654                                       PIPE_TEXTURE_USAGE_RENDER_TARGET, 0))
655      XORG_FALLBACK("pDst format: %s", pf_name(priv->tex->format));
656
657   if (priv->picture_format != pDstPicture->format)
658      XORG_FALLBACK("pDst pic_format: %s != %s",
659                    render_format_name(priv->picture_format),
660                    render_format_name(pDstPicture->format));
661
662   if (pSrc) {
663      priv = exaGetPixmapDriverPrivate(pSrc);
664      if (!priv || !priv->tex)
665         XORG_FALLBACK("pSrc %s", !priv ? "!priv" : "!priv->tex");
666
667      if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
668                                          priv->tex->target,
669                                          PIPE_TEXTURE_USAGE_SAMPLER, 0))
670         XORG_FALLBACK("pSrc format: %s", pf_name(priv->tex->format));
671
672      if (!picture_check_formats(priv, pSrcPicture))
673         XORG_FALLBACK("pSrc pic_format: %s != %s",
674                       render_format_name(priv->picture_format),
675                       render_format_name(pSrcPicture->format));
676
677   }
678
679   if (pMask) {
680      priv = exaGetPixmapDriverPrivate(pMask);
681      if (!priv || !priv->tex)
682         XORG_FALLBACK("pMask %s", !priv ? "!priv" : "!priv->tex");
683
684      if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
685                                          priv->tex->target,
686                                          PIPE_TEXTURE_USAGE_SAMPLER, 0))
687         XORG_FALLBACK("pMask format: %s", pf_name(priv->tex->format));
688
689      if (!picture_check_formats(priv, pMaskPicture))
690         XORG_FALLBACK("pMask pic_format: %s != %s",
691                       render_format_name(priv->picture_format),
692                       render_format_name(pMaskPicture->format));
693   }
694
695   return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture,
696                                    pDstPicture,
697                                    pSrc ? exaGetPixmapDriverPrivate(pSrc) : NULL,
698                                    pMask ? exaGetPixmapDriverPrivate(pMask) : NULL,
699                                    exaGetPixmapDriverPrivate(pDst));
700}
701
702static void
703ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY,
704	     int dstX, int dstY, int width, int height)
705{
706   ScrnInfoPtr pScrn = xf86Screens[pDst->drawable.pScreen->myNum];
707   modesettingPtr ms = modesettingPTR(pScrn);
708   struct exa_context *exa = ms->exa;
709   struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst);
710
711#if DEBUG_PRINT
712   debug_printf("\tExaComposite(src[%d,%d], mask=[%d, %d], dst=[%d, %d], dim=[%d, %d])\n",
713                srcX, srcY, maskX, maskY, dstX, dstY, width, height);
714   debug_printf("\t   Num bound samplers = %d\n",
715                exa->num_bound_samplers);
716#endif
717
718   xorg_composite(exa, priv, srcX, srcY, maskX, maskY,
719                  dstX, dstY, width, height);
720}
721
722
723
724static void
725ExaDoneComposite(PixmapPtr pPixmap)
726{
727   ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum];
728   modesettingPtr ms = modesettingPTR(pScrn);
729   struct exa_context *exa = ms->exa;
730
731   xorg_composite_done(exa);
732}
733
734
735/***********************************************************************
736 * Pixmaps
737 */
738
739static void *
740ExaCreatePixmap(ScreenPtr pScreen, int size, int align)
741{
742    struct exa_pixmap_priv *priv;
743
744    priv = xcalloc(1, sizeof(struct exa_pixmap_priv));
745    if (!priv)
746	return NULL;
747
748    return priv;
749}
750
751static void
752ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv)
753{
754    struct exa_pixmap_priv *priv = (struct exa_pixmap_priv *)dPriv;
755
756    if (!priv)
757	return;
758
759    pipe_texture_reference(&priv->tex, NULL);
760
761    xfree(priv);
762}
763
764static Bool
765ExaPixmapIsOffscreen(PixmapPtr pPixmap)
766{
767    struct exa_pixmap_priv *priv;
768
769    priv = exaGetPixmapDriverPrivate(pPixmap);
770
771    if (!priv)
772	return FALSE;
773
774    if (priv->tex)
775	return TRUE;
776
777    return FALSE;
778}
779
780int
781xorg_exa_set_displayed_usage(PixmapPtr pPixmap)
782{
783    struct exa_pixmap_priv *priv;
784    priv = exaGetPixmapDriverPrivate(pPixmap);
785
786    if (!priv) {
787	FatalError("NO PIXMAP PRIVATE\n");
788	return 0;
789    }
790
791    priv->flags |= PIPE_TEXTURE_USAGE_PRIMARY;
792
793    return 0;
794}
795
796int
797xorg_exa_set_shared_usage(PixmapPtr pPixmap)
798{
799    struct exa_pixmap_priv *priv;
800    priv = exaGetPixmapDriverPrivate(pPixmap);
801
802    if (!priv) {
803	FatalError("NO PIXMAP PRIVATE\n");
804	return 0;
805    }
806
807    priv->flags |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
808
809    return 0;
810}
811
812unsigned
813xorg_exa_get_pixmap_handle(PixmapPtr pPixmap, unsigned *stride_out)
814{
815    ScreenPtr pScreen = pPixmap->drawable.pScreen;
816    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
817    modesettingPtr ms = modesettingPTR(pScrn);
818    struct exa_pixmap_priv *priv;
819    unsigned handle;
820    unsigned stride;
821
822    if (!ms->exa) {
823	FatalError("NO MS->EXA\n");
824	return 0;
825    }
826
827    priv = exaGetPixmapDriverPrivate(pPixmap);
828
829    if (!priv) {
830	FatalError("NO PIXMAP PRIVATE\n");
831	return 0;
832    }
833
834    ms->api->local_handle_from_texture(ms->api, ms->screen, priv->tex, &stride, &handle);
835    if (stride_out)
836	*stride_out = stride;
837
838    return handle;
839}
840
841static Bool
842size_match( int width, int tex_width )
843{
844#if ROUND_UP_TEXTURES
845   if (width > tex_width)
846      return FALSE;
847
848   if (width * 2 < tex_width)
849      return FALSE;
850
851   return TRUE;
852#else
853   return width == tex_width;
854#endif
855}
856
857static Bool
858ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height,
859		      int depth, int bitsPerPixel, int devKind,
860		      pointer pPixData)
861{
862    ScreenPtr pScreen = pPixmap->drawable.pScreen;
863    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
864    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
865    modesettingPtr ms = modesettingPTR(pScrn);
866    struct exa_context *exa = ms->exa;
867
868    if (!priv || pPixData)
869	return FALSE;
870
871    if (0) {
872       debug_printf("%s pixmap %p sz %dx%dx%d devKind %d\n",
873                    __FUNCTION__, pPixmap, width, height, bitsPerPixel, devKind);
874
875       if (priv->tex)
876          debug_printf("  ==> old texture %dx%d\n",
877                       priv->tex->width[0],
878                       priv->tex->height[0]);
879    }
880
881
882    if (depth <= 0)
883	depth = pPixmap->drawable.depth;
884
885    if (bitsPerPixel <= 0)
886	bitsPerPixel = pPixmap->drawable.bitsPerPixel;
887
888    if (width <= 0)
889	width = pPixmap->drawable.width;
890
891    if (height <= 0)
892	height = pPixmap->drawable.height;
893
894    if (width <= 0 || height <= 0 || depth <= 0)
895	return FALSE;
896
897    miModifyPixmapHeader(pPixmap, width, height, depth,
898			     bitsPerPixel, devKind, NULL);
899
900    priv->width = width;
901    priv->height = height;
902
903    /* Deal with screen resize */
904    if ((exa->accel || priv->flags) &&
905        (!priv->tex ||
906         !size_match(width, priv->tex->width[0]) ||
907         !size_match(height, priv->tex->height[0]) ||
908         priv->tex_flags != priv->flags)) {
909	struct pipe_texture *texture = NULL;
910	struct pipe_texture template;
911
912	memset(&template, 0, sizeof(template));
913	template.target = PIPE_TEXTURE_2D;
914	exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &priv->picture_format);
915	pf_get_block(template.format, &template.block);
916        if (ROUND_UP_TEXTURES && priv->flags == 0) {
917           template.width[0] = util_next_power_of_two(width);
918           template.height[0] = util_next_power_of_two(height);
919        }
920        else {
921           template.width[0] = width;
922           template.height[0] = height;
923        }
924
925	template.depth[0] = 1;
926	template.last_level = 0;
927	template.tex_usage = PIPE_TEXTURE_USAGE_RENDER_TARGET | priv->flags;
928	priv->tex_flags = priv->flags;
929	texture = exa->scrn->texture_create(exa->scrn, &template);
930
931	if (priv->tex) {
932	    struct pipe_surface *dst_surf;
933	    struct pipe_surface *src_surf;
934
935	    dst_surf = exa->scrn->get_tex_surface(
936		exa->scrn, texture, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
937	    src_surf = xorg_gpu_surface(exa->pipe->screen, priv);
938            if (exa->pipe->surface_copy) {
939               exa->pipe->surface_copy(exa->pipe, dst_surf, 0, 0, src_surf,
940                                       0, 0, min(width, texture->width[0]),
941                                       min(height, texture->height[0]));
942            } else {
943               util_surface_copy(exa->pipe, FALSE, dst_surf, 0, 0, src_surf,
944                                 0, 0, min(width, texture->width[0]),
945                                 min(height, texture->height[0]));
946            }
947	    exa->scrn->tex_surface_destroy(dst_surf);
948	    exa->scrn->tex_surface_destroy(src_surf);
949	}
950
951	pipe_texture_reference(&priv->tex, texture);
952	/* the texture we create has one reference */
953	pipe_texture_reference(&texture, NULL);
954    }
955
956    return TRUE;
957}
958
959struct pipe_texture *
960xorg_exa_get_texture(PixmapPtr pPixmap)
961{
962   struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
963   struct pipe_texture *tex = NULL;
964   pipe_texture_reference(&tex, priv->tex);
965   return tex;
966}
967
968Bool
969xorg_exa_set_texture(PixmapPtr pPixmap, struct  pipe_texture *tex)
970{
971    struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap);
972
973    int mask = PIPE_TEXTURE_USAGE_PRIMARY | PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
974
975    if (!priv)
976	return FALSE;
977
978    if (pPixmap->drawable.width != tex->width[0] ||
979	pPixmap->drawable.height != tex->height[0])
980	return FALSE;
981
982    pipe_texture_reference(&priv->tex, tex);
983    priv->tex_flags = tex->tex_usage & mask;
984
985    return TRUE;
986}
987
988struct pipe_texture *
989xorg_exa_create_root_texture(ScrnInfoPtr pScrn,
990			     int width, int height,
991			     int depth, int bitsPerPixel)
992{
993    modesettingPtr ms = modesettingPTR(pScrn);
994    struct exa_context *exa = ms->exa;
995    struct pipe_texture template;
996    int dummy;
997
998    memset(&template, 0, sizeof(template));
999    template.target = PIPE_TEXTURE_2D;
1000    exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &dummy);
1001    pf_get_block(template.format, &template.block);
1002    template.width[0] = width;
1003    template.height[0] = height;
1004    template.depth[0] = 1;
1005    template.last_level = 0;
1006    template.tex_usage |= PIPE_TEXTURE_USAGE_RENDER_TARGET;
1007    template.tex_usage |= PIPE_TEXTURE_USAGE_PRIMARY;
1008    template.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
1009
1010    return exa->scrn->texture_create(exa->scrn, &template);
1011}
1012
1013void
1014xorg_exa_close(ScrnInfoPtr pScrn)
1015{
1016   modesettingPtr ms = modesettingPTR(pScrn);
1017   struct exa_context *exa = ms->exa;
1018
1019   renderer_destroy(exa->renderer);
1020
1021   if (exa->pipe)
1022      exa->pipe->destroy(exa->pipe);
1023
1024   exaDriverFini(pScrn->pScreen);
1025   xfree(exa);
1026   ms->exa = NULL;
1027}
1028
1029void *
1030xorg_exa_init(ScrnInfoPtr pScrn, Bool accel)
1031{
1032   modesettingPtr ms = modesettingPTR(pScrn);
1033   struct exa_context *exa;
1034   ExaDriverPtr pExa;
1035
1036   exa = xcalloc(1, sizeof(struct exa_context));
1037   if (!exa)
1038      return NULL;
1039
1040   pExa = exaDriverAlloc();
1041   if (!pExa) {
1042      goto out_err;
1043   }
1044
1045   memset(pExa, 0, sizeof(*pExa));
1046
1047   pExa->exa_major         = 2;
1048   pExa->exa_minor         = 2;
1049   pExa->memoryBase        = 0;
1050   pExa->memorySize        = 0;
1051   pExa->offScreenBase     = 0;
1052   pExa->pixmapOffsetAlign = 0;
1053   pExa->pixmapPitchAlign  = 1;
1054   pExa->flags             = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS;
1055#ifdef EXA_SUPPORTS_PREPARE_AUX
1056   pExa->flags            |= EXA_SUPPORTS_PREPARE_AUX;
1057#endif
1058#ifdef EXA_MIXED_PIXMAPS
1059   pExa->flags            |= EXA_MIXED_PIXMAPS;
1060#endif
1061   pExa->maxX              = 8191; /* FIXME */
1062   pExa->maxY              = 8191; /* FIXME */
1063
1064   pExa->WaitMarker         = ExaWaitMarker;
1065   pExa->MarkSync           = ExaMarkSync;
1066   pExa->PrepareSolid       = ExaPrepareSolid;
1067   pExa->Solid              = ExaSolid;
1068   pExa->DoneSolid          = ExaDoneSolid;
1069   pExa->PrepareCopy        = ExaPrepareCopy;
1070   pExa->Copy               = ExaCopy;
1071   pExa->DoneCopy           = ExaDoneCopy;
1072   pExa->CheckComposite     = ExaCheckComposite;
1073   pExa->PrepareComposite   = ExaPrepareComposite;
1074   pExa->Composite          = ExaComposite;
1075   pExa->DoneComposite      = ExaDoneComposite;
1076   pExa->PixmapIsOffscreen  = ExaPixmapIsOffscreen;
1077   pExa->DownloadFromScreen = ExaDownloadFromScreen;
1078   pExa->UploadToScreen     = ExaUploadToScreen;
1079   pExa->PrepareAccess      = ExaPrepareAccess;
1080   pExa->FinishAccess       = ExaFinishAccess;
1081   pExa->CreatePixmap       = ExaCreatePixmap;
1082   pExa->DestroyPixmap      = ExaDestroyPixmap;
1083   pExa->ModifyPixmapHeader = ExaModifyPixmapHeader;
1084
1085   if (!exaDriverInit(pScrn->pScreen, pExa)) {
1086      goto out_err;
1087   }
1088
1089   exa->scrn = ms->screen;
1090   exa->pipe = ms->api->create_context(ms->api, exa->scrn);
1091   /* Share context with DRI */
1092   ms->ctx = exa->pipe;
1093
1094   exa->renderer = renderer_create(exa->pipe);
1095   exa->accel = accel;
1096
1097   return (void *)exa;
1098
1099out_err:
1100   xorg_exa_close(pScrn);
1101
1102   return NULL;
1103}
1104
1105struct pipe_surface *
1106xorg_gpu_surface(struct pipe_screen *scrn, struct exa_pixmap_priv *priv)
1107{
1108   return scrn->get_tex_surface(scrn, priv->tex, 0, 0, 0,
1109                                PIPE_BUFFER_USAGE_GPU_READ |
1110                                PIPE_BUFFER_USAGE_GPU_WRITE);
1111
1112}
1113
1114void xorg_exa_flush(struct exa_context *exa, uint pipeFlushFlags,
1115                    struct pipe_fence_handle **fence)
1116{
1117   exa->pipe->flush(exa->pipe, pipeFlushFlags, fence);
1118}
1119
1120void xorg_exa_finish(struct exa_context *exa)
1121{
1122   struct pipe_fence_handle *fence = NULL;
1123
1124   xorg_exa_flush(exa, PIPE_FLUSH_RENDER_CACHE, &fence);
1125
1126   exa->pipe->screen->fence_finish(exa->pipe->screen, fence, 0);
1127   exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL);
1128}
1129
1130