git.libre-soc.org Git - mesa.git/blob - src/mesa/drivers/dri/intel/intel_pixel

1 /**************************************************************************

2 *

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 **************************************************************************/

28 #include "main/glheader.h"

29 #include "main/image.h"

30 #include "main/state.h"

31 #include "main/mtypes.h"

32 #include "drivers/common/meta.h"

34 #include "intel_context.h"

35 #include "intel_buffers.h"

36 #include "intel_regions.h"

37 #include "intel_pixel.h"

38 #include "intel_fbo.h"

40 #define FILE_DEBUG_FLAG DEBUG_PIXEL

42 static struct intel_region *

 copypix_src_region(struct intel_context *intel, GLenum type)

44 {

45 struct intel_renderbuffer *depth;

47 depth = (struct intel_renderbuffer *)

       &intel->ctx.DrawBuffer->Attachment[BUFFER_DEPTH].Renderbuffer;

50 switch (type) {

51 case GL_COLOR:

52 return intel_readbuf_region(intel);

53 case GL_DEPTH:

54 /* Don't think this is really possible execpt at 16bpp, when we

55 * have no stencil. */

       if (depth && depth->region->cpp == 2)

57 return depth->region;

58 case GL_STENCIL:

59 /* Don't think this is really possible. */

60 break;

61 case GL_DEPTH_STENCIL_EXT:

62 /* Does it matter whether it is stencil/depth or depth/stencil?

63 */

64 return depth->region;

65 default:

66 break;

67 }

69 return NULL;

70 }

73 /**

74 * Check if any fragment operations are in effect which might effect

75 * glCopyPixels. Differs from intel_check_blit_fragment_ops in that

76 * we allow Scissor.

77 */

78 static GLboolean

79 intel_check_copypixel_blit_fragment_ops(GLcontext * ctx)

80 {

81 if (ctx->NewState)

82 _mesa_update_state(ctx);

84 /* Could do logicop with the blitter:

85 */

86 return !(ctx->_ImageTransferState ||

87 ctx->Color.AlphaEnabled ||

88 ctx->Depth.Test ||

89 ctx->Fog.Enabled ||

90 ctx->Stencil._Enabled ||

             !ctx->Color.ColorMask[0][0] ||

             !ctx->Color.ColorMask[0][1] ||

             !ctx->Color.ColorMask[0][2] ||

             !ctx->Color.ColorMask[0][3] ||

95 ctx->Texture._EnabledUnits ||

96 ctx->FragmentProgram._Enabled ||

97 ctx->Color.BlendEnabled);

98 }

100

101 /**

102 * CopyPixels with the blitter. Don't support zooming, pixel transfer, etc.

103 */

104 static GLboolean

105 do_blit_copypixels(GLcontext * ctx,

106 GLint srcx, GLint srcy,

107 GLsizei width, GLsizei height,

108 GLint dstx, GLint dsty, GLenum type)

