st_cb_fbo.c revision bf89ecb6c92aaaeccd7b6f093cb8bae9fd56aaf6 
1/**************************************************************************
2 *
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
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 TUNGSTEN GRAPHICS 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
29/**
30 * Framebuffer/renderbuffer functions.
31 *
32 * \author Brian Paul
33 */
34
35
36#include "main/imports.h"
37#include "main/context.h"
38#include "main/fbobject.h"
39#include "main/framebuffer.h"
40#include "main/renderbuffer.h"
41
42#include "pipe/p_context.h"
43#include "pipe/p_defines.h"
44#include "pipe/p_screen.h"
45#include "st_context.h"
46#include "st_cb_fbo.h"
47#include "st_cb_texture.h"
48#include "st_format.h"
49#include "st_public.h"
50#include "st_texture.h"
51
52
53
54/**
55 * Compute the renderbuffer's Red/Green/EtcBit fields from the pipe format.
56 */
57static int
58init_renderbuffer_bits(struct st_renderbuffer *strb,
59                       enum pipe_format pipeFormat)
60{
61   struct pipe_format_info info;
62
63   if (!st_get_format_info( pipeFormat, &info )) {
64      assert( 0 );
65   }
66
67   strb->Base._ActualFormat = info.base_format;
68   strb->Base.RedBits = info.red_bits;
69   strb->Base.GreenBits = info.green_bits;
70   strb->Base.BlueBits = info.blue_bits;
71   strb->Base.AlphaBits = info.alpha_bits;
72   strb->Base.DepthBits = info.depth_bits;
73   strb->Base.StencilBits = info.stencil_bits;
74   strb->Base.DataType = st_format_datatype(pipeFormat);
75
76   return info.size;
77}
78
79/**
80 * gl_renderbuffer::AllocStorage()
81 * This is called to allocate the original drawing surface, and
82 * during window resize.
83 */
84static GLboolean
85st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
86                              GLenum internalFormat,
87                              GLuint width, GLuint height)
88{
89   struct pipe_context *pipe = ctx->st->pipe;
90   struct st_renderbuffer *strb = st_renderbuffer(rb);
91   enum pipe_format format;
92
93   if (strb->format != PIPE_FORMAT_NONE)
94      format = strb->format;
95   else
96      format = st_choose_renderbuffer_format(pipe, internalFormat);
97
98   /* init renderbuffer fields */
99   strb->Base.Width  = width;
100   strb->Base.Height = height;
101   init_renderbuffer_bits(strb, format);
102
103   strb->defined = GL_FALSE;  /* undefined contents now */
104
105   if(strb->software) {
106      struct pipe_format_block block;
107      size_t size;
108
109      _mesa_free(strb->data);
110
111      assert(strb->format != PIPE_FORMAT_NONE);
112      pf_get_block(strb->format, &block);
113
114      strb->stride = pf_get_stride(&block, width);
115      size = pf_get_2d_size(&block, strb->stride, height);
116
117      strb->data = _mesa_malloc(size);
118
119      return strb->data != NULL;
120   }
121   else {
122      struct pipe_texture template;
123      unsigned surface_usage;
124
125      /* Free the old surface and texture
126       */
127      pipe_surface_reference( &strb->surface, NULL );
128      pipe_texture_reference( &strb->texture, NULL );
129
130      /* Setup new texture template.
131       */
132      memset(&template, 0, sizeof(template));
133      template.target = PIPE_TEXTURE_2D;
134      template.format = format;
135      pf_get_block(format, &template.block);
136      template.width[0] = width;
137      template.height[0] = height;
138      template.depth[0] = 1;
139      template.last_level = 0;
140      template.nr_samples = rb->NumSamples;
141      if (pf_is_depth_stencil(format)) {
142         template.tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
143      }
144      else {
145         template.tex_usage = (PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
146                               PIPE_TEXTURE_USAGE_RENDER_TARGET);
147      }
148
149      /* Probably need dedicated flags for surface usage too:
150       */
151      surface_usage = (PIPE_BUFFER_USAGE_GPU_READ |
152                       PIPE_BUFFER_USAGE_GPU_WRITE);
153#if 0
154                       PIPE_BUFFER_USAGE_CPU_READ |
155                       PIPE_BUFFER_USAGE_CPU_WRITE);
156#endif
157
158      strb->texture = pipe->screen->texture_create( pipe->screen,
159                                                    &template );
160
161      if (!strb->texture)
162         return FALSE;
163
164      strb->surface = pipe->screen->get_tex_surface( pipe->screen,
165                                                     strb->texture,
166                                                     0, 0, 0,
167                                                     surface_usage );
168
169      assert(strb->surface->texture);
170      assert(strb->surface->format);
171      assert(strb->surface->width == width);
172      assert(strb->surface->height == height);
173
174
175      return strb->surface != NULL;
176   }
177}
178
179
180/**
181 * gl_renderbuffer::Delete()
182 */
183static void
184st_renderbuffer_delete(struct gl_renderbuffer *rb)
185{
186   struct st_renderbuffer *strb = st_renderbuffer(rb);
187   ASSERT(strb);
188   pipe_surface_reference(&strb->surface, NULL);
189   pipe_texture_reference(&strb->texture, NULL);
190   _mesa_free(strb->data);
191   _mesa_free(strb);
192}
193
194
195/**
196 * gl_renderbuffer::GetPointer()
197 */
198static void *
199null_get_pointer(GLcontext * ctx, struct gl_renderbuffer *rb,
200                 GLint x, GLint y)
201{
202   /* By returning NULL we force all software rendering to go through
203    * the span routines.
204    */
205#if 0
206   assert(0);  /* Should never get called with softpipe */
207#endif
208   return NULL;
209}
210
211
212/**
213 * Called via ctx->Driver.NewFramebuffer()
214 */
215static struct gl_framebuffer *
216st_new_framebuffer(GLcontext *ctx, GLuint name)
217{
218   /* XXX not sure we need to subclass gl_framebuffer for pipe */
219   return _mesa_new_framebuffer(ctx, name);
220}
221
222
223/**
224 * Called via ctx->Driver.NewRenderbuffer()
225 */
226static struct gl_renderbuffer *
227st_new_renderbuffer(GLcontext *ctx, GLuint name)
228{
229   struct st_renderbuffer *strb = ST_CALLOC_STRUCT(st_renderbuffer);
230   if (strb) {
231      _mesa_init_renderbuffer(&strb->Base, name);
232      strb->Base.Delete = st_renderbuffer_delete;
233      strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
234      strb->Base.GetPointer = null_get_pointer;
235      strb->format = PIPE_FORMAT_NONE;
236      return &strb->Base;
237   }
238   return NULL;
239}
240
241
242/**
243 * Allocate a renderbuffer for a an on-screen window (not a user-created
244 * renderbuffer).  The window system code determines the format.
245 */
246struct gl_renderbuffer *
247st_new_renderbuffer_fb(enum pipe_format format, int samples, boolean sw)
248{
249   struct st_renderbuffer *strb;
250
251   strb = ST_CALLOC_STRUCT(st_renderbuffer);
252   if (!strb) {
253      _mesa_error(NULL, GL_OUT_OF_MEMORY, "creating renderbuffer");
254      return NULL;
255   }
256
257   _mesa_init_renderbuffer(&strb->Base, 0);
258   strb->Base.ClassID = 0x4242; /* just a unique value */
259   strb->Base.NumSamples = samples;
260   strb->format = format;
261   strb->software = sw;
262
263   switch (format) {
264   case PIPE_FORMAT_A8R8G8B8_UNORM:
265   case PIPE_FORMAT_B8G8R8A8_UNORM:
266   case PIPE_FORMAT_X8R8G8B8_UNORM:
267   case PIPE_FORMAT_B8G8R8X8_UNORM:
268   case PIPE_FORMAT_A1R5G5B5_UNORM:
269   case PIPE_FORMAT_A4R4G4B4_UNORM:
270   case PIPE_FORMAT_R5G6B5_UNORM:
271      strb->Base.InternalFormat = GL_RGBA;
272      strb->Base._BaseFormat = GL_RGBA;
273      break;
274   case PIPE_FORMAT_Z16_UNORM:
275      strb->Base.InternalFormat = GL_DEPTH_COMPONENT16;
276      strb->Base._BaseFormat = GL_DEPTH_COMPONENT;
277      break;
278   case PIPE_FORMAT_Z32_UNORM:
279      strb->Base.InternalFormat = GL_DEPTH_COMPONENT32;
280      strb->Base._BaseFormat = GL_DEPTH_COMPONENT;
281      break;
282   case PIPE_FORMAT_S8Z24_UNORM:
283   case PIPE_FORMAT_Z24S8_UNORM:
284   case PIPE_FORMAT_X8Z24_UNORM:
285   case PIPE_FORMAT_Z24X8_UNORM:
286      strb->Base.InternalFormat = GL_DEPTH24_STENCIL8_EXT;
287      strb->Base._BaseFormat = GL_DEPTH_STENCIL_EXT;
288      break;
289   case PIPE_FORMAT_S8_UNORM:
290      strb->Base.InternalFormat = GL_STENCIL_INDEX8_EXT;
291      strb->Base._BaseFormat = GL_STENCIL_INDEX;
292      break;
293   case PIPE_FORMAT_R16G16B16A16_SNORM:
294      strb->Base.InternalFormat = GL_RGBA16;
295      strb->Base._BaseFormat = GL_RGBA;
296      break;
297   default:
298      _mesa_problem(NULL,
299		    "Unexpected format in st_new_renderbuffer_fb");
300      return NULL;
301   }
302
303   /* st-specific methods */
304   strb->Base.Delete = st_renderbuffer_delete;
305   strb->Base.AllocStorage = st_renderbuffer_alloc_storage;
306   strb->Base.GetPointer = null_get_pointer;
307
308   /* surface is allocated in st_renderbuffer_alloc_storage() */
309   strb->surface = NULL;
310
311   return &strb->Base;
312}
313
314
315
316
317/**
318 * Called via ctx->Driver.BindFramebufferEXT().
319 */
320static void
321st_bind_framebuffer(GLcontext *ctx, GLenum target,
322                    struct gl_framebuffer *fb, struct gl_framebuffer *fbread)
323{
324
325}
326
327/**
328 * Called by ctx->Driver.FramebufferRenderbuffer
329 */
330static void
331st_framebuffer_renderbuffer(GLcontext *ctx,
332                            struct gl_framebuffer *fb,
333                            GLenum attachment,
334                            struct gl_renderbuffer *rb)
335{
336   /* XXX no need for derivation? */
337   _mesa_framebuffer_renderbuffer(ctx, fb, attachment, rb);
338}
339
340
341/**
342 * Called by ctx->Driver.RenderTexture
343 */
344static void
345st_render_texture(GLcontext *ctx,
346                  struct gl_framebuffer *fb,
347                  struct gl_renderbuffer_attachment *att)
348{
349   struct pipe_screen *screen = ctx->st->pipe->screen;
350   struct st_renderbuffer *strb;
351   struct gl_renderbuffer *rb;
352   struct pipe_texture *pt = st_get_texobj_texture(att->Texture);
353   struct st_texture_object *stObj;
354   const struct gl_texture_image *texImage =
355      att->Texture->Image[att->CubeMapFace][att->TextureLevel];
356
357   if (!pt)
358      return;
359
360   /* create new renderbuffer which wraps the texture image */
361   rb = st_new_renderbuffer(ctx, 0);
362   if (!rb) {
363      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glFramebufferTexture()");
364      return;
365   }
366
367   _mesa_reference_renderbuffer(&att->Renderbuffer, rb);
368   assert(rb->RefCount == 1);
369   rb->AllocStorage = NULL; /* should not get called */
370   strb = st_renderbuffer(rb);
371
372   assert(strb->Base.RefCount > 0);
373
374   /* get the texture for the texture object */
375   stObj = st_texture_object(att->Texture);
376
377   /* point renderbuffer at texobject */
378   strb->rtt = stObj;
379   strb->rtt_level = att->TextureLevel;
380   strb->rtt_face = att->CubeMapFace;
381   strb->rtt_slice = att->Zoffset;
382
383   rb->Width = texImage->Width2;
384   rb->Height = texImage->Height2;
385   /*printf("***** render to texture level %d: %d x %d\n", att->TextureLevel, rb->Width, rb->Height);*/
386
387   /*printf("***** pipe texture %d x %d\n", pt->width[0], pt->height[0]);*/
388
389   pipe_texture_reference( &strb->texture, pt );
390
391   pipe_surface_reference(&strb->surface, NULL);
392
393   /* new surface for rendering into the texture */
394   strb->surface = screen->get_tex_surface(screen,
395                                           strb->texture,
396                                           strb->rtt_face,
397                                           strb->rtt_level,
398                                           strb->rtt_slice,
399                                           PIPE_BUFFER_USAGE_GPU_READ |
400                                           PIPE_BUFFER_USAGE_GPU_WRITE);
401
402   init_renderbuffer_bits(strb, pt->format);
403
404   /*
405   printf("RENDER TO TEXTURE obj=%p pt=%p surf=%p  %d x %d\n",
406          att->Texture, pt, strb->surface, rb->Width, rb->Height);
407   */
408
409   /* Invalidate buffer state so that the pipe's framebuffer state
410    * gets updated.
411    * That's where the new renderbuffer (which we just created) gets
412    * passed to the pipe as a (color/depth) render target.
413    */
414   st_invalidate_state(ctx, _NEW_BUFFERS);
415}
416
417
418/**
419 * Called via ctx->Driver.FinishRenderTexture.
420 */
421static void
422st_finish_render_texture(GLcontext *ctx,
423                         struct gl_renderbuffer_attachment *att)
424{
425   struct st_renderbuffer *strb = st_renderbuffer(att->Renderbuffer);
426
427   if (!strb)
428      return;
429
430   st_flush( ctx->st, PIPE_FLUSH_RENDER_CACHE, NULL );
431
432   if (strb->surface)
433      pipe_surface_reference( &strb->surface, NULL );
434
435   strb->rtt = NULL;
436
437   /*
438   printf("FINISH RENDER TO TEXTURE surf=%p\n", strb->surface);
439   */
440
441   _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
442
443   /* restore previous framebuffer state */
444   st_invalidate_state(ctx, _NEW_BUFFERS);
445}
446
447
448/**
449 * Check that the framebuffer configuration is valid in terms of what
450 * the driver can support.
451 *
452 * For Gallium we only supports combined Z+stencil, not separate buffers.
453 */
454static void
455st_validate_framebuffer(GLcontext *ctx, struct gl_framebuffer *fb)
456{
457   const struct gl_renderbuffer *depthRb =
458      fb->Attachment[BUFFER_DEPTH].Renderbuffer;
459   const struct gl_renderbuffer *stencilRb =
460      fb->Attachment[BUFFER_STENCIL].Renderbuffer;
461
462   if (stencilRb && depthRb && stencilRb != depthRb) {
463      fb->_Status = GL_FRAMEBUFFER_UNSUPPORTED_EXT;
464   }
465}
466
467
468/**
469 * Copy back color buffer to front color buffer.
470 */
471static void
472copy_back_to_front(struct st_context *st,
473                   struct gl_framebuffer *fb,
474                   gl_buffer_index frontIndex,
475                   gl_buffer_index backIndex)
476
477{
478   struct st_framebuffer *stfb = (struct st_framebuffer *) fb;
479   struct pipe_surface *surf_front, *surf_back;
480
481   (void) st_get_framebuffer_surface(stfb, frontIndex, &surf_front);
482   (void) st_get_framebuffer_surface(stfb, backIndex, &surf_back);
483
484   if (surf_front && surf_back) {
485      st->pipe->surface_copy(st->pipe,
486                             surf_front, 0, 0,  /* dest */
487                             surf_back, 0, 0,   /* src */
488                             fb->Width, fb->Height);
489   }
490}
491
492
493/**
494 * Check if we're drawing into, or read from, a front color buffer.  If the
495 * front buffer is missing, create it now.
496 *
497 * The back color buffer must exist since we'll use its format/samples info
498 * for creating the front buffer.
499 *
500 * \param frontIndex  either BUFFER_FRONT_LEFT or BUFFER_FRONT_RIGHT
501 * \param backIndex  either BUFFER_BACK_LEFT or BUFFER_BACK_RIGHT
502 */
503static void
504check_create_front_buffer(GLcontext *ctx, struct gl_framebuffer *fb,
505                          gl_buffer_index frontIndex,
506                          gl_buffer_index backIndex)
507{
508   if (fb->Attachment[frontIndex].Renderbuffer == NULL) {
509      GLboolean create = GL_FALSE;
510
511      /* check if drawing to or reading from front buffer */
512      if (fb->_ColorReadBufferIndex == frontIndex) {
513         create = GL_TRUE;
514      }
515      else {
516         GLuint b;
517         for (b = 0; b < fb->_NumColorDrawBuffers; b++) {
518            if (fb->_ColorDrawBufferIndexes[b] == frontIndex) {
519               create = GL_TRUE;
520               break;
521            }
522         }
523      }
524
525      if (create) {
526         struct st_renderbuffer *back;
527         struct gl_renderbuffer *front;
528         enum pipe_format colorFormat;
529         uint samples;
530
531         if (0)
532            _mesa_debug(ctx, "Allocate new front buffer\n");
533
534         /* get back renderbuffer info */
535         back = st_renderbuffer(fb->Attachment[backIndex].Renderbuffer);
536         colorFormat = back->format;
537         samples = back->Base.NumSamples;
538
539         /* create front renderbuffer */
540         front = st_new_renderbuffer_fb(colorFormat, samples, FALSE);
541         _mesa_add_renderbuffer(fb, frontIndex, front);
542
543         /* alloc texture/surface for new front buffer */
544         front->AllocStorage(ctx, front, front->InternalFormat,
545                             fb->Width, fb->Height);
546
547         /* initialize the front color buffer contents by copying
548          * the back buffer.
549          */
550         copy_back_to_front(ctx->st, fb, frontIndex, backIndex);
551      }
552   }
553}
554
555
556/**
557 * If front left/right color buffers are missing, create them now.
558 */
559static void
560check_create_front_buffers(GLcontext *ctx, struct gl_framebuffer *fb)
561{
562   /* check if we need to create the front left buffer now */
563   check_create_front_buffer(ctx, fb, BUFFER_FRONT_LEFT, BUFFER_BACK_LEFT);
564
565   if (fb->Visual.stereoMode) {
566      check_create_front_buffer(ctx, fb, BUFFER_FRONT_RIGHT, BUFFER_BACK_RIGHT);
567   }
568
569   st_invalidate_state(ctx, _NEW_BUFFERS);
570}
571
572
573/**
574 * Called via glDrawBuffer.
575 */
576static void
577st_DrawBuffers(GLcontext *ctx, GLsizei count, const GLenum *buffers)
578{
579   (void) count;
580   (void) buffers;
581   check_create_front_buffers(ctx, ctx->DrawBuffer);
582}
583
584
585/**
586 * Called via glReadBuffer.
587 */
588static void
589st_ReadBuffer(GLcontext *ctx, GLenum buffer)
590{
591   (void) buffer;
592   check_create_front_buffers(ctx, ctx->ReadBuffer);
593}
594
595
596void st_init_fbo_functions(struct dd_function_table *functions)
597{
598   functions->NewFramebuffer = st_new_framebuffer;
599   functions->NewRenderbuffer = st_new_renderbuffer;
600   functions->BindFramebuffer = st_bind_framebuffer;
601   functions->FramebufferRenderbuffer = st_framebuffer_renderbuffer;
602   functions->RenderTexture = st_render_texture;
603   functions->FinishRenderTexture = st_finish_render_texture;
604   functions->ValidateFramebuffer = st_validate_framebuffer;
605   /* no longer needed by core Mesa, drivers handle resizes...
606   functions->ResizeBuffers = st_resize_buffers;
607   */
608
609   functions->DrawBuffers = st_DrawBuffers;
610   functions->ReadBuffer = st_ReadBuffer;
611}
612