7c611cb4ec965802b984c71434f9c2e858e2d252
[mesa.git] / src / mesa / state_tracker / st_cb_drawpixels.c
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 * Authors:
30 * Brian Paul
31 */
32
33 #include "main/imports.h"
34 #include "main/image.h"
35 #include "main/bufferobj.h"
36 #include "main/macros.h"
37 #include "main/texformat.h"
38 #include "main/texstore.h"
39 #include "shader/program.h"
40 #include "shader/prog_print.h"
41
42 #include "st_debug.h"
43 #include "st_context.h"
44 #include "st_atom.h"
45 #include "st_atom_constbuf.h"
46 #include "st_program.h"
47 #include "st_cb_drawpixels.h"
48 #include "st_cb_readpixels.h"
49 #include "st_cb_fbo.h"
50 #include "st_format.h"
51 #include "st_texture.h"
52 #include "st_inlines.h"
53
54 #include "pipe/p_context.h"
55 #include "pipe/p_defines.h"
56 #include "util/u_inlines.h"
57 #include "tgsi/tgsi_ureg.h"
58 #include "util/u_tile.h"
59 #include "util/u_draw_quad.h"
60 #include "util/u_format.h"
61 #include "util/u_math.h"
62 #include "util/u_rect.h"
63 #include "shader/prog_instruction.h"
64 #include "cso_cache/cso_context.h"
65
66
67 /**
68 * Check if the given program is:
69 * 0: MOVE result.color, fragment.color;
70 * 1: END;
71 */
72 static GLboolean
73 is_passthrough_program(const struct gl_fragment_program *prog)
74 {
75 if (prog->Base.NumInstructions == 2) {
76 const struct prog_instruction *inst = prog->Base.Instructions;
77 if (inst[0].Opcode == OPCODE_MOV &&
78 inst[1].Opcode == OPCODE_END &&
79 inst[0].DstReg.File == PROGRAM_OUTPUT &&
80 inst[0].DstReg.Index == FRAG_RESULT_COLOR &&
81 inst[0].DstReg.WriteMask == WRITEMASK_XYZW &&
82 inst[0].SrcReg[0].File == PROGRAM_INPUT &&
83 inst[0].SrcReg[0].Index == FRAG_ATTRIB_COL0 &&
84 inst[0].SrcReg[0].Swizzle == SWIZZLE_XYZW) {
85 return GL_TRUE;
86 }
87 }
88 return GL_FALSE;
89 }
90
91
92
93 /**
94 * Make fragment shader for glDraw/CopyPixels. This shader is made
95 * by combining the pixel transfer shader with the user-defined shader.
96 * \return pointer to Gallium driver fragment shader
97 */
98 static void *
99 combined_drawpix_fragment_program(GLcontext *ctx)
100 {
101 struct st_context *st = st_context(ctx);
102 struct st_fragment_program *stfp;
103
104 if (st->pixel_xfer.program->serialNo == st->pixel_xfer.xfer_prog_sn
105 && st->fp->serialNo == st->pixel_xfer.user_prog_sn) {
106 /* the pixel tranfer program has not changed and the user-defined
107 * program has not changed, so re-use the combined program.
108 */
109 stfp = st->pixel_xfer.combined_prog;
110 }
111 else {
112 /* Concatenate the pixel transfer program with the current user-
113 * defined program.
114 */
115 if (is_passthrough_program(&st->fp->Base)) {
116 stfp = (struct st_fragment_program *)
117 _mesa_clone_fragment_program(ctx, &st->pixel_xfer.program->Base);
118 }
119 else {
120 #if 0
121 printf("Base program:\n");
122 _mesa_print_program(&st->fp->Base.Base);
123 printf("DrawPix program:\n");
124 _mesa_print_program(&st->pixel_xfer.program->Base.Base);
125 #endif
126 stfp = (struct st_fragment_program *)
127 _mesa_combine_programs(ctx,
128 &st->pixel_xfer.program->Base.Base,
129 &st->fp->Base.Base);
130 }
131
132 #if 0
133 {
134 struct gl_program *p = &stfp->Base.Base;
135 printf("Combined DrawPixels program:\n");
136 _mesa_print_program(p);
137 printf("InputsRead: 0x%x\n", p->InputsRead);
138 printf("OutputsWritten: 0x%x\n", p->OutputsWritten);
139 _mesa_print_parameter_list(p->Parameters);
140 }
141 #endif
142
143 /* translate to TGSI tokens */
144 st_translate_fragment_program(st, stfp);
145
146 /* save new program, update serial numbers */
147 st->pixel_xfer.xfer_prog_sn = st->pixel_xfer.program->serialNo;
148 st->pixel_xfer.user_prog_sn = st->fp->serialNo;
149 st->pixel_xfer.combined_prog_sn = stfp->serialNo;
150 /* can't reference new program directly, already have a reference on it */
151 st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
152 st->pixel_xfer.combined_prog = stfp;
153 }
154
155 /* Ideally we'd have updated the pipe constants during the normal
156 * st/atom mechanism. But we can't since this is specific to glDrawPixels.
157 */
158 st_upload_constants(st, stfp->Base.Base.Parameters, PIPE_SHADER_FRAGMENT);
159
160 return stfp->driver_shader;
161 }
162
163
164 /**
165 * Create fragment shader that does a TEX() instruction to get a Z
166 * value, then writes to FRAG_RESULT_DEPTH.
167 * Pass fragment color through as-is.
168 * \return pointer to the Gallium driver fragment shader
169 */
170 static void *
171 make_fragment_shader_z(struct st_context *st)
172 {
173 GLcontext *ctx = st->ctx;
174 struct gl_program *p;
175 GLuint ic = 0;
176
177 if (st->drawpix.z_shader) {
178 return st->drawpix.z_shader->driver_shader;
179 }
180
181 /*
182 * Create shader now
183 */
184 p = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
185 if (!p)
186 return NULL;
187
188 p->NumInstructions = 3;
189
190 p->Instructions = _mesa_alloc_instructions(p->NumInstructions);
191 if (!p->Instructions) {
192 ctx->Driver.DeleteProgram(ctx, p);
193 return NULL;
194 }
195 _mesa_init_instructions(p->Instructions, p->NumInstructions);
196
197 /* TEX result.depth, fragment.texcoord[0], texture[0], 2D; */
198 p->Instructions[ic].Opcode = OPCODE_TEX;
199 p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
200 p->Instructions[ic].DstReg.Index = FRAG_RESULT_DEPTH;
201 p->Instructions[ic].DstReg.WriteMask = WRITEMASK_Z;
202 p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
203 p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_TEX0;
204 p->Instructions[ic].TexSrcUnit = 0;
205 p->Instructions[ic].TexSrcTarget = TEXTURE_2D_INDEX;
206 ic++;
207
208 /* MOV result.color, fragment.color */
209 p->Instructions[ic].Opcode = OPCODE_MOV;
210 p->Instructions[ic].DstReg.File = PROGRAM_OUTPUT;
211 p->Instructions[ic].DstReg.Index = FRAG_RESULT_COLOR;
212 p->Instructions[ic].SrcReg[0].File = PROGRAM_INPUT;
213 p->Instructions[ic].SrcReg[0].Index = FRAG_ATTRIB_COL0;
214 ic++;
215
216 /* END; */
217 p->Instructions[ic++].Opcode = OPCODE_END;
218
219 assert(ic == p->NumInstructions);
220
221 p->InputsRead = FRAG_BIT_TEX0 | FRAG_BIT_COL0;
222 p->OutputsWritten = (1 << FRAG_RESULT_COLOR) | (1 << FRAG_RESULT_DEPTH);
223 p->SamplersUsed = 0x1; /* sampler 0 (bit 0) is used */
224
225 st->drawpix.z_shader = (struct st_fragment_program *) p;
226 st_translate_fragment_program(st, st->drawpix.z_shader);
227
228 return st->drawpix.z_shader->driver_shader;
229 }
230
231
232
233 /**
234 * Create a simple vertex shader that just passes through the
235 * vertex position and texcoord (and optionally, color).
236 */
237 static void *
238 make_passthrough_vertex_shader(struct st_context *st,
239 GLboolean passColor)
240 {
241 if (!st->drawpix.vert_shaders[passColor]) {
242 struct ureg_program *ureg =
243 ureg_create( TGSI_PROCESSOR_VERTEX );
244
245 if (ureg == NULL)
246 return NULL;
247
248 /* MOV result.pos, vertex.pos; */
249 ureg_MOV(ureg,
250 ureg_DECL_output( ureg, TGSI_SEMANTIC_POSITION, 0 ),
251 ureg_DECL_vs_input( ureg, 0 ));
252
253 /* MOV result.texcoord0, vertex.texcoord0; */
254 ureg_MOV(ureg,
255 ureg_DECL_output( ureg, TGSI_SEMANTIC_GENERIC, 0 ),
256 ureg_DECL_vs_input( ureg, 1 ));
257
258 if (passColor) {
259 /* MOV result.color0, vertex.color0; */
260 ureg_MOV(ureg,
261 ureg_DECL_output( ureg, TGSI_SEMANTIC_COLOR, 0 ),
262 ureg_DECL_vs_input( ureg, 2 ));
263 }
264
265 ureg_END( ureg );
266
267 st->drawpix.vert_shaders[passColor] =
268 ureg_create_shader_and_destroy( ureg, st->pipe );
269 }
270
271 return st->drawpix.vert_shaders[passColor];
272 }
273
274
275 /**
276 * Return a texture internalFormat for drawing/copying an image
277 * of the given type.
278 */
279 static GLenum
280 base_format(GLenum format)
281 {
282 switch (format) {
283 case GL_DEPTH_COMPONENT:
284 return GL_DEPTH_COMPONENT;
285 case GL_DEPTH_STENCIL:
286 return GL_DEPTH_STENCIL;
287 case GL_STENCIL_INDEX:
288 return GL_STENCIL_INDEX;
289 default:
290 return GL_RGBA;
291 }
292 }
293
294
295 /**
296 * Make texture containing an image for glDrawPixels image.
297 * If 'pixels' is NULL, leave the texture image data undefined.
298 */
299 static struct pipe_texture *
300 make_texture(struct st_context *st,
301 GLsizei width, GLsizei height, GLenum format, GLenum type,
302 const struct gl_pixelstore_attrib *unpack,
303 const GLvoid *pixels)
304 {
305 GLcontext *ctx = st->ctx;
306 struct pipe_context *pipe = st->pipe;
307 struct pipe_screen *screen = pipe->screen;
308 gl_format mformat;
309 struct pipe_texture *pt;
310 enum pipe_format pipeFormat;
311 GLuint cpp;
312 GLenum baseFormat;
313 int ptw, pth;
314
315 baseFormat = base_format(format);
316
317 mformat = st_ChooseTextureFormat(ctx, baseFormat, format, type);
318 assert(mformat);
319
320 pipeFormat = st_mesa_format_to_pipe_format(mformat);
321 assert(pipeFormat);
322 cpp = util_format_get_blocksize(pipeFormat);
323
324 pixels = _mesa_map_pbo_source(ctx, unpack, pixels);
325 if (!pixels)
326 return NULL;
327
328 /* Need to use POT texture? */
329 ptw = width;
330 pth = height;
331 if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
332 int l2pt, maxSize;
333
334 l2pt = util_logbase2(width);
335 if (1<<l2pt != width) {
336 ptw = 1<<(l2pt+1);
337 }
338 l2pt = util_logbase2(height);
339 if (1<<l2pt != height) {
340 pth = 1<<(l2pt+1);
341 }
342
343 /* Check against maximum texture size */
344 maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
345 assert(ptw <= maxSize);
346 assert(pth <= maxSize);
347 }
348
349 pt = st_texture_create(st, PIPE_TEXTURE_2D, pipeFormat, 0, ptw, pth, 1,
350 PIPE_TEXTURE_USAGE_SAMPLER);
351 if (!pt) {
352 _mesa_unmap_pbo_source(ctx, unpack);
353 return NULL;
354 }
355
356 {
357 struct pipe_transfer *transfer;
358 static const GLuint dstImageOffsets = 0;
359 GLboolean success;
360 GLubyte *dest;
361 const GLbitfield imageTransferStateSave = ctx->_ImageTransferState;
362
363 /* we'll do pixel transfer in a fragment shader */
364 ctx->_ImageTransferState = 0x0;
365
366 transfer = st_no_flush_get_tex_transfer(st, pt, 0, 0, 0,
367 PIPE_TRANSFER_WRITE, 0, 0,
368 width, height);
369
370 /* map texture transfer */
371 dest = screen->transfer_map(screen, transfer);
372
373
374 /* Put image into texture transfer.
375 * Note that the image is actually going to be upside down in
376 * the texture. We deal with that with texcoords.
377 */
378 success = _mesa_texstore(ctx, 2, /* dims */
379 baseFormat, /* baseInternalFormat */
380 mformat, /* gl_format */
381 dest, /* dest */
382 0, 0, 0, /* dstX/Y/Zoffset */
383 transfer->stride, /* dstRowStride, bytes */
384 &dstImageOffsets, /* dstImageOffsets */
385 width, height, 1, /* size */
386 format, type, /* src format/type */
387 pixels, /* data source */
388 unpack);
389
390 /* unmap */
391 screen->transfer_unmap(screen, transfer);
392 screen->tex_transfer_destroy(transfer);
393
394 assert(success);
395
396 /* restore */
397 ctx->_ImageTransferState = imageTransferStateSave;
398 }
399
400 _mesa_unmap_pbo_source(ctx, unpack);
401
402 return pt;
403 }
404
405
406 /**
407 * Draw quad with texcoords and optional color.
408 * Coords are gallium window coords with y=0=top.
409 * \param color may be null
410 * \param invertTex if true, flip texcoords vertically
411 */
412 static void
413 draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
414 GLfloat x1, GLfloat y1, const GLfloat *color,
415 GLboolean invertTex, GLfloat maxXcoord, GLfloat maxYcoord)
416 {
417 struct st_context *st = st_context(ctx);
418 struct pipe_context *pipe = st->pipe;
419 GLfloat verts[4][3][4]; /* four verts, three attribs, XYZW */
420
421 /* setup vertex data */
422 {
423 const struct gl_framebuffer *fb = st->ctx->DrawBuffer;
424 const GLfloat fb_width = (GLfloat) fb->Width;
425 const GLfloat fb_height = (GLfloat) fb->Height;
426 const GLfloat clip_x0 = x0 / fb_width * 2.0f - 1.0f;
427 const GLfloat clip_y0 = y0 / fb_height * 2.0f - 1.0f;
428 const GLfloat clip_x1 = x1 / fb_width * 2.0f - 1.0f;
429 const GLfloat clip_y1 = y1 / fb_height * 2.0f - 1.0f;
430 const GLfloat sLeft = 0.0f, sRight = maxXcoord;
431 const GLfloat tTop = invertTex ? maxYcoord : 0.0f;
432 const GLfloat tBot = invertTex ? 0.0f : maxYcoord;
433 GLuint tex, i;
434
435 /* upper-left */
436 verts[0][0][0] = clip_x0; /* v[0].attr[0].x */
437 verts[0][0][1] = clip_y0; /* v[0].attr[0].y */
438
439 /* upper-right */
440 verts[1][0][0] = clip_x1;
441 verts[1][0][1] = clip_y0;
442
443 /* lower-right */
444 verts[2][0][0] = clip_x1;
445 verts[2][0][1] = clip_y1;
446
447 /* lower-left */
448 verts[3][0][0] = clip_x0;
449 verts[3][0][1] = clip_y1;
450
451 tex = color ? 2 : 1;
452 verts[0][tex][0] = sLeft; /* v[0].attr[tex].s */
453 verts[0][tex][1] = tTop; /* v[0].attr[tex].t */
454 verts[1][tex][0] = sRight;
455 verts[1][tex][1] = tTop;
456 verts[2][tex][0] = sRight;
457 verts[2][tex][1] = tBot;
458 verts[3][tex][0] = sLeft;
459 verts[3][tex][1] = tBot;
460
461 /* same for all verts: */
462 if (color) {
463 for (i = 0; i < 4; i++) {
464 verts[i][0][2] = z; /*Z*/
465 verts[i][0][3] = 1.0f; /*W*/
466 verts[i][1][0] = color[0];
467 verts[i][1][1] = color[1];
468 verts[i][1][2] = color[2];
469 verts[i][1][3] = color[3];
470 verts[i][2][2] = 0.0f; /*R*/
471 verts[i][2][3] = 1.0f; /*Q*/
472 }
473 }
474 else {
475 for (i = 0; i < 4; i++) {
476 verts[i][0][2] = z; /*Z*/
477 verts[i][0][3] = 1.0f; /*W*/
478 verts[i][1][2] = 0.0f; /*R*/
479 verts[i][1][3] = 1.0f; /*Q*/
480 }
481 }
482 }
483
484 {
485 struct pipe_buffer *buf;
486
487 /* allocate/load buffer object with vertex data */
488 buf = pipe_buffer_create(pipe->screen, 32, PIPE_BUFFER_USAGE_VERTEX,
489 sizeof(verts));
490 st_no_flush_pipe_buffer_write(st, buf, 0, sizeof(verts), verts);
491
492 util_draw_vertex_buffer(pipe, buf, 0,
493 PIPE_PRIM_QUADS,
494 4, /* verts */
495 3); /* attribs/vert */
496 pipe_buffer_reference(&buf, NULL);
497 }
498 }
499
500
501
502 static void
503 draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
504 GLsizei width, GLsizei height,
505 GLfloat zoomX, GLfloat zoomY,
506 struct pipe_texture *pt,
507 void *driver_vp,
508 void *driver_fp,
509 const GLfloat *color,
510 GLboolean invertTex)
511 {
512 struct st_context *st = st_context(ctx);
513 struct pipe_context *pipe = st->pipe;
514 struct cso_context *cso = st->cso_context;
515 GLfloat x0, y0, x1, y1;
516 GLsizei maxSize;
517
518 /* limit checks */
519 /* XXX if DrawPixels image is larger than max texture size, break
520 * it up into chunks.
521 */
522 maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
523 assert(width <= maxSize);
524 assert(height <= maxSize);
525
526 cso_save_rasterizer(cso);
527 cso_save_viewport(cso);
528 cso_save_samplers(cso);
529 cso_save_sampler_textures(cso);
530 cso_save_fragment_shader(cso);
531 cso_save_vertex_shader(cso);
532
533 /* rasterizer state: just scissor */
534 {
535 struct pipe_rasterizer_state rasterizer;
536 memset(&rasterizer, 0, sizeof(rasterizer));
537 rasterizer.gl_rasterization_rules = 1;
538 rasterizer.scissor = ctx->Scissor.Enabled;
539 cso_set_rasterizer(cso, &rasterizer);
540 }
541
542 /* fragment shader state: TEX lookup program */
543 cso_set_fragment_shader_handle(cso, driver_fp);
544
545 /* vertex shader state: position + texcoord pass-through */
546 cso_set_vertex_shader_handle(cso, driver_vp);
547
548
549 /* texture sampling state: */
550 {
551 struct pipe_sampler_state sampler;
552 memset(&sampler, 0, sizeof(sampler));
553 sampler.wrap_s = PIPE_TEX_WRAP_CLAMP;
554 sampler.wrap_t = PIPE_TEX_WRAP_CLAMP;
555 sampler.wrap_r = PIPE_TEX_WRAP_CLAMP;
556 sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
557 sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
558 sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
559 sampler.normalized_coords = 1;
560
561 cso_single_sampler(cso, 0, &sampler);
562 if (st->pixel_xfer.pixelmap_enabled) {
563 cso_single_sampler(cso, 1, &sampler);
564 }
565 cso_single_sampler_done(cso);
566 }
567
568 /* viewport state: viewport matching window dims */
569 {
570 const float w = (float) ctx->DrawBuffer->Width;
571 const float h = (float) ctx->DrawBuffer->Height;
572 struct pipe_viewport_state vp;
573 vp.scale[0] = 0.5f * w;
574 vp.scale[1] = -0.5f * h;
575 vp.scale[2] = 0.5f;
576 vp.scale[3] = 1.0f;
577 vp.translate[0] = 0.5f * w;
578 vp.translate[1] = 0.5f * h;
579 vp.translate[2] = 0.5f;
580 vp.translate[3] = 0.0f;
581 cso_set_viewport(cso, &vp);
582 }
583
584 /* texture state: */
585 if (st->pixel_xfer.pixelmap_enabled) {
586 struct pipe_texture *textures[2];
587 textures[0] = pt;
588 textures[1] = st->pixel_xfer.pixelmap_texture;
589 pipe->set_fragment_sampler_textures(pipe, 2, textures);
590 }
591 else {
592 pipe->set_fragment_sampler_textures(pipe, 1, &pt);
593 }
594
595 /* Compute Gallium window coords (y=0=top) with pixel zoom.
596 * Recall that these coords are transformed by the current
597 * vertex shader and viewport transformation.
598 */
599 if (st_fb_orientation(ctx->DrawBuffer) == Y_0_BOTTOM) {
600 y = ctx->DrawBuffer->Height - (int) (y + height * ctx->Pixel.ZoomY);
601 invertTex = !invertTex;
602 }
603
604 x0 = (GLfloat) x;
605 x1 = x + width * ctx->Pixel.ZoomX;
606 y0 = (GLfloat) y;
607 y1 = y + height * ctx->Pixel.ZoomY;
608
609 /* convert Z from [0,1] to [-1,-1] to match viewport Z scale/bias */
610 z = z * 2.0 - 1.0;
611
612 draw_quad(ctx, x0, y0, z, x1, y1, color, invertTex,
613 (GLfloat) width / pt->width0,
614 (GLfloat) height / pt->height0);
615
616 /* restore state */
617 cso_restore_rasterizer(cso);
618 cso_restore_viewport(cso);
619 cso_restore_samplers(cso);
620 cso_restore_sampler_textures(cso);
621 cso_restore_fragment_shader(cso);
622 cso_restore_vertex_shader(cso);
623 }
624
625
626 static void
627 draw_stencil_pixels(GLcontext *ctx, GLint x, GLint y,
628 GLsizei width, GLsizei height, GLenum format, GLenum type,
629 const struct gl_pixelstore_attrib *unpack,
630 const GLvoid *pixels)
631 {
632 struct st_context *st = st_context(ctx);
633 struct pipe_context *pipe = st->pipe;
634 struct pipe_screen *screen = pipe->screen;
635 struct st_renderbuffer *strb;
636 enum pipe_transfer_usage usage;
637 struct pipe_transfer *pt;
638 const GLboolean zoom = ctx->Pixel.ZoomX != 1.0 || ctx->Pixel.ZoomY != 1.0;
639 GLint skipPixels;
640 ubyte *stmap;
641 struct gl_pixelstore_attrib clippedUnpack = *unpack;
642
643 if (!zoom) {
644 if (!_mesa_clip_drawpixels(ctx, &x, &y, &width, &height,
645 &clippedUnpack)) {
646 /* totally clipped */
647 return;
648 }
649 }
650
651 strb = st_renderbuffer(ctx->DrawBuffer->
652 Attachment[BUFFER_STENCIL].Renderbuffer);
653
654 if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
655 y = ctx->DrawBuffer->Height - y - height;
656 }
657
658 if(format != GL_DEPTH_STENCIL &&
659 util_format_get_component_bits(strb->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
660 usage = PIPE_TRANSFER_READ_WRITE;
661 else
662 usage = PIPE_TRANSFER_WRITE;
663
664 pt = st_cond_flush_get_tex_transfer(st_context(ctx), strb->texture, 0, 0, 0,
665 usage, x, y,
666 width, height);
667
668 stmap = screen->transfer_map(screen, pt);
669
670 pixels = _mesa_map_pbo_source(ctx, &clippedUnpack, pixels);
671 assert(pixels);
672
673 /* if width > MAX_WIDTH, have to process image in chunks */
674 skipPixels = 0;
675 while (skipPixels < width) {
676 const GLint spanX = skipPixels;
677 const GLint spanWidth = MIN2(width - skipPixels, MAX_WIDTH);
678 GLint row;
679 for (row = 0; row < height; row++) {
680 GLubyte sValues[MAX_WIDTH];
681 GLuint zValues[MAX_WIDTH];
682 GLenum destType = GL_UNSIGNED_BYTE;
683 const GLvoid *source = _mesa_image_address2d(&clippedUnpack, pixels,
684 width, height,
685 format, type,
686 row, skipPixels);
687 _mesa_unpack_stencil_span(ctx, spanWidth, destType, sValues,
688 type, source, &clippedUnpack,
689 ctx->_ImageTransferState);
690
691 if (format == GL_DEPTH_STENCIL) {
692 _mesa_unpack_depth_span(ctx, spanWidth, GL_UNSIGNED_INT, zValues,
693 (1 << 24) - 1, type, source,
694 &clippedUnpack);
695 }
696
697 if (zoom) {
698 _mesa_problem(ctx, "Gallium glDrawPixels(GL_STENCIL) with "
699 "zoom not complete");
700 }
701
702 {
703 GLint spanY;
704
705 if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
706 spanY = height - row - 1;
707 }
708 else {
709 spanY = row;
710 }
711
712 /* now pack the stencil (and Z) values in the dest format */
713 switch (pt->texture->format) {
714 case PIPE_FORMAT_S8_UNORM:
715 {
716 ubyte *dest = stmap + spanY * pt->stride + spanX;
717 assert(usage == PIPE_TRANSFER_WRITE);
718 memcpy(dest, sValues, spanWidth);
719 }
720 break;
721 case PIPE_FORMAT_Z24S8_UNORM:
722 if (format == GL_DEPTH_STENCIL) {
723 uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
724 GLint k;
725 assert(usage == PIPE_TRANSFER_WRITE);
726 for (k = 0; k < spanWidth; k++) {
727 dest[k] = zValues[k] | (sValues[k] << 24);
728 }
729 }
730 else {
731 uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
732 GLint k;
733 assert(usage == PIPE_TRANSFER_READ_WRITE);
734 for (k = 0; k < spanWidth; k++) {
735 dest[k] = (dest[k] & 0xffffff) | (sValues[k] << 24);
736 }
737 }
738 break;
739 case PIPE_FORMAT_S8Z24_UNORM:
740 if (format == GL_DEPTH_STENCIL) {
741 uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
742 GLint k;
743 assert(usage == PIPE_TRANSFER_WRITE);
744 for (k = 0; k < spanWidth; k++) {
745 dest[k] = (zValues[k] << 8) | (sValues[k] & 0xff);
746 }
747 }
748 else {
749 uint *dest = (uint *) (stmap + spanY * pt->stride + spanX*4);
750 GLint k;
751 assert(usage == PIPE_TRANSFER_READ_WRITE);
752 for (k = 0; k < spanWidth; k++) {
753 dest[k] = (dest[k] & 0xffffff00) | (sValues[k] & 0xff);
754 }
755 }
756 break;
757 default:
758 assert(0);
759 }
760 }
761 }
762 skipPixels += spanWidth;
763 }
764
765 _mesa_unmap_pbo_source(ctx, &clippedUnpack);
766
767 /* unmap the stencil buffer */
768 screen->transfer_unmap(screen, pt);
769 screen->tex_transfer_destroy(pt);
770 }
771
772
773 /**
774 * Called via ctx->Driver.DrawPixels()
775 */
776 static void
777 st_DrawPixels(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
778 GLenum format, GLenum type,
779 const struct gl_pixelstore_attrib *unpack, const GLvoid *pixels)
780 {
781 void *driver_vp, *driver_fp;
782 struct st_context *st = st_context(ctx);
783 const GLfloat *color;
784
785 if (format == GL_STENCIL_INDEX ||
786 format == GL_DEPTH_STENCIL) {
787 draw_stencil_pixels(ctx, x, y, width, height, format, type,
788 unpack, pixels);
789 return;
790 }
791
792 /* Mesa state should be up to date by now */
793 assert(ctx->NewState == 0x0);
794
795 st_validate_state(st);
796
797 if (format == GL_DEPTH_COMPONENT) {
798 driver_fp = make_fragment_shader_z(st);
799 driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
800 color = ctx->Current.RasterColor;
801 }
802 else {
803 driver_fp = combined_drawpix_fragment_program(ctx);
804 driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
805 color = NULL;
806 }
807
808 /* draw with textured quad */
809 {
810 struct pipe_texture *pt
811 = make_texture(st, width, height, format, type, unpack, pixels);
812 if (pt) {
813 draw_textured_quad(ctx, x, y, ctx->Current.RasterPos[2],
814 width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
815 pt,
816 driver_vp,
817 driver_fp,
818 color, GL_FALSE);
819 pipe_texture_reference(&pt, NULL);
820 }
821 }
822 }
823
824
825
826 static void
827 copy_stencil_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
828 GLsizei width, GLsizei height,
829 GLint dstx, GLint dsty)
830 {
831 struct st_renderbuffer *rbDraw = st_renderbuffer(ctx->DrawBuffer->_StencilBuffer);
832 struct pipe_screen *screen = ctx->st->pipe->screen;
833 enum pipe_transfer_usage usage;
834 struct pipe_transfer *ptDraw;
835 ubyte *drawMap;
836 ubyte *buffer;
837 int i;
838
839 buffer = malloc(width * height * sizeof(ubyte));
840 if (!buffer) {
841 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyPixels(stencil)");
842 return;
843 }
844
845 /* this will do stencil pixel transfer ops */
846 st_read_stencil_pixels(ctx, srcx, srcy, width, height,
847 GL_STENCIL_INDEX, GL_UNSIGNED_BYTE,
848 &ctx->DefaultPacking, buffer);
849
850 if(util_format_get_component_bits(rbDraw->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0)
851 usage = PIPE_TRANSFER_READ_WRITE;
852 else
853 usage = PIPE_TRANSFER_WRITE;
854
855 if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
856 dsty = rbDraw->Base.Height - dsty - height;
857 }
858
859 ptDraw = st_cond_flush_get_tex_transfer(st_context(ctx),
860 rbDraw->texture, 0, 0, 0,
861 usage, dstx, dsty,
862 width, height);
863
864 assert(util_format_get_blockwidth(ptDraw->texture->format) == 1);
865 assert(util_format_get_blockheight(ptDraw->texture->format) == 1);
866
867 /* map the stencil buffer */
868 drawMap = screen->transfer_map(screen, ptDraw);
869
870 /* draw */
871 /* XXX PixelZoom not handled yet */
872 for (i = 0; i < height; i++) {
873 ubyte *dst;
874 const ubyte *src;
875 int y;
876
877 y = i;
878
879 if (st_fb_orientation(ctx->DrawBuffer) == Y_0_TOP) {
880 y = height - y - 1;
881 }
882
883 dst = drawMap + y * ptDraw->stride;
884 src = buffer + i * width;
885
886 switch (ptDraw->texture->format) {
887 case PIPE_FORMAT_Z24S8_UNORM:
888 {
889 uint *dst4 = (uint *) dst;
890 int j;
891 assert(usage == PIPE_TRANSFER_READ_WRITE);
892 for (j = 0; j < width; j++) {
893 *dst4 = (*dst4 & 0xffffff) | (src[j] << 24);
894 dst4++;
895 }
896 }
897 break;
898 case PIPE_FORMAT_S8Z24_UNORM:
899 {
900 uint *dst4 = (uint *) dst;
901 int j;
902 assert(usage == PIPE_TRANSFER_READ_WRITE);
903 for (j = 0; j < width; j++) {
904 *dst4 = (*dst4 & 0xffffff00) | (src[j] & 0xff);
905 dst4++;
906 }
907 }
908 break;
909 case PIPE_FORMAT_S8_UNORM:
910 assert(usage == PIPE_TRANSFER_WRITE);
911 memcpy(dst, src, width);
912 break;
913 default:
914 assert(0);
915 }
916 }
917
918 free(buffer);
919
920 /* unmap the stencil buffer */
921 screen->transfer_unmap(screen, ptDraw);
922 screen->tex_transfer_destroy(ptDraw);
923 }
924
925
926 static void
927 st_CopyPixels(GLcontext *ctx, GLint srcx, GLint srcy,
928 GLsizei width, GLsizei height,
929 GLint dstx, GLint dsty, GLenum type)
930 {
931 struct st_context *st = st_context(ctx);
932 struct pipe_context *pipe = st->pipe;
933 struct pipe_screen *screen = pipe->screen;
934 struct st_renderbuffer *rbRead;
935 void *driver_vp, *driver_fp;
936 struct pipe_texture *pt;
937 GLfloat *color;
938 enum pipe_format srcFormat, texFormat;
939 int ptw, pth;
940 GLboolean invertTex = GL_FALSE;
941 GLint readX, readY, readW, readH;
942 struct gl_pixelstore_attrib unpack = ctx->DefaultPacking;
943
944 pipe->flush(pipe, PIPE_FLUSH_RENDER_CACHE, NULL);
945
946 st_validate_state(st);
947
948 if (type == GL_STENCIL) {
949 /* can't use texturing to do stencil */
950 copy_stencil_pixels(ctx, srcx, srcy, width, height, dstx, dsty);
951 return;
952 }
953
954 if (type == GL_COLOR) {
955 rbRead = st_get_color_read_renderbuffer(ctx);
956 color = NULL;
957 driver_fp = combined_drawpix_fragment_program(ctx);
958 driver_vp = make_passthrough_vertex_shader(st, GL_FALSE);
959 }
960 else {
961 assert(type == GL_DEPTH);
962 rbRead = st_renderbuffer(ctx->ReadBuffer->_DepthBuffer);
963 color = ctx->Current.Attrib[VERT_ATTRIB_COLOR0];
964 driver_fp = make_fragment_shader_z(st);
965 driver_vp = make_passthrough_vertex_shader(st, GL_TRUE);
966 }
967
968 srcFormat = rbRead->texture->format;
969
970 if (screen->is_format_supported(screen, srcFormat, PIPE_TEXTURE_2D,
971 PIPE_TEXTURE_USAGE_SAMPLER, 0)) {
972 texFormat = srcFormat;
973 }
974 else {
975 /* srcFormat can't be used as a texture format */
976 if (type == GL_DEPTH) {
977 texFormat = st_choose_format(screen, GL_DEPTH_COMPONENT,
978 PIPE_TEXTURE_2D,
979 PIPE_TEXTURE_USAGE_DEPTH_STENCIL);
980 assert(texFormat != PIPE_FORMAT_NONE);
981 }
982 else {
983 /* default color format */
984 texFormat = st_choose_format(screen, GL_RGBA, PIPE_TEXTURE_2D,
985 PIPE_TEXTURE_USAGE_SAMPLER);
986 assert(texFormat != PIPE_FORMAT_NONE);
987 }
988 }
989
990 /* Invert src region if needed */
991 if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) {
992 srcy = ctx->ReadBuffer->Height - srcy - height;
993 invertTex = !invertTex;
994 }
995
996 /* Clip the read region against the src buffer bounds.
997 * We'll still allocate a temporary buffer/texture for the original
998 * src region size but we'll only read the region which is on-screen.
999 * This may mean that we draw garbage pixels into the dest region, but
1000 * that's expected.
1001 */
1002 readX = srcx;
1003 readY = srcy;
1004 readW = width;
1005 readH = height;
1006 _mesa_clip_readpixels(ctx, &readX, &readY, &readW, &readH, &unpack);
1007 readW = MAX2(0, readW);
1008 readH = MAX2(0, readH);
1009
1010 /* Need to use POT texture? */
1011 ptw = width;
1012 pth = height;
1013 if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES)) {
1014 int l2pt, maxSize;
1015
1016 l2pt = util_logbase2(width);
1017 if (1<<l2pt != width) {
1018 ptw = 1<<(l2pt+1);
1019 }
1020 l2pt = util_logbase2(height);
1021 if (1<<l2pt != height) {
1022 pth = 1<<(l2pt+1);
1023 }
1024
1025 /* Check against maximum texture size */
1026 maxSize = 1 << (pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
1027 assert(ptw <= maxSize);
1028 assert(pth <= maxSize);
1029 }
1030
1031 pt = st_texture_create(st, PIPE_TEXTURE_2D, texFormat, 0,
1032 ptw, pth, 1,
1033 PIPE_TEXTURE_USAGE_SAMPLER);
1034 if (!pt)
1035 return;
1036
1037 /* Make temporary texture which is a copy of the src region.
1038 */
1039 if (srcFormat == texFormat) {
1040 /* copy source framebuffer surface into mipmap/texture */
1041 struct pipe_surface *psRead = screen->get_tex_surface(screen,
1042 rbRead->texture, 0, 0, 0,
1043 PIPE_BUFFER_USAGE_GPU_READ);
1044 struct pipe_surface *psTex = screen->get_tex_surface(screen, pt, 0, 0, 0,
1045 PIPE_BUFFER_USAGE_GPU_WRITE );
1046 if (pipe->surface_copy) {
1047 pipe->surface_copy(pipe,
1048 psTex, /* dest surf */
1049 unpack.SkipPixels, unpack.SkipRows, /* dest pos */
1050 psRead, /* src surf */
1051 readX, readY, readW, readH); /* src region */
1052 } else {
1053 util_surface_copy(pipe, FALSE,
1054 psTex,
1055 unpack.SkipPixels, unpack.SkipRows,
1056 psRead,
1057 readX, readY, readW, readH);
1058 }
1059
1060 if (0) {
1061 /* debug */
1062 debug_dump_surface("copypixsrcsurf", psRead);
1063 debug_dump_surface("copypixtemptex", psTex);
1064 }
1065
1066 pipe_surface_reference(&psRead, NULL);
1067 pipe_surface_reference(&psTex, NULL);
1068 }
1069 else {
1070 /* CPU-based fallback/conversion */
1071 struct pipe_transfer *ptRead =
1072 st_cond_flush_get_tex_transfer(st, rbRead->texture, 0, 0, 0,
1073 PIPE_TRANSFER_READ,
1074 readX, readY, readW, readH);
1075 struct pipe_transfer *ptTex;
1076 enum pipe_transfer_usage transfer_usage;
1077
1078 if (ST_DEBUG & DEBUG_FALLBACK)
1079 debug_printf("%s: fallback processing\n", __FUNCTION__);
1080
1081 if (type == GL_DEPTH && util_format_is_depth_and_stencil(pt->format))
1082 transfer_usage = PIPE_TRANSFER_READ_WRITE;
1083 else
1084 transfer_usage = PIPE_TRANSFER_WRITE;
1085
1086 ptTex = st_cond_flush_get_tex_transfer(st, pt, 0, 0, 0, transfer_usage,
1087 0, 0, width, height);
1088
1089 /* copy image from ptRead surface to ptTex surface */
1090 if (type == GL_COLOR) {
1091 /* alternate path using get/put_tile() */
1092 GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
1093 pipe_get_tile_rgba(ptRead, readX, readY, readW, readH, buf);
1094 pipe_put_tile_rgba(ptTex, unpack.SkipPixels, unpack.SkipRows,
1095 readW, readH, buf);
1096 free(buf);
1097 }
1098 else {
1099 /* GL_DEPTH */
1100 GLuint *buf = (GLuint *) malloc(width * height * sizeof(GLuint));
1101 pipe_get_tile_z(ptRead, readX, readY, readW, readH, buf);
1102 pipe_put_tile_z(ptTex, unpack.SkipPixels, unpack.SkipRows,
1103 readW, readH, buf);
1104 free(buf);
1105 }
1106
1107 screen->tex_transfer_destroy(ptRead);
1108 screen->tex_transfer_destroy(ptTex);
1109 }
1110
1111 /* OK, the texture 'pt' contains the src image/pixels. Now draw a
1112 * textured quad with that texture.
1113 */
1114 draw_textured_quad(ctx, dstx, dsty, ctx->Current.RasterPos[2],
1115 width, height, ctx->Pixel.ZoomX, ctx->Pixel.ZoomY,
1116 pt,
1117 driver_vp,
1118 driver_fp,
1119 color, invertTex);
1120
1121 pipe_texture_reference(&pt, NULL);
1122 }
1123
1124
1125
1126 void st_init_drawpixels_functions(struct dd_function_table *functions)
1127 {
1128 functions->DrawPixels = st_DrawPixels;
1129 functions->CopyPixels = st_CopyPixels;
1130 }
1131
1132
1133 void
1134 st_destroy_drawpix(struct st_context *st)
1135 {
1136 st_reference_fragprog(st, &st->drawpix.z_shader, NULL);
1137 st_reference_fragprog(st, &st->pixel_xfer.combined_prog, NULL);
1138 if (st->drawpix.vert_shaders[0])
1139 free(st->drawpix.vert_shaders[0]);
1140 if (st->drawpix.vert_shaders[1])
1141 free(st->drawpix.vert_shaders[1]);
1142 }