src/mesa/pipe/i915simple/i915_surface.c - platform/external/mesa3d - Gitiles

 /**************************************************************************
  *
  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
  * "Software"), to deal in the Software without restriction, including
  * without limitation the rights to use, copy, modify, merge, publish,
  * distribute, sub license, and/or sell copies of the Software, and to
  * permit persons to whom the Software is furnished to do so, subject to
  * the following conditions:
  *
  * The above copyright notice and this permission notice (including the
  * next paragraph) shall be included in all copies or substantial portions
  * of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  **************************************************************************/

 #include "i915_context.h"
 #include "i915_blit.h"
 #include "i915_state.h"
 #include "pipe/p_defines.h"
 #include "pipe/p_util.h"
 #include "pipe/p_inlines.h"
 #include "pipe/p_winsys.h"


 #define CLIP_TILE \
    do { \
       if (x >= ps->width) \
          return; \
       if (y >= ps->height) \
          return; \
       if (x + w > ps->width) \
          w = ps->width - x; \
       if (y + h > ps->height) \
          h = ps->height -y; \
    } while(0)


 /**
  * Note: this is exactly like a8r8g8b8_get_tile() in sp_surface.c
  * Share it someday.
  */
 static void
 i915_get_tile_rgba(struct pipe_context *pipe,
                    struct pipe_surface *ps,
                    uint x, uint y, uint w, uint h, float *p)
 {
    const unsigned *src
       = ((const unsigned *) (ps->region->map + ps->offset))
       + y * ps->pitch + x;
    unsigned i, j;
    unsigned w0 = w;

    CLIP_TILE;

    switch (ps->format) {
    case PIPE_FORMAT_U_A8_R8_G8_B8:
       for (i = 0; i < h; i++) {
          float *pRow = p;
          for (j = 0; j < w; j++) {
             const unsigned pixel = src[j];
             pRow[0] = UBYTE_TO_FLOAT((pixel >> 16) & 0xff);
             pRow[1] = UBYTE_TO_FLOAT((pixel >>  8) & 0xff);
             pRow[2] = UBYTE_TO_FLOAT((pixel >>  0) & 0xff);
             pRow[3] = UBYTE_TO_FLOAT((pixel >> 24) & 0xff);
             pRow += 4;
          }
          src += ps->pitch;
          p += w0 * 4;
       }
       break;
    case PIPE_FORMAT_S8_Z24:
       {
          const float scale = 1.0f / (float) 0xffffff;
          for (i = 0; i < h; i++) {
             float *pRow = p;
             for (j = 0; j < w; j++) {
                const unsigned pixel = src[j];
                pRow[0] =
                pRow[1] =
                pRow[2] =
                pRow[3] = (pixel & 0xffffff) * scale;
                pRow += 4;
             }
             src += ps->pitch;
             p += w0 * 4;
          }
       }
       break;
    default:
       assert(0);
    }
 }


 static void
 i915_put_tile_rgba(struct pipe_context *pipe,
                    struct pipe_surface *ps,
                    uint x, uint y, uint w, uint h, const float *p)
 {
    /* TODO */
    assert(0);
 }


 /*
  * XXX note: same as code in sp_surface.c
  */
 static void
 i915_get_tile(struct pipe_context *pipe,
               struct pipe_surface *ps,
               uint x, uint y, uint w, uint h,
               void *p, int dst_stride)
 {
    const uint cpp = ps->cpp;
    const uint w0 = w;
    const ubyte *pSrc;
    ubyte *pDest;
    uint i;

    assert(ps->region->map);

    CLIP_TILE;

    if (dst_stride == 0) {
       dst_stride = w0 * cpp;
    }

    pSrc = ps->region->map + ps->offset + (y * ps->pitch + x) * cpp;
    pDest = (ubyte *) p;

    for (i = 0; i < h; i++) {
       memcpy(pDest, pSrc, w0 * cpp);
       pDest += dst_stride;
       pSrc += ps->pitch * cpp;
    }
 }


 /*
  * XXX note: same as code in sp_surface.c
  */
 static void
 i915_put_tile(struct pipe_context *pipe,
               struct pipe_surface *ps,
               uint x, uint y, uint w, uint h,
               const void *p, int src_stride)
 {
    const uint cpp = ps->cpp;
    const uint w0 = w;
    const ubyte *pSrc;
    ubyte *pDest;
    uint i;

    assert(ps->region->map);

    CLIP_TILE;

    if (src_stride == 0) {
       src_stride = w0 * cpp;
    }

    pSrc = (const ubyte *) p;
    pDest = ps->region->map + ps->offset + (y * ps->pitch + x) * cpp;

    for (i = 0; i < h; i++) {
       memcpy(pDest, pSrc, w0 * cpp);
       pDest += ps->pitch * cpp;
       pSrc += src_stride;
    }
 }


 /*
  * XXX note: same as code in sp_surface.c
  */
 static struct pipe_surface *
 i915_get_tex_surface(struct pipe_context *pipe,
                      struct pipe_mipmap_tree *mt,
                      unsigned face, unsigned level, unsigned zslice)
 {
    struct pipe_surface *ps;
    unsigned offset;  /* in bytes */

    offset = mt->level[level].level_offset;

    if (mt->target == PIPE_TEXTURE_CUBE) {
       offset += mt->level[level].image_offset[face] * mt->cpp;
    }
    else if (mt->target == PIPE_TEXTURE_3D) {
       offset += mt->level[level].image_offset[zslice] * mt->cpp;
    }
    else {
       assert(face == 0);
       assert(zslice == 0);
    }

    ps = pipe->winsys->surface_alloc(pipe->winsys, mt->format);
    if (ps) {
       assert(ps->format);
       assert(ps->refcount);
       pipe_region_reference(&ps->region, mt->region);
       ps->cpp = mt->cpp;
       ps->width = mt->level[level].width;
       ps->height = mt->level[level].height;
       ps->pitch = mt->pitch;
       ps->offset = offset;
    }
    return ps;
 }


 /*
  * XXX Move this into core Mesa?
  */
 static void
 _mesa_copy_rect(ubyte * dst,
                 unsigned cpp,
                 unsigned dst_pitch,
                 unsigned dst_x,
                 unsigned dst_y,
                 unsigned width,
                 unsigned height,
                 const ubyte * src,
                 unsigned src_pitch,
 		unsigned src_x,
 		unsigned src_y)
 {
    unsigned i;

    dst_pitch *= cpp;
    src_pitch *= cpp;
    dst += dst_x * cpp;
    src += src_x * cpp;
    dst += dst_y * dst_pitch;
    src += src_y * dst_pitch;
    width *= cpp;

    if (width == dst_pitch && width == src_pitch)
       memcpy(dst, src, height * width);
    else {
       for (i = 0; i < height; i++) {
          memcpy(dst, src, width);
          dst += dst_pitch;
          src += src_pitch;
       }
    }
 }


 /* Upload data to a rectangular sub-region.  Lots of choices how to do this:
  *
  * - memcpy by span to current destination
  * - upload data as new buffer and blit
  *
  * Currently always memcpy.
  */
 static void
 i915_surface_data(struct pipe_context *pipe,
 		  struct pipe_surface *dst,
 		  unsigned dstx, unsigned dsty,
 		  const void *src, unsigned src_pitch,
 		  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
    _mesa_copy_rect(pipe->region_map(pipe, dst->region) + dst->offset,
                    dst->cpp,
                    dst->pitch,
                    dstx, dsty, width, height, src, src_pitch, srcx, srcy);

    pipe->region_unmap(pipe, dst->region);
 }


 /* Assumes all values are within bounds -- no checking at this level -
  * do it higher up if required.
  */
 static void
 i915_surface_copy(struct pipe_context *pipe,
 		  struct pipe_surface *dst,
 		  unsigned dstx, unsigned dsty,
 		  struct pipe_surface *src,
 		  unsigned srcx, unsigned srcy, unsigned width, unsigned height)
 {
    assert( dst != src );
    assert( dst->cpp == src->cpp );

    if (0) {
       _mesa_copy_rect(pipe->region_map(pipe, dst->region) + dst->offset,
 		      dst->cpp,
 		      dst->pitch,
 		      dstx, dsty,
 		      width, height,
 		      pipe->region_map(pipe, src->region) + src->offset,
 		      src->pitch,
 		      srcx, srcy);

       pipe->region_unmap(pipe, src->region);
       pipe->region_unmap(pipe, dst->region);
    }
    else {
       i915_copy_blit( i915_context(pipe),
 		      dst->cpp,
 		      (short) src->pitch, src->region->buffer, src->offset,
 		      (short) dst->pitch, dst->region->buffer, dst->offset,
 		      (short) srcx, (short) srcy, (short) dstx, (short) dsty, (short) width, (short) height );
    }
 }

 /* Fill a rectangular sub-region.  Need better logic about when to
  * push buffers into AGP - will currently do so whenever possible.
  */
 static ubyte *
 get_pointer(struct pipe_surface *dst, unsigned x, unsigned y)
 {
    return dst->region->map + (y * dst->pitch + x) * dst->cpp;
 }


 static void
 i915_surface_fill(struct pipe_context *pipe,
 		  struct pipe_surface *dst,
 		  unsigned dstx, unsigned dsty,
 		  unsigned width, unsigned height, unsigned value)
 {
    if (0) {
       unsigned i, j;

       (void)pipe->region_map(pipe, dst->region);

       switch (dst->cpp) {
       case 1: {
 	 ubyte *row = get_pointer(dst, dstx, dsty);
 	 for (i = 0; i < height; i++) {
 	    memset(row, value, width);
 	    row += dst->pitch;
 	 }
       }
 	 break;
       case 2: {
 	 ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
 	 for (i = 0; i < height; i++) {
 	    for (j = 0; j < width; j++)
 	       row[j] = (ushort) value;
 	    row += dst->pitch;
 	 }
       }
 	 break;
       case 4: {
 	 unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
 	 for (i = 0; i < height; i++) {
 	    for (j = 0; j < width; j++)
 	       row[j] = value;
 	    row += dst->pitch;
 	 }
       }
 	 break;
       default:
 	 assert(0);
 	 break;
       }
    }
    else {
       i915_fill_blit( i915_context(pipe),
 		      dst->cpp,
 		      (short) dst->pitch,
 		      dst->region->buffer, dst->offset,
 		      (short) dstx, (short) dsty,
 		      (short) width, (short) height,
 		      value );
    }
 }


 void
 i915_init_surface_functions(struct i915_context *i915)
 {
    i915->pipe.get_tex_surface = i915_get_tex_surface;
    i915->pipe.get_tile = i915_get_tile;
    i915->pipe.put_tile = i915_put_tile;
    i915->pipe.get_tile_rgba = i915_get_tile_rgba;
    i915->pipe.put_tile_rgba = i915_put_tile_rgba;
    i915->pipe.surface_data = i915_surface_data;
    i915->pipe.surface_copy = i915_surface_copy;
    i915->pipe.surface_fill = i915_surface_fill;
 }
	/**************************************************************************
	*
	* Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
	* All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the
	* "Software"), to deal in the Software without restriction, including
	* without limitation the rights to use, copy, modify, merge, publish,
	* distribute, sub license, and/or sell copies of the Software, and to
	* permit persons to whom the Software is furnished to do so, subject to
	* the following conditions:
	*
	* The above copyright notice and this permission notice (including the
	* next paragraph) shall be included in all copies or substantial portions
	* of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
	* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
	* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*
	**************************************************************************/

	#include "i915_context.h"
	#include "i915_blit.h"
	#include "i915_state.h"
	#include "pipe/p_defines.h"
	#include "pipe/p_util.h"
	#include "pipe/p_inlines.h"
	#include "pipe/p_winsys.h"


	#define CLIP_TILE \
	do { \
	if (x >= ps->width) \
	return; \
	if (y >= ps->height) \
	return; \
	if (x + w > ps->width) \
	w = ps->width - x; \
	if (y + h > ps->height) \
	h = ps->height -y; \
	} while(0)


	/**
	* Note: this is exactly like a8r8g8b8_get_tile() in sp_surface.c
	* Share it someday.
	*/
	static void
	i915_get_tile_rgba(struct pipe_context *pipe,
	struct pipe_surface *ps,
	uint x, uint y, uint w, uint h, float *p)
	{
	const unsigned *src
	= ((const unsigned *) (ps->region->map + ps->offset))
	+ y * ps->pitch + x;
	unsigned i, j;
	unsigned w0 = w;

	CLIP_TILE;

	switch (ps->format) {
	case PIPE_FORMAT_U_A8_R8_G8_B8:
	for (i = 0; i < h; i++) {
	float *pRow = p;
	for (j = 0; j < w; j++) {
	const unsigned pixel = src[j];
	pRow[0] = UBYTE_TO_FLOAT((pixel >> 16) & 0xff);
	pRow[1] = UBYTE_TO_FLOAT((pixel >> 8) & 0xff);
	pRow[2] = UBYTE_TO_FLOAT((pixel >> 0) & 0xff);
	pRow[3] = UBYTE_TO_FLOAT((pixel >> 24) & 0xff);
	pRow += 4;
	}
	src += ps->pitch;
	p += w0 * 4;
	}
	break;
	case PIPE_FORMAT_S8_Z24:
	{
	const float scale = 1.0f / (float) 0xffffff;
	for (i = 0; i < h; i++) {
	float *pRow = p;
	for (j = 0; j < w; j++) {
	const unsigned pixel = src[j];
	pRow[0] =
	pRow[1] =
	pRow[2] =
	pRow[3] = (pixel & 0xffffff) * scale;
	pRow += 4;
	}
	src += ps->pitch;
	p += w0 * 4;
	}
	}
	break;
	default:
	assert(0);
	}
	}


	static void
	i915_put_tile_rgba(struct pipe_context *pipe,
	struct pipe_surface *ps,
	uint x, uint y, uint w, uint h, const float *p)
	{
	/* TODO */
	assert(0);
	}


	/*
	* XXX note: same as code in sp_surface.c
	*/
	static void
	i915_get_tile(struct pipe_context *pipe,
	struct pipe_surface *ps,
	uint x, uint y, uint w, uint h,
	void *p, int dst_stride)
	{
	const uint cpp = ps->cpp;
	const uint w0 = w;
	const ubyte *pSrc;
	ubyte *pDest;
	uint i;

	assert(ps->region->map);

	CLIP_TILE;

	if (dst_stride == 0) {
	dst_stride = w0 * cpp;
	}

	pSrc = ps->region->map + ps->offset + (y * ps->pitch + x) * cpp;
	pDest = (ubyte *) p;

	for (i = 0; i < h; i++) {
	memcpy(pDest, pSrc, w0 * cpp);
	pDest += dst_stride;
	pSrc += ps->pitch * cpp;
	}
	}


	/*
	* XXX note: same as code in sp_surface.c
	*/
	static void
	i915_put_tile(struct pipe_context *pipe,
	struct pipe_surface *ps,
	uint x, uint y, uint w, uint h,
	const void *p, int src_stride)
	{
	const uint cpp = ps->cpp;
	const uint w0 = w;
	const ubyte *pSrc;
	ubyte *pDest;
	uint i;

	assert(ps->region->map);

	CLIP_TILE;

	if (src_stride == 0) {
	src_stride = w0 * cpp;
	}

	pSrc = (const ubyte *) p;
	pDest = ps->region->map + ps->offset + (y * ps->pitch + x) * cpp;

	for (i = 0; i < h; i++) {
	memcpy(pDest, pSrc, w0 * cpp);
	pDest += ps->pitch * cpp;
	pSrc += src_stride;
	}
	}


	/*
	* XXX note: same as code in sp_surface.c
	*/
	static struct pipe_surface *
	i915_get_tex_surface(struct pipe_context *pipe,
	struct pipe_mipmap_tree *mt,
	unsigned face, unsigned level, unsigned zslice)
	{
	struct pipe_surface *ps;
	unsigned offset; /* in bytes */

	offset = mt->level[level].level_offset;

	if (mt->target == PIPE_TEXTURE_CUBE) {
	offset += mt->level[level].image_offset[face] * mt->cpp;
	}
	else if (mt->target == PIPE_TEXTURE_3D) {
	offset += mt->level[level].image_offset[zslice] * mt->cpp;
	}
	else {
	assert(face == 0);
	assert(zslice == 0);
	}

	ps = pipe->winsys->surface_alloc(pipe->winsys, mt->format);
	if (ps) {
	assert(ps->format);
	assert(ps->refcount);
	pipe_region_reference(&ps->region, mt->region);
	ps->cpp = mt->cpp;
	ps->width = mt->level[level].width;
	ps->height = mt->level[level].height;
	ps->pitch = mt->pitch;
	ps->offset = offset;
	}
	return ps;
	}


	/*
	* XXX Move this into core Mesa?
	*/
	static void
	_mesa_copy_rect(ubyte * dst,
	unsigned cpp,
	unsigned dst_pitch,
	unsigned dst_x,
	unsigned dst_y,
	unsigned width,
	unsigned height,
	const ubyte * src,
	unsigned src_pitch,
	unsigned src_x,
	unsigned src_y)
	{
	unsigned i;

	dst_pitch *= cpp;
	src_pitch *= cpp;
	dst += dst_x * cpp;
	src += src_x * cpp;
	dst += dst_y * dst_pitch;
	src += src_y * dst_pitch;
	width *= cpp;

	if (width == dst_pitch && width == src_pitch)
	memcpy(dst, src, height * width);
	else {
	for (i = 0; i < height; i++) {
	memcpy(dst, src, width);
	dst += dst_pitch;
	src += src_pitch;
	}
	}
	}


	/* Upload data to a rectangular sub-region. Lots of choices how to do this:
	*
	* - memcpy by span to current destination
	* - upload data as new buffer and blit
	*
	* Currently always memcpy.
	*/
	static void
	i915_surface_data(struct pipe_context *pipe,
	struct pipe_surface *dst,
	unsigned dstx, unsigned dsty,
	const void *src, unsigned src_pitch,
	unsigned srcx, unsigned srcy, unsigned width, unsigned height)
	{
	_mesa_copy_rect(pipe->region_map(pipe, dst->region) + dst->offset,
	dst->cpp,
	dst->pitch,
	dstx, dsty, width, height, src, src_pitch, srcx, srcy);

	pipe->region_unmap(pipe, dst->region);
	}


	/* Assumes all values are within bounds -- no checking at this level -
	* do it higher up if required.
	*/
	static void
	i915_surface_copy(struct pipe_context *pipe,
	struct pipe_surface *dst,
	unsigned dstx, unsigned dsty,
	struct pipe_surface *src,
	unsigned srcx, unsigned srcy, unsigned width, unsigned height)
	{
	assert( dst != src );
	assert( dst->cpp == src->cpp );

	if (0) {
	_mesa_copy_rect(pipe->region_map(pipe, dst->region) + dst->offset,
	dst->cpp,
	dst->pitch,
	dstx, dsty,
	width, height,
	pipe->region_map(pipe, src->region) + src->offset,
	src->pitch,
	srcx, srcy);

	pipe->region_unmap(pipe, src->region);
	pipe->region_unmap(pipe, dst->region);
	}
	else {
	i915_copy_blit( i915_context(pipe),
	dst->cpp,
	(short) src->pitch, src->region->buffer, src->offset,
	(short) dst->pitch, dst->region->buffer, dst->offset,
	(short) srcx, (short) srcy, (short) dstx, (short) dsty, (short) width, (short) height );
	}
	}

	/* Fill a rectangular sub-region. Need better logic about when to
	* push buffers into AGP - will currently do so whenever possible.
	*/
	static ubyte *
	get_pointer(struct pipe_surface *dst, unsigned x, unsigned y)
	{
	return dst->region->map + (y * dst->pitch + x) * dst->cpp;
	}


	static void
	i915_surface_fill(struct pipe_context *pipe,
	struct pipe_surface *dst,
	unsigned dstx, unsigned dsty,
	unsigned width, unsigned height, unsigned value)
	{
	if (0) {
	unsigned i, j;

	(void)pipe->region_map(pipe, dst->region);

	switch (dst->cpp) {
	case 1: {
	ubyte *row = get_pointer(dst, dstx, dsty);
	for (i = 0; i < height; i++) {
	memset(row, value, width);
	row += dst->pitch;
	}
	}
	break;
	case 2: {
	ushort row = (ushort ) get_pointer(dst, dstx, dsty);
	for (i = 0; i < height; i++) {
	for (j = 0; j < width; j++)
	row[j] = (ushort) value;
	row += dst->pitch;
	}
	}
	break;
	case 4: {
	unsigned row = (unsigned ) get_pointer(dst, dstx, dsty);
	for (i = 0; i < height; i++) {
	for (j = 0; j < width; j++)
	row[j] = value;
	row += dst->pitch;
	}
	}
	break;
	default:
	assert(0);
	break;
	}
	}
	else {
	i915_fill_blit( i915_context(pipe),
	dst->cpp,
	(short) dst->pitch,
	dst->region->buffer, dst->offset,
	(short) dstx, (short) dsty,
	(short) width, (short) height,
	value );
	}
	}


	void
	i915_init_surface_functions(struct i915_context *i915)
	{
	i915->pipe.get_tex_surface = i915_get_tex_surface;
	i915->pipe.get_tile = i915_get_tile;
	i915->pipe.put_tile = i915_put_tile;
	i915->pipe.get_tile_rgba = i915_get_tile_rgba;
	i915->pipe.put_tile_rgba = i915_put_tile_rgba;
	i915->pipe.surface_data = i915_surface_data;
	i915->pipe.surface_copy = i915_surface_copy;
	i915->pipe.surface_fill = i915_surface_fill;
	}