109 {

    struct intel_context *intel = intel_context(ctx);

    struct intel_region *dst = intel_drawbuf_region(intel);

    struct intel_region *src = copypix_src_region(intel, type);

    struct gl_framebuffer *fb = ctx->DrawBuffer;

    struct gl_framebuffer *read_fb = ctx->ReadBuffer;

115 unsigned int num_cliprects;

116 drm_clip_rect_t *cliprects;

117 int x_off, y_off;

118

    if (type == GL_DEPTH || type == GL_STENCIL) {

120 if (INTEL_DEBUG & DEBUG_FALLBACKS)

          fprintf(stderr, "glCopyPixels() fallback: GL_DEPTH || GL_STENCIL\n");

122 return GL_FALSE;

123 }

124

125 /* Update draw buffer bounds */

126 _mesa_update_state(ctx);

127

128 /* Copypixels can be more than a straight copy. Ensure all the

129 * extra operations are disabled:

130 */

    if (!intel_check_copypixel_blit_fragment_ops(ctx) ||

        ctx->Pixel.ZoomX != 1.0F || ctx->Pixel.ZoomY != 1.0F)

133 return GL_FALSE;

134

135 if (!src || !dst)

136 return GL_FALSE;

137

138

139

140 intelFlush(&intel->ctx);

141

    intel_get_cliprects(intel, &cliprects, &num_cliprects, &x_off, &y_off);

    if (num_cliprects != 0) {

144 GLint delta_x;

145 GLint delta_y;

146 GLint orig_dstx;

147 GLint orig_dsty;

148 GLint orig_srcx;

149 GLint orig_srcy;

150 GLuint i;

151

152 /* XXX: We fail to handle different inversion between read and draw framebuffer. */

153

154 /* Clip to destination buffer. */

155 orig_dstx = dstx;

156 orig_dsty = dsty;

       if (!_mesa_clip_to_region(fb->_Xmin, fb->_Ymin,

158 fb->_Xmax, fb->_Ymax,

                                 &dstx, &dsty, &width, &height))

160 goto out;

161 /* Adjust src coords for our post-clipped destination origin */

162 srcx += dstx - orig_dstx;

163 srcy += dsty - orig_dsty;

164

165 /* Clip to source buffer. */

166 orig_srcx = srcx;

167 orig_srcy = srcy;

       if (!_mesa_clip_to_region(0, 0,

169 read_fb->Width, read_fb->Height,

                                 &srcx, &srcy, &width, &height))

171 goto out;

172 /* Adjust dst coords for our post-clipped source origin */

173 dstx += srcx - orig_srcx;

174 dsty += srcy - orig_srcy;

175

176 /* Convert from GL to hardware coordinates:

177 */

       if (fb->Name == 0) {

179 /* copypixels to a system framebuffer */

180 dstx = x_off + dstx;

          dsty = y_off + (fb->Height - dsty - height);

182 } else {

183 /* copypixels to a user framebuffer object */

184 dstx = x_off + dstx;

185 dsty = y_off + dsty;

186 }

187

188 /* Flip source Y if it's a system framebuffer. */

       if (read_fb->Name == 0) {

          srcx = intel->driReadDrawable->x + srcx;

          srcy = intel->driReadDrawable->y + (fb->Height - srcy - height);

192 }

193

194 delta_x = srcx - dstx;

195 delta_y = srcy - dsty;

196 /* Could do slightly more clipping: Eg, take the intersection of

197 * the destination cliprects and the read drawable cliprects

198 *

199 * This code will not overwrite other windows, but will

200 * introduce garbage when copying from obscured window regions.

201 */

       for (i = 0; i < num_cliprects; i++) {

203 GLint clip_x = dstx;

204 GLint clip_y = dsty;

205 GLint clip_w = width;

206 GLint clip_h = height;

207

          if (!_mesa_clip_to_region(cliprects[i].x1, cliprects[i].y1,

                                    cliprects[i].x2, cliprects[i].y2,

                                    &clip_x, &clip_y, &clip_w, &clip_h))

211 continue;

212

          if (!intel_region_copy(intel,

                                 dst, 0, clip_x, clip_y,

                                 src, 0, clip_x + delta_x, clip_y + delta_y,

216 clip_w, clip_h,

217 ctx->Color.ColorLogicOpEnabled ?

218 ctx->Color.LogicOp : GL_COPY)) {

             DBG("%s: blit failure\n", __FUNCTION__);

220 return GL_FALSE;

221 }

222 }

223 }

224 out:

225

226 intel_check_front_buffer_rendering(intel);

227

    DBG("%s: success\n", __FUNCTION__);

229 return GL_TRUE;

230 }

231

232

233 void

234 intelCopyPixels(GLcontext * ctx,

235 GLint srcx, GLint srcy,

236 GLsizei width, GLsizei height,

237 GLint destx, GLint desty, GLenum type)

238 {

239 if (INTEL_DEBUG & DEBUG_PIXEL)

       fprintf(stderr, "%s\n", __FUNCTION__);

241

    if (do_blit_copypixels(ctx, srcx, srcy, width, height, destx, desty, type))

243 return;

244

245 /* this will use swrast if needed */

    _mesa_meta_CopyPixels(ctx, srcx, srcy, width, height, destx, desty, type);

247 }