1 /**************************************************************************
3 * Copyright 2006 VMware, Inc.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portionsalloc
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.
26 **************************************************************************/
28 #include "main/blend.h"
29 #include "main/glheader.h"
30 #include "main/enums.h"
31 #include "main/image.h"
32 #include "main/colormac.h"
33 #include "main/condrender.h"
34 #include "main/mtypes.h"
35 #include "main/macros.h"
37 #include "main/bufferobj.h"
38 #include "main/state.h"
39 #include "main/texobj.h"
40 #include "main/context.h"
41 #include "main/fbobject.h"
42 #include "swrast/swrast.h"
43 #include "drivers/common/meta.h"
45 #include "brw_context.h"
46 #include "intel_screen.h"
47 #include "intel_batchbuffer.h"
48 #include "intel_blit.h"
49 #include "intel_fbo.h"
50 #include "intel_regions.h"
51 #include "intel_buffers.h"
52 #include "intel_pixel.h"
53 #include "intel_reg.h"
56 #define FILE_DEBUG_FLAG DEBUG_PIXEL
59 /* Unlike the other intel_pixel_* functions, the expectation here is
60 * that the incoming data is not in a PBO. With the XY_TEXT blit
61 * method, there's no benefit haveing it in a PBO, but we could
62 * implement a path based on XY_MONO_SRC_COPY_BLIT which might benefit
63 * PBO bitmaps. I think they are probably pretty rare though - I
64 * wonder if Xgl uses them?
66 static const GLubyte
*map_pbo( struct gl_context
*ctx
,
67 GLsizei width
, GLsizei height
,
68 const struct gl_pixelstore_attrib
*unpack
,
69 const GLubyte
*bitmap
)
73 if (!_mesa_validate_pbo_access(2, unpack
, width
, height
, 1,
74 GL_COLOR_INDEX
, GL_BITMAP
,
75 INT_MAX
, (const GLvoid
*) bitmap
)) {
76 _mesa_error(ctx
, GL_INVALID_OPERATION
,"glBitmap(invalid PBO access)");
80 buf
= (GLubyte
*) ctx
->Driver
.MapBufferRange(ctx
, 0, unpack
->BufferObj
->Size
,
85 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glBitmap(PBO is mapped)");
89 return ADD_POINTERS(buf
, bitmap
);
92 static bool test_bit( const GLubyte
*src
, GLuint bit
)
94 return (src
[bit
/8] & (1<<(bit
% 8))) ? 1 : 0;
97 static void set_bit( GLubyte
*dest
, GLuint bit
)
99 dest
[bit
/8] |= 1 << (bit
% 8);
102 /* Extract a rectangle's worth of data from the bitmap. Called
103 * per chunk of HW-sized bitmap.
105 static GLuint
get_bitmap_rect(GLsizei width
, GLsizei height
,
106 const struct gl_pixelstore_attrib
*unpack
,
107 const GLubyte
*bitmap
,
114 GLuint src_offset
= (x
+ unpack
->SkipPixels
) & 0x7;
115 GLuint mask
= unpack
->LsbFirst
? 0 : 7;
122 DBG("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n",
123 __FUNCTION__
, x
,y
,w
,h
,width
,height
,unpack
->SkipPixels
, src_offset
, mask
);
136 /* Require that dest be pre-zero'd.
138 for (row
= first
; row
!= (last
+incr
); row
+= incr
) {
139 const GLubyte
*rowsrc
= _mesa_image_address2d(unpack
, bitmap
,
141 GL_COLOR_INDEX
, GL_BITMAP
,
144 for (col
= 0; col
< w
; col
++, bit
++) {
145 if (test_bit(rowsrc
, (col
+ src_offset
) ^ mask
)) {
146 set_bit(dest
, bit
^ 7);
152 bit
= ALIGN(bit
, row_align
);
159 * Returns the low Y value of the vertical range given, flipped according to
160 * whether the framebuffer is or not.
163 y_flip(struct gl_framebuffer
*fb
, int y
, int height
)
165 if (_mesa_is_user_fbo(fb
))
168 return fb
->Height
- y
- height
;
175 do_blit_bitmap( struct gl_context
*ctx
,
176 GLint dstx
, GLint dsty
,
177 GLsizei width
, GLsizei height
,
178 const struct gl_pixelstore_attrib
*unpack
,
179 const GLubyte
*bitmap
)
181 struct brw_context
*brw
= brw_context(ctx
);
182 struct gl_framebuffer
*fb
= ctx
->DrawBuffer
;
183 struct intel_renderbuffer
*irb
;
187 GLsizei bitmap_width
= width
;
188 GLsizei bitmap_height
= height
;
191 GLint orig_dstx
= dstx
;
192 GLint orig_dsty
= dsty
;
194 /* Update draw buffer bounds */
195 _mesa_update_state(ctx
);
197 if (ctx
->Depth
.Test
) {
198 /* The blit path produces incorrect results when depth testing is on.
199 * It seems the blit Z coord is always 1.0 (the far plane) so fragments
200 * will likely be obscured by other, closer geometry.
205 intel_prepare_render(brw
);
207 if (fb
->_NumColorDrawBuffers
!= 1) {
208 perf_debug("accelerated glBitmap() only supports rendering to a "
209 "single color buffer\n");
213 irb
= intel_renderbuffer(fb
->_ColorDrawBuffers
[0]);
215 if (_mesa_is_bufferobj(unpack
->BufferObj
)) {
216 bitmap
= map_pbo(ctx
, width
, height
, unpack
, bitmap
);
218 return true; /* even though this is an error, we're done */
221 COPY_4V(tmpColor
, ctx
->Current
.RasterColor
);
223 if (_mesa_need_secondary_color(ctx
)) {
224 ADD_3V(tmpColor
, tmpColor
, ctx
->Current
.RasterSecondaryColor
);
227 UNCLAMPED_FLOAT_TO_UBYTE(ubcolor
[0], tmpColor
[0]);
228 UNCLAMPED_FLOAT_TO_UBYTE(ubcolor
[1], tmpColor
[1]);
229 UNCLAMPED_FLOAT_TO_UBYTE(ubcolor
[2], tmpColor
[2]);
230 UNCLAMPED_FLOAT_TO_UBYTE(ubcolor
[3], tmpColor
[3]);
232 switch (_mesa_get_render_format(ctx
, intel_rb_format(irb
))) {
233 case MESA_FORMAT_B8G8R8A8_UNORM
:
234 case MESA_FORMAT_B8G8R8X8_UNORM
:
235 color
= PACK_COLOR_8888(ubcolor
[3], ubcolor
[0], ubcolor
[1], ubcolor
[2]);
237 case MESA_FORMAT_B5G6R5_UNORM
:
238 color
= PACK_COLOR_565(ubcolor
[0], ubcolor
[1], ubcolor
[2]);
241 perf_debug("Unsupported format %s in accelerated glBitmap()\n",
242 _mesa_get_format_name(irb
->mt
->format
));
246 if (!intel_check_blit_fragment_ops(ctx
, tmpColor
[3] == 1.0F
))
249 /* Clip to buffer bounds and scissor. */
250 if (!_mesa_clip_to_region(fb
->_Xmin
, fb
->_Ymin
,
251 fb
->_Xmax
, fb
->_Ymax
,
252 &dstx
, &dsty
, &width
, &height
))
255 dsty
= y_flip(fb
, dsty
, height
);
260 /* The blitter has no idea about fast color clears, so we need to resolve
261 * the miptree before we do anything.
263 intel_miptree_resolve_color(brw
, irb
->mt
);
265 /* Chop it all into chunks that can be digested by hardware: */
266 for (py
= 0; py
< height
; py
+= DY
) {
267 for (px
= 0; px
< width
; px
+= DX
) {
268 int h
= MIN2(DY
, height
- py
);
269 int w
= MIN2(DX
, width
- px
);
270 GLuint sz
= ALIGN(ALIGN(w
,8) * h
, 64)/8;
271 GLenum logic_op
= ctx
->Color
.ColorLogicOpEnabled
?
272 ctx
->Color
.LogicOp
: GL_COPY
;
274 assert(sz
<= sizeof(stipple
));
275 memset(stipple
, 0, sz
);
277 /* May need to adjust this when padding has been introduced in
280 * Have to translate destination coordinates back into source
283 int count
= get_bitmap_rect(bitmap_width
, bitmap_height
, unpack
,
285 -orig_dstx
+ (dstx
+ px
),
286 -orig_dsty
+ y_flip(fb
, dsty
+ py
, h
),
290 _mesa_is_winsys_fbo(fb
));
294 if (!intelEmitImmediateColorExpandBlit(brw
,
299 irb
->mt
->region
->pitch
,
302 irb
->mt
->region
->tiling
,
310 if (ctx
->Query
.CurrentOcclusionObject
)
311 ctx
->Query
.CurrentOcclusionObject
->Result
+= count
;
316 if (unlikely(INTEL_DEBUG
& DEBUG_SYNC
))
317 intel_batchbuffer_flush(brw
);
319 if (_mesa_is_bufferobj(unpack
->BufferObj
)) {
320 /* done with PBO so unmap it now */
321 ctx
->Driver
.UnmapBuffer(ctx
, unpack
->BufferObj
, MAP_INTERNAL
);
324 intel_check_front_buffer_rendering(brw
);
330 /* There are a large number of possible ways to implement bitmap on
331 * this hardware, most of them have some sort of drawback. Here are a
332 * few that spring to mind:
335 * - XY_MONO_SRC_BLT_CMD
336 * - use XY_SETUP_CLIP_BLT for cliprect clipping.
338 * - XY_TEXT_IMMEDIATE_BLT
339 * - blit per cliprect, subject to maximum immediate data size.
341 * - per pixel or run of pixels
343 * - good for sparse bitmaps
347 * - Translate bitmap to an alpha texture and render as a quad
348 * - Chop bitmap up into 32x32 squares and render w/polygon stipple.
351 intelBitmap(struct gl_context
* ctx
,
353 GLsizei width
, GLsizei height
,
354 const struct gl_pixelstore_attrib
*unpack
,
355 const GLubyte
* pixels
)
357 if (!_mesa_check_conditional_render(ctx
))
360 if (do_blit_bitmap(ctx
, x
, y
, width
, height
,
364 _mesa_meta_Bitmap(ctx
, x
, y
, width
, height
, unpack
, pixels
);