1/*
2 * Mesa 3-D graphics library
3 * Version:  7.2
4 *
5 * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions 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 MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26/**
27 * Functions for allocating/managing framebuffers and renderbuffers.
28 * Also, routines for reading/writing renderbuffer data as ubytes,
29 * ushorts, uints, etc.
30 */
31
32
33#include "glheader.h"
34#include "imports.h"
35#include "buffers.h"
36#include "context.h"
37#include "enums.h"
38#include "formats.h"
39#include "macros.h"
40#include "mtypes.h"
41#include "fbobject.h"
42#include "framebuffer.h"
43#include "renderbuffer.h"
44#include "texobj.h"
45
46
47
48/**
49 * Compute/set the _DepthMax field for the given framebuffer.
50 * This value depends on the Z buffer resolution.
51 */
52static void
53compute_depth_max(struct gl_framebuffer *fb)
54{
55   if (fb->Visual.depthBits == 0) {
56      /* Special case.  Even if we don't have a depth buffer we need
57       * good values for DepthMax for Z vertex transformation purposes
58       * and for per-fragment fog computation.
59       */
60      fb->_DepthMax = (1 << 16) - 1;
61   }
62   else if (fb->Visual.depthBits < 32) {
63      fb->_DepthMax = (1 << fb->Visual.depthBits) - 1;
64   }
65   else {
66      /* Special case since shift values greater than or equal to the
67       * number of bits in the left hand expression's type are undefined.
68       */
69      fb->_DepthMax = 0xffffffff;
70   }
71   fb->_DepthMaxF = (GLfloat) fb->_DepthMax;
72
73   /* Minimum resolvable depth value, for polygon offset */
74   fb->_MRD = (GLfloat)1.0 / fb->_DepthMaxF;
75}
76
77/**
78 * Create and initialize a gl_framebuffer object.
79 * This is intended for creating _window_system_ framebuffers, not generic
80 * framebuffer objects ala GL_EXT_framebuffer_object.
81 *
82 * \sa _mesa_new_framebuffer
83 */
84struct gl_framebuffer *
85_mesa_create_framebuffer(const struct gl_config *visual)
86{
87   struct gl_framebuffer *fb = CALLOC_STRUCT(gl_framebuffer);
88   assert(visual);
89   if (fb) {
90      _mesa_initialize_window_framebuffer(fb, visual);
91   }
92   return fb;
93}
94
95
96/**
97 * Allocate a new gl_framebuffer object.
98 * This is the default function for ctx->Driver.NewFramebuffer().
99 * This is for allocating user-created framebuffers, not window-system
100 * framebuffers!
101 * \sa _mesa_create_framebuffer
102 */
103struct gl_framebuffer *
104_mesa_new_framebuffer(struct gl_context *ctx, GLuint name)
105{
106   struct gl_framebuffer *fb;
107   (void) ctx;
108   assert(name != 0);
109   fb = CALLOC_STRUCT(gl_framebuffer);
110   if (fb) {
111      _mesa_initialize_user_framebuffer(fb, name);
112   }
113   return fb;
114}
115
116
117/**
118 * Initialize a gl_framebuffer object.  Typically used to initialize
119 * window system-created framebuffers, not user-created framebuffers.
120 * \sa _mesa_initialize_user_framebuffer
121 */
122void
123_mesa_initialize_window_framebuffer(struct gl_framebuffer *fb,
124				     const struct gl_config *visual)
125{
126   assert(fb);
127   assert(visual);
128
129   memset(fb, 0, sizeof(struct gl_framebuffer));
130
131   _glthread_INIT_MUTEX(fb->Mutex);
132
133   fb->RefCount = 1;
134
135   /* save the visual */
136   fb->Visual = *visual;
137
138   /* Init read/draw renderbuffer state */
139   if (visual->doubleBufferMode) {
140      fb->_NumColorDrawBuffers = 1;
141      fb->ColorDrawBuffer[0] = GL_BACK;
142      fb->_ColorDrawBufferIndexes[0] = BUFFER_BACK_LEFT;
143      fb->ColorReadBuffer = GL_BACK;
144      fb->_ColorReadBufferIndex = BUFFER_BACK_LEFT;
145   }
146   else {
147      fb->_NumColorDrawBuffers = 1;
148      fb->ColorDrawBuffer[0] = GL_FRONT;
149      fb->_ColorDrawBufferIndexes[0] = BUFFER_FRONT_LEFT;
150      fb->ColorReadBuffer = GL_FRONT;
151      fb->_ColorReadBufferIndex = BUFFER_FRONT_LEFT;
152   }
153
154   fb->Delete = _mesa_destroy_framebuffer;
155   fb->_Status = GL_FRAMEBUFFER_COMPLETE_EXT;
156
157   compute_depth_max(fb);
158}
159
160
161/**
162 * Initialize a user-created gl_framebuffer object.
163 * \sa _mesa_initialize_window_framebuffer
164 */
165void
166_mesa_initialize_user_framebuffer(struct gl_framebuffer *fb, GLuint name)
167{
168   assert(fb);
169   assert(name);
170
171   memset(fb, 0, sizeof(struct gl_framebuffer));
172
173   fb->Name = name;
174   fb->RefCount = 1;
175   fb->_NumColorDrawBuffers = 1;
176   fb->ColorDrawBuffer[0] = GL_COLOR_ATTACHMENT0_EXT;
177   fb->_ColorDrawBufferIndexes[0] = BUFFER_COLOR0;
178   fb->ColorReadBuffer = GL_COLOR_ATTACHMENT0_EXT;
179   fb->_ColorReadBufferIndex = BUFFER_COLOR0;
180   fb->Delete = _mesa_destroy_framebuffer;
181   _glthread_INIT_MUTEX(fb->Mutex);
182}
183
184
185/**
186 * Deallocate buffer and everything attached to it.
187 * Typically called via the gl_framebuffer->Delete() method.
188 */
189void
190_mesa_destroy_framebuffer(struct gl_framebuffer *fb)
191{
192   if (fb) {
193      _mesa_free_framebuffer_data(fb);
194      free(fb);
195   }
196}
197
198
199/**
200 * Free all the data hanging off the given gl_framebuffer, but don't free
201 * the gl_framebuffer object itself.
202 */
203void
204_mesa_free_framebuffer_data(struct gl_framebuffer *fb)
205{
206   GLuint i;
207
208   assert(fb);
209   assert(fb->RefCount == 0);
210
211   _glthread_DESTROY_MUTEX(fb->Mutex);
212
213   for (i = 0; i < BUFFER_COUNT; i++) {
214      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
215      if (att->Renderbuffer) {
216         _mesa_reference_renderbuffer(&att->Renderbuffer, NULL);
217      }
218      if (att->Texture) {
219         _mesa_reference_texobj(&att->Texture, NULL);
220      }
221      ASSERT(!att->Renderbuffer);
222      ASSERT(!att->Texture);
223      att->Type = GL_NONE;
224   }
225}
226
227
228/**
229 * Set *ptr to point to fb, with refcounting and locking.
230 * This is normally only called from the _mesa_reference_framebuffer() macro
231 * when there's a real pointer change.
232 */
233void
234_mesa_reference_framebuffer_(struct gl_framebuffer **ptr,
235                             struct gl_framebuffer *fb)
236{
237   if (*ptr) {
238      /* unreference old renderbuffer */
239      GLboolean deleteFlag = GL_FALSE;
240      struct gl_framebuffer *oldFb = *ptr;
241
242      _glthread_LOCK_MUTEX(oldFb->Mutex);
243      ASSERT(oldFb->RefCount > 0);
244      oldFb->RefCount--;
245      deleteFlag = (oldFb->RefCount == 0);
246      _glthread_UNLOCK_MUTEX(oldFb->Mutex);
247
248      if (deleteFlag)
249         oldFb->Delete(oldFb);
250
251      *ptr = NULL;
252   }
253   assert(!*ptr);
254
255   if (fb) {
256      _glthread_LOCK_MUTEX(fb->Mutex);
257      fb->RefCount++;
258      _glthread_UNLOCK_MUTEX(fb->Mutex);
259      *ptr = fb;
260   }
261}
262
263
264/**
265 * Resize the given framebuffer's renderbuffers to the new width and height.
266 * This should only be used for window-system framebuffers, not
267 * user-created renderbuffers (i.e. made with GL_EXT_framebuffer_object).
268 * This will typically be called via ctx->Driver.ResizeBuffers() or directly
269 * from a device driver.
270 *
271 * \note it's possible for ctx to be null since a window can be resized
272 * without a currently bound rendering context.
273 */
274void
275_mesa_resize_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb,
276                         GLuint width, GLuint height)
277{
278   GLuint i;
279
280   /* XXX I think we could check if the size is not changing
281    * and return early.
282    */
283
284   /* Can only resize win-sys framebuffer objects */
285   assert(_mesa_is_winsys_fbo(fb));
286
287   for (i = 0; i < BUFFER_COUNT; i++) {
288      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
289      if (att->Type == GL_RENDERBUFFER_EXT && att->Renderbuffer) {
290         struct gl_renderbuffer *rb = att->Renderbuffer;
291         /* only resize if size is changing */
292         if (rb->Width != width || rb->Height != height) {
293            if (rb->AllocStorage(ctx, rb, rb->InternalFormat, width, height)) {
294               ASSERT(rb->Width == width);
295               ASSERT(rb->Height == height);
296            }
297            else {
298               _mesa_error(ctx, GL_OUT_OF_MEMORY, "Resizing framebuffer");
299               /* no return */
300            }
301         }
302      }
303   }
304
305   fb->Width = width;
306   fb->Height = height;
307
308   if (ctx) {
309      /* update scissor / window bounds */
310      _mesa_update_draw_buffer_bounds(ctx);
311      /* Signal new buffer state so that swrast will update its clipping
312       * info (the CLIP_BIT flag).
313       */
314      ctx->NewState |= _NEW_BUFFERS;
315   }
316}
317
318
319
320/**
321 * XXX THIS IS OBSOLETE - drivers should take care of detecting window
322 * size changes and act accordingly, likely calling _mesa_resize_framebuffer().
323 *
324 * GL_MESA_resize_buffers extension.
325 *
326 * When this function is called, we'll ask the window system how large
327 * the current window is.  If it's a new size, we'll call the driver's
328 * ResizeBuffers function.  The driver will then resize its color buffers
329 * as needed, and maybe call the swrast's routine for reallocating
330 * swrast-managed depth/stencil/accum/etc buffers.
331 * \note This function should only be called through the GL API, not
332 * from device drivers (as was done in the past).
333 */
334void
335_mesa_resizebuffers( struct gl_context *ctx )
336{
337   ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH( ctx );
338
339   if (MESA_VERBOSE & VERBOSE_API)
340      _mesa_debug(ctx, "glResizeBuffersMESA\n");
341
342   if (!ctx->Driver.GetBufferSize) {
343      return;
344   }
345
346   if (ctx->WinSysDrawBuffer) {
347      GLuint newWidth, newHeight;
348      struct gl_framebuffer *buffer = ctx->WinSysDrawBuffer;
349
350      assert(_mesa_is_winsys_fbo(buffer));
351
352      /* ask device driver for size of output buffer */
353      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
354
355      /* see if size of device driver's color buffer (window) has changed */
356      if (buffer->Width != newWidth || buffer->Height != newHeight) {
357         if (ctx->Driver.ResizeBuffers)
358            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
359      }
360   }
361
362   if (ctx->WinSysReadBuffer
363       && ctx->WinSysReadBuffer != ctx->WinSysDrawBuffer) {
364      GLuint newWidth, newHeight;
365      struct gl_framebuffer *buffer = ctx->WinSysReadBuffer;
366
367      assert(_mesa_is_winsys_fbo(buffer));
368
369      /* ask device driver for size of read buffer */
370      ctx->Driver.GetBufferSize( buffer, &newWidth, &newHeight );
371
372      /* see if size of device driver's color buffer (window) has changed */
373      if (buffer->Width != newWidth || buffer->Height != newHeight) {
374         if (ctx->Driver.ResizeBuffers)
375            ctx->Driver.ResizeBuffers(ctx, buffer, newWidth, newHeight );
376      }
377   }
378
379   ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */
380}
381
382
383/*
384 * XXX THIS IS OBSOLETE
385 */
386void GLAPIENTRY
387_mesa_ResizeBuffersMESA( void )
388{
389   GET_CURRENT_CONTEXT(ctx);
390
391   if (ctx->Extensions.MESA_resize_buffers)
392      _mesa_resizebuffers( ctx );
393}
394
395
396
397/**
398 * Examine all the framebuffer's renderbuffers to update the Width/Height
399 * fields of the framebuffer.  If we have renderbuffers with different
400 * sizes, set the framebuffer's width and height to the min size.
401 * Note: this is only intended for user-created framebuffers, not
402 * window-system framebuffes.
403 */
404static void
405update_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
406{
407   GLuint minWidth = ~0, minHeight = ~0;
408   GLuint i;
409
410   /* user-created framebuffers only */
411   assert(_mesa_is_user_fbo(fb));
412
413   for (i = 0; i < BUFFER_COUNT; i++) {
414      struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
415      const struct gl_renderbuffer *rb = att->Renderbuffer;
416      if (rb) {
417         minWidth = MIN2(minWidth, rb->Width);
418         minHeight = MIN2(minHeight, rb->Height);
419      }
420   }
421
422   if (minWidth != ~0) {
423      fb->Width = minWidth;
424      fb->Height = minHeight;
425   }
426   else {
427      fb->Width = 0;
428      fb->Height = 0;
429   }
430}
431
432
433/**
434 * Update the context's current drawing buffer's Xmin, Xmax, Ymin, Ymax fields.
435 * These values are computed from the buffer's width and height and
436 * the scissor box, if it's enabled.
437 * \param ctx  the GL context.
438 */
439void
440_mesa_update_draw_buffer_bounds(struct gl_context *ctx)
441{
442   struct gl_framebuffer *buffer = ctx->DrawBuffer;
443
444   if (!buffer)
445      return;
446
447   if (_mesa_is_user_fbo(buffer)) {
448      /* user-created framebuffer size depends on the renderbuffers */
449      update_framebuffer_size(ctx, buffer);
450   }
451
452   buffer->_Xmin = 0;
453   buffer->_Ymin = 0;
454   buffer->_Xmax = buffer->Width;
455   buffer->_Ymax = buffer->Height;
456
457   if (ctx->Scissor.Enabled) {
458      if (ctx->Scissor.X > buffer->_Xmin) {
459	 buffer->_Xmin = ctx->Scissor.X;
460      }
461      if (ctx->Scissor.Y > buffer->_Ymin) {
462	 buffer->_Ymin = ctx->Scissor.Y;
463      }
464      if (ctx->Scissor.X + ctx->Scissor.Width < buffer->_Xmax) {
465	 buffer->_Xmax = ctx->Scissor.X + ctx->Scissor.Width;
466      }
467      if (ctx->Scissor.Y + ctx->Scissor.Height < buffer->_Ymax) {
468	 buffer->_Ymax = ctx->Scissor.Y + ctx->Scissor.Height;
469      }
470      /* finally, check for empty region */
471      if (buffer->_Xmin > buffer->_Xmax) {
472         buffer->_Xmin = buffer->_Xmax;
473      }
474      if (buffer->_Ymin > buffer->_Ymax) {
475         buffer->_Ymin = buffer->_Ymax;
476      }
477   }
478
479   ASSERT(buffer->_Xmin <= buffer->_Xmax);
480   ASSERT(buffer->_Ymin <= buffer->_Ymax);
481}
482
483
484/**
485 * The glGet queries of the framebuffer red/green/blue size, stencil size,
486 * etc. are satisfied by the fields of ctx->DrawBuffer->Visual.  These can
487 * change depending on the renderbuffer bindings.  This function updates
488 * the given framebuffer's Visual from the current renderbuffer bindings.
489 *
490 * This may apply to user-created framebuffers or window system framebuffers.
491 *
492 * Also note: ctx->DrawBuffer->Visual.depthBits might not equal
493 * ctx->DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer.DepthBits.
494 * The former one is used to convert floating point depth values into
495 * integer Z values.
496 */
497void
498_mesa_update_framebuffer_visual(struct gl_context *ctx,
499				struct gl_framebuffer *fb)
500{
501   GLuint i;
502
503   memset(&fb->Visual, 0, sizeof(fb->Visual));
504   fb->Visual.rgbMode = GL_TRUE; /* assume this */
505
506#if 0 /* this _might_ be needed */
507   if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
508      /* leave visual fields zero'd */
509      return;
510   }
511#endif
512
513   /* find first RGB renderbuffer */
514   for (i = 0; i < BUFFER_COUNT; i++) {
515      if (fb->Attachment[i].Renderbuffer) {
516         const struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer;
517         const GLenum baseFormat = _mesa_get_format_base_format(rb->Format);
518         const gl_format fmt = rb->Format;
519
520         /* Grab samples and sampleBuffers from any attachment point (assuming
521          * the framebuffer is complete, we'll get the same answer from all
522          * attachments).
523          */
524         fb->Visual.samples = rb->NumSamples;
525         fb->Visual.sampleBuffers = rb->NumSamples > 0 ? 1 : 0;
526
527         if (_mesa_is_legal_color_format(ctx, baseFormat)) {
528            fb->Visual.redBits = _mesa_get_format_bits(fmt, GL_RED_BITS);
529            fb->Visual.greenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);
530            fb->Visual.blueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);
531            fb->Visual.alphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);
532            fb->Visual.rgbBits = fb->Visual.redBits
533               + fb->Visual.greenBits + fb->Visual.blueBits;
534            if (_mesa_get_format_color_encoding(fmt) == GL_SRGB)
535                fb->Visual.sRGBCapable = ctx->Extensions.EXT_framebuffer_sRGB;
536            break;
537         }
538      }
539   }
540
541   fb->Visual.floatMode = GL_FALSE;
542   for (i = 0; i < BUFFER_COUNT; i++) {
543      if (fb->Attachment[i].Renderbuffer) {
544         const struct gl_renderbuffer *rb = fb->Attachment[i].Renderbuffer;
545         const gl_format fmt = rb->Format;
546
547         if (_mesa_get_format_datatype(fmt) == GL_FLOAT) {
548            fb->Visual.floatMode = GL_TRUE;
549            break;
550         }
551      }
552   }
553
554   if (fb->Attachment[BUFFER_DEPTH].Renderbuffer) {
555      const struct gl_renderbuffer *rb =
556         fb->Attachment[BUFFER_DEPTH].Renderbuffer;
557      const gl_format fmt = rb->Format;
558      fb->Visual.haveDepthBuffer = GL_TRUE;
559      fb->Visual.depthBits = _mesa_get_format_bits(fmt, GL_DEPTH_BITS);
560   }
561
562   if (fb->Attachment[BUFFER_STENCIL].Renderbuffer) {
563      const struct gl_renderbuffer *rb =
564         fb->Attachment[BUFFER_STENCIL].Renderbuffer;
565      const gl_format fmt = rb->Format;
566      fb->Visual.haveStencilBuffer = GL_TRUE;
567      fb->Visual.stencilBits = _mesa_get_format_bits(fmt, GL_STENCIL_BITS);
568   }
569
570   if (fb->Attachment[BUFFER_ACCUM].Renderbuffer) {
571      const struct gl_renderbuffer *rb =
572         fb->Attachment[BUFFER_ACCUM].Renderbuffer;
573      const gl_format fmt = rb->Format;
574      fb->Visual.haveAccumBuffer = GL_TRUE;
575      fb->Visual.accumRedBits = _mesa_get_format_bits(fmt, GL_RED_BITS);
576      fb->Visual.accumGreenBits = _mesa_get_format_bits(fmt, GL_GREEN_BITS);
577      fb->Visual.accumBlueBits = _mesa_get_format_bits(fmt, GL_BLUE_BITS);
578      fb->Visual.accumAlphaBits = _mesa_get_format_bits(fmt, GL_ALPHA_BITS);
579   }
580
581   compute_depth_max(fb);
582}
583
584
585/*
586 * Example DrawBuffers scenarios:
587 *
588 * 1. glDrawBuffer(GL_FRONT_AND_BACK), fixed-func or shader writes to
589 * "gl_FragColor" or program writes to the "result.color" register:
590 *
591 *   fragment color output   renderbuffer
592 *   ---------------------   ---------------
593 *   color[0]                Front, Back
594 *
595 *
596 * 2. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]), shader writes to
597 * gl_FragData[i] or program writes to result.color[i] registers:
598 *
599 *   fragment color output   renderbuffer
600 *   ---------------------   ---------------
601 *   color[0]                Front
602 *   color[1]                Aux0
603 *   color[3]                Aux1
604 *
605 *
606 * 3. glDrawBuffers(3, [GL_FRONT, GL_AUX0, GL_AUX1]) and shader writes to
607 * gl_FragColor, or fixed function:
608 *
609 *   fragment color output   renderbuffer
610 *   ---------------------   ---------------
611 *   color[0]                Front, Aux0, Aux1
612 *
613 *
614 * In either case, the list of renderbuffers is stored in the
615 * framebuffer->_ColorDrawBuffers[] array and
616 * framebuffer->_NumColorDrawBuffers indicates the number of buffers.
617 * The renderer (like swrast) has to look at the current fragment shader
618 * to see if it writes to gl_FragColor vs. gl_FragData[i] to determine
619 * how to map color outputs to renderbuffers.
620 *
621 * Note that these two calls are equivalent (for fixed function fragment
622 * shading anyway):
623 *   a)  glDrawBuffer(GL_FRONT_AND_BACK);  (assuming non-stereo framebuffer)
624 *   b)  glDrawBuffers(2, [GL_FRONT_LEFT, GL_BACK_LEFT]);
625 */
626
627
628
629
630/**
631 * Update the (derived) list of color drawing renderbuffer pointers.
632 * Later, when we're rendering we'll loop from 0 to _NumColorDrawBuffers
633 * writing colors.
634 */
635static void
636update_color_draw_buffers(struct gl_context *ctx, struct gl_framebuffer *fb)
637{
638   GLuint output;
639
640   /* set 0th buffer to NULL now in case _NumColorDrawBuffers is zero */
641   fb->_ColorDrawBuffers[0] = NULL;
642
643   for (output = 0; output < fb->_NumColorDrawBuffers; output++) {
644      GLint buf = fb->_ColorDrawBufferIndexes[output];
645      if (buf >= 0) {
646         fb->_ColorDrawBuffers[output] = fb->Attachment[buf].Renderbuffer;
647      }
648      else {
649         fb->_ColorDrawBuffers[output] = NULL;
650      }
651   }
652}
653
654
655/**
656 * Update the (derived) color read renderbuffer pointer.
657 * Unlike the DrawBuffer, we can only read from one (or zero) color buffers.
658 */
659static void
660update_color_read_buffer(struct gl_context *ctx, struct gl_framebuffer *fb)
661{
662   (void) ctx;
663   if (fb->_ColorReadBufferIndex == -1 ||
664       fb->DeletePending ||
665       fb->Width == 0 ||
666       fb->Height == 0) {
667      fb->_ColorReadBuffer = NULL; /* legal! */
668   }
669   else {
670      ASSERT(fb->_ColorReadBufferIndex >= 0);
671      ASSERT(fb->_ColorReadBufferIndex < BUFFER_COUNT);
672      fb->_ColorReadBuffer
673         = fb->Attachment[fb->_ColorReadBufferIndex].Renderbuffer;
674   }
675}
676
677
678/**
679 * Update a gl_framebuffer's derived state.
680 *
681 * Specifically, update these framebuffer fields:
682 *    _ColorDrawBuffers
683 *    _NumColorDrawBuffers
684 *    _ColorReadBuffer
685 *
686 * If the framebuffer is user-created, make sure it's complete.
687 *
688 * The following functions (at least) can effect framebuffer state:
689 * glReadBuffer, glDrawBuffer, glDrawBuffersARB, glFramebufferRenderbufferEXT,
690 * glRenderbufferStorageEXT.
691 */
692static void
693update_framebuffer(struct gl_context *ctx, struct gl_framebuffer *fb)
694{
695   if (_mesa_is_winsys_fbo(fb)) {
696      /* This is a window-system framebuffer */
697      /* Need to update the FB's GL_DRAW_BUFFER state to match the
698       * context state (GL_READ_BUFFER too).
699       */
700      if (fb->ColorDrawBuffer[0] != ctx->Color.DrawBuffer[0]) {
701         _mesa_drawbuffers(ctx, ctx->Const.MaxDrawBuffers,
702                           ctx->Color.DrawBuffer, NULL);
703      }
704   }
705   else {
706      /* This is a user-created framebuffer.
707       * Completeness only matters for user-created framebuffers.
708       */
709      if (fb->_Status != GL_FRAMEBUFFER_COMPLETE) {
710         _mesa_test_framebuffer_completeness(ctx, fb);
711      }
712   }
713
714   /* Strictly speaking, we don't need to update the draw-state
715    * if this FB is bound as ctx->ReadBuffer (and conversely, the
716    * read-state if this FB is bound as ctx->DrawBuffer), but no
717    * harm.
718    */
719   update_color_draw_buffers(ctx, fb);
720   update_color_read_buffer(ctx, fb);
721
722   compute_depth_max(fb);
723}
724
725
726/**
727 * Update state related to the current draw/read framebuffers.
728 */
729void
730_mesa_update_framebuffer(struct gl_context *ctx)
731{
732   struct gl_framebuffer *drawFb;
733   struct gl_framebuffer *readFb;
734
735   assert(ctx);
736   drawFb = ctx->DrawBuffer;
737   readFb = ctx->ReadBuffer;
738
739   update_framebuffer(ctx, drawFb);
740   if (readFb != drawFb)
741      update_framebuffer(ctx, readFb);
742}
743
744
745/**
746 * Check if the renderbuffer for a read/draw operation exists.
747 * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
748 *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
749 * \param reading  if TRUE, we're going to read from the buffer,
750                   if FALSE, we're going to write to the buffer.
751 * \return GL_TRUE if buffer exists, GL_FALSE otherwise
752 */
753static GLboolean
754renderbuffer_exists(struct gl_context *ctx,
755                    struct gl_framebuffer *fb,
756                    GLenum format,
757                    GLboolean reading)
758{
759   const struct gl_renderbuffer_attachment *att = fb->Attachment;
760
761   /* If we don't know the framebuffer status, update it now */
762   if (fb->_Status == 0) {
763      _mesa_test_framebuffer_completeness(ctx, fb);
764   }
765
766   if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
767      return GL_FALSE;
768   }
769
770   switch (format) {
771   case GL_COLOR:
772   case GL_RED:
773   case GL_GREEN:
774   case GL_BLUE:
775   case GL_ALPHA:
776   case GL_LUMINANCE:
777   case GL_LUMINANCE_ALPHA:
778   case GL_INTENSITY:
779   case GL_RG:
780   case GL_RGB:
781   case GL_BGR:
782   case GL_RGBA:
783   case GL_BGRA:
784   case GL_ABGR_EXT:
785   case GL_RED_INTEGER_EXT:
786   case GL_RG_INTEGER:
787   case GL_GREEN_INTEGER_EXT:
788   case GL_BLUE_INTEGER_EXT:
789   case GL_ALPHA_INTEGER_EXT:
790   case GL_RGB_INTEGER_EXT:
791   case GL_RGBA_INTEGER_EXT:
792   case GL_BGR_INTEGER_EXT:
793   case GL_BGRA_INTEGER_EXT:
794   case GL_LUMINANCE_INTEGER_EXT:
795   case GL_LUMINANCE_ALPHA_INTEGER_EXT:
796      if (reading) {
797         /* about to read from a color buffer */
798         const struct gl_renderbuffer *readBuf = fb->_ColorReadBuffer;
799         if (!readBuf) {
800            return GL_FALSE;
801         }
802         ASSERT(_mesa_get_format_bits(readBuf->Format, GL_RED_BITS) > 0 ||
803                _mesa_get_format_bits(readBuf->Format, GL_ALPHA_BITS) > 0 ||
804                _mesa_get_format_bits(readBuf->Format, GL_TEXTURE_LUMINANCE_SIZE) > 0 ||
805                _mesa_get_format_bits(readBuf->Format, GL_TEXTURE_INTENSITY_SIZE) > 0 ||
806                _mesa_get_format_bits(readBuf->Format, GL_INDEX_BITS) > 0);
807      }
808      else {
809         /* about to draw to zero or more color buffers (none is OK) */
810         return GL_TRUE;
811      }
812      break;
813   case GL_DEPTH:
814   case GL_DEPTH_COMPONENT:
815      if (att[BUFFER_DEPTH].Type == GL_NONE) {
816         return GL_FALSE;
817      }
818      break;
819   case GL_STENCIL:
820   case GL_STENCIL_INDEX:
821      if (att[BUFFER_STENCIL].Type == GL_NONE) {
822         return GL_FALSE;
823      }
824      break;
825   case GL_DEPTH_STENCIL_EXT:
826      if (att[BUFFER_DEPTH].Type == GL_NONE ||
827          att[BUFFER_STENCIL].Type == GL_NONE) {
828         return GL_FALSE;
829      }
830      break;
831   default:
832      _mesa_problem(ctx,
833                    "Unexpected format 0x%x in renderbuffer_exists",
834                    format);
835      return GL_FALSE;
836   }
837
838   /* OK */
839   return GL_TRUE;
840}
841
842
843/**
844 * Check if the renderbuffer for a read operation (glReadPixels, glCopyPixels,
845 * glCopyTex[Sub]Image, etc) exists.
846 * \param format  a basic image format such as GL_RGB, GL_RGBA, GL_ALPHA,
847 *                GL_DEPTH_COMPONENT, etc. or GL_COLOR, GL_DEPTH, GL_STENCIL.
848 * \return GL_TRUE if buffer exists, GL_FALSE otherwise
849 */
850GLboolean
851_mesa_source_buffer_exists(struct gl_context *ctx, GLenum format)
852{
853   return renderbuffer_exists(ctx, ctx->ReadBuffer, format, GL_TRUE);
854}
855
856
857/**
858 * As above, but for drawing operations.
859 */
860GLboolean
861_mesa_dest_buffer_exists(struct gl_context *ctx, GLenum format)
862{
863   return renderbuffer_exists(ctx, ctx->DrawBuffer, format, GL_FALSE);
864}
865
866
867/**
868 * Used to answer the GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES query.
869 */
870GLenum
871_mesa_get_color_read_format(struct gl_context *ctx)
872{
873   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {
874   case MESA_FORMAT_ARGB8888:
875      return GL_BGRA;
876   case MESA_FORMAT_RGB565:
877      return GL_BGR;
878   default:
879      return GL_RGBA;
880   }
881}
882
883
884/**
885 * Used to answer the GL_IMPLEMENTATION_COLOR_READ_TYPE_OES query.
886 */
887GLenum
888_mesa_get_color_read_type(struct gl_context *ctx)
889{
890   switch (ctx->ReadBuffer->_ColorReadBuffer->Format) {
891   case MESA_FORMAT_ARGB8888:
892      return GL_UNSIGNED_BYTE;
893   case MESA_FORMAT_RGB565:
894      return GL_UNSIGNED_SHORT_5_6_5_REV;
895   default:
896      return GL_UNSIGNED_BYTE;
897   }
898}
899
900
901/**
902 * Print framebuffer info to stderr, for debugging.
903 */
904void
905_mesa_print_framebuffer(const struct gl_framebuffer *fb)
906{
907   GLuint i;
908
909   fprintf(stderr, "Mesa Framebuffer %u at %p\n", fb->Name, (void *) fb);
910   fprintf(stderr, "  Size: %u x %u  Status: %s\n", fb->Width, fb->Height,
911           _mesa_lookup_enum_by_nr(fb->_Status));
912   fprintf(stderr, "  Attachments:\n");
913
914   for (i = 0; i < BUFFER_COUNT; i++) {
915      const struct gl_renderbuffer_attachment *att = &fb->Attachment[i];
916      if (att->Type == GL_TEXTURE) {
917         const struct gl_texture_image *texImage =
918            _mesa_get_attachment_teximage_const(att);
919         fprintf(stderr,
920                 "  %2d: Texture %u, level %u, face %u, slice %u, complete %d\n",
921                 i, att->Texture->Name, att->TextureLevel, att->CubeMapFace,
922                 att->Zoffset, att->Complete);
923         fprintf(stderr, "       Size: %u x %u x %u  Format %s\n",
924                 texImage->Width, texImage->Height, texImage->Depth,
925                 _mesa_get_format_name(texImage->TexFormat));
926      }
927      else if (att->Type == GL_RENDERBUFFER) {
928         fprintf(stderr, "  %2d: Renderbuffer %u, complete %d\n",
929                 i, att->Renderbuffer->Name, att->Complete);
930         fprintf(stderr, "       Size: %u x %u  Format %s\n",
931                 att->Renderbuffer->Width, att->Renderbuffer->Height,
932                 _mesa_get_format_name(att->Renderbuffer->Format));
933      }
934      else {
935         fprintf(stderr, "  %2d: none\n", i);
936      }
937   }
938}
939