dlls/wined3d/volume.c - wine - Git at Google

 /*
  * Copyright 2002-2005 Jason Edmeades
  * Copyright 2002-2005 Raphael Junqueira
  * Copyright 2005 Oliver Stieber
  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
  * Copyright 2013 Stefan Dösinger for CodeWeavers
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */

 #include "config.h"
 #include "wine/port.h"
 #include "wined3d_private.h"

 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);

 /* This call just uploads data, the caller is responsible for binding the
  * correct texture. */
 /* Context activation is done by the caller. */
 void wined3d_volume_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
         const struct wined3d_context *context, const struct wined3d_const_bo_address *data)
 {
     const struct wined3d_format *format = texture->resource.format;
     unsigned int level = sub_resource_idx % texture->level_count;
     const struct wined3d_gl_info *gl_info = context->gl_info;
     unsigned int width, height, depth;
     const void *mem = data->addr;
     void *converted_mem = NULL;

     TRACE("texture %p, sub_resource_idx %u, context %p, format %s (%#x).\n",
             texture, level, context, debug_d3dformat(format->id), format->id);

     width = wined3d_texture_get_level_width(texture, level);
     height = wined3d_texture_get_level_height(texture, level);
     depth = wined3d_texture_get_level_depth(texture, level);

     if (format->convert)
     {
         UINT dst_row_pitch, dst_slice_pitch;
         UINT src_row_pitch, src_slice_pitch;

         if (data->buffer_object)
             ERR("Loading a converted texture from a PBO.\n");
         if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS)
             ERR("Converting a block-based format.\n");

         dst_row_pitch = width * format->conv_byte_count;
         dst_slice_pitch = dst_row_pitch * height;

         wined3d_texture_get_pitch(texture, level, &src_row_pitch, &src_slice_pitch);

         converted_mem = HeapAlloc(GetProcessHeap(), 0, dst_slice_pitch * depth);
         format->convert(data->addr, converted_mem, src_row_pitch, src_slice_pitch,
                 dst_row_pitch, dst_slice_pitch, width, height, depth);
         mem = converted_mem;
     }

     if (data->buffer_object)
     {
         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, data->buffer_object));
         checkGLcall("glBindBuffer");
     }

     GL_EXTCALL(glTexSubImage3D(GL_TEXTURE_3D, level, 0, 0, 0,
             width, height, depth, format->glFormat, format->glType, mem));
     checkGLcall("glTexSubImage3D");

     if (data->buffer_object)
     {
         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
         checkGLcall("glBindBuffer");
     }

     HeapFree(GetProcessHeap(), 0, converted_mem);
 }

 /* Context activation is done by the caller. */
 static void wined3d_volume_download_data(struct wined3d_volume *volume,
         const struct wined3d_context *context, const struct wined3d_bo_address *data)
 {
     const struct wined3d_format *format = volume->container->resource.format;
     const struct wined3d_gl_info *gl_info = context->gl_info;

     if (format->convert)
     {
         FIXME("Attempting to download a converted volume, format %s.\n",
                 debug_d3dformat(format->id));
         return;
     }

     if (data->buffer_object)
     {
         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object));
         checkGLcall("glBindBuffer");
     }

     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, volume->texture_level,
             format->glFormat, format->glType, data->addr);
     checkGLcall("glGetTexImage");

     if (data->buffer_object)
     {
         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
         checkGLcall("glBindBuffer");
     }

 }

 static DWORD volume_access_from_location(DWORD location)
 {
     switch (location)
     {
         case WINED3D_LOCATION_DISCARDED:
             return 0;

         case WINED3D_LOCATION_SYSMEM:
             return WINED3D_RESOURCE_ACCESS_CPU;

         case WINED3D_LOCATION_BUFFER:
         case WINED3D_LOCATION_TEXTURE_RGB:
         case WINED3D_LOCATION_TEXTURE_SRGB:
             return WINED3D_RESOURCE_ACCESS_GPU;

         default:
             FIXME("Unhandled location %#x.\n", location);
             return 0;
     }
 }

 /* Context activation is done by the caller. */
 static void wined3d_volume_srgb_transfer(struct wined3d_volume *volume,
         struct wined3d_context *context, BOOL dest_is_srgb)
 {
     struct wined3d_texture *texture = volume->container;
     struct wined3d_bo_address data;
     /* Optimizations are possible, but the effort should be put into either
      * implementing EXT_SRGB_DECODE in the driver or finding out why we
      * picked the wrong copy for the original upload and fixing that.
      *
      * Also keep in mind that we want to avoid using resource.heap_memory
      * for DEFAULT pool surfaces. */

     WARN_(d3d_perf)("Performing slow rgb/srgb volume transfer.\n");
     data.buffer_object = 0;
     if (!(data.addr = HeapAlloc(GetProcessHeap(), 0, texture->sub_resources[volume->texture_level].size)))
         return;

     wined3d_texture_bind_and_dirtify(texture, context, !dest_is_srgb);
     wined3d_volume_download_data(volume, context, &data);
     wined3d_texture_bind_and_dirtify(texture, context, dest_is_srgb);
     wined3d_volume_upload_data(texture, volume->texture_level, context, wined3d_const_bo_address(&data));

     HeapFree(GetProcessHeap(), 0, data.addr);
 }

 /* Context activation is done by the caller. */
 BOOL wined3d_volume_load_location(struct wined3d_volume *volume,
         struct wined3d_context *context, DWORD location)
 {
     DWORD required_access = volume_access_from_location(location);
     unsigned int sub_resource_idx = volume->texture_level;
     struct wined3d_texture *texture = volume->container;
     struct wined3d_texture_sub_resource *sub_resource;

     sub_resource = &texture->sub_resources[sub_resource_idx];
     TRACE("Volume %p, loading %s, have %s.\n", volume, wined3d_debug_location(location),
         wined3d_debug_location(sub_resource->locations));

     if ((sub_resource->locations & location) == location)
     {
         TRACE("Location(s) already up to date.\n");
         return TRUE;
     }

     if ((texture->resource.access_flags & required_access) != required_access)
     {
         ERR("Operation requires %#x access, but volume only has %#x.\n",
                 required_access, texture->resource.access_flags);
         return FALSE;
     }

     if (!wined3d_texture_prepare_location(texture, sub_resource_idx, context, location))
         return FALSE;

     if (sub_resource->locations & WINED3D_LOCATION_DISCARDED)
     {
         TRACE("Volume previously discarded, nothing to do.\n");
         wined3d_texture_validate_location(texture, sub_resource_idx, location);
         wined3d_texture_invalidate_location(texture, sub_resource_idx, WINED3D_LOCATION_DISCARDED);
         goto done;
     }

     switch (location)
     {
         case WINED3D_LOCATION_TEXTURE_RGB:
         case WINED3D_LOCATION_TEXTURE_SRGB:
             if (sub_resource->locations & WINED3D_LOCATION_SYSMEM)
             {
                 struct wined3d_const_bo_address data = {0, texture->resource.heap_memory};
                 data.addr += sub_resource->offset;
                 wined3d_texture_bind_and_dirtify(texture, context,
                         location == WINED3D_LOCATION_TEXTURE_SRGB);
                 wined3d_volume_upload_data(texture, sub_resource_idx, context, &data);
             }
             else if (sub_resource->locations & WINED3D_LOCATION_BUFFER)
             {
                 struct wined3d_const_bo_address data = {sub_resource->buffer_object, NULL};
                 wined3d_texture_bind_and_dirtify(texture, context,
                         location == WINED3D_LOCATION_TEXTURE_SRGB);
                 wined3d_volume_upload_data(texture, sub_resource_idx, context, &data);
             }
             else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
             {
                 wined3d_volume_srgb_transfer(volume, context, TRUE);
             }
             else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_SRGB)
             {
                 wined3d_volume_srgb_transfer(volume, context, FALSE);
             }
             else
             {
                 FIXME("Implement texture loading from %s.\n", wined3d_debug_location(sub_resource->locations));
                 return FALSE;
             }
             break;

         case WINED3D_LOCATION_SYSMEM:
             if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
             {
                 struct wined3d_bo_address data = {0, texture->resource.heap_memory};

                 data.addr += sub_resource->offset;
                 if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
                     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
                 else
                     wined3d_texture_bind_and_dirtify(texture, context, TRUE);

                 wined3d_volume_download_data(volume, context, &data);
                 ++texture->download_count;
             }
             else
             {
                 FIXME("Implement WINED3D_LOCATION_SYSMEM loading from %s.\n",
                         wined3d_debug_location(sub_resource->locations));
                 return FALSE;
             }
             break;

         case WINED3D_LOCATION_BUFFER:
             if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
             {
                 struct wined3d_bo_address data = {sub_resource->buffer_object, NULL};

                 if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
                     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
                 else
                     wined3d_texture_bind_and_dirtify(texture, context, TRUE);

                 wined3d_volume_download_data(volume, context, &data);
             }
             else
             {
                 FIXME("Implement WINED3D_LOCATION_BUFFER loading from %s.\n",
                         wined3d_debug_location(sub_resource->locations));
                 return FALSE;
             }
             break;

         default:
             FIXME("Implement %s loading from %s.\n", wined3d_debug_location(location),
                     wined3d_debug_location(sub_resource->locations));
             return FALSE;
     }

 done:
     wined3d_texture_validate_location(texture, sub_resource_idx, location);

     return TRUE;
 }
	/*
	* Copyright 2002-2005 Jason Edmeades
	* Copyright 2002-2005 Raphael Junqueira
	* Copyright 2005 Oliver Stieber
	* Copyright 2009-2011 Henri Verbeet for CodeWeavers
	* Copyright 2013 Stefan Dösinger for CodeWeavers
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
	*/

	#include "config.h"
	#include "wine/port.h"
	#include "wined3d_private.h"

	WINE_DEFAULT_DEBUG_CHANNEL(d3d);
	WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);

	/* This call just uploads data, the caller is responsible for binding the
	* correct texture. */
	/* Context activation is done by the caller. */
	void wined3d_volume_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
	const struct wined3d_context context, const struct wined3d_const_bo_address data)
	{
	const struct wined3d_format *format = texture->resource.format;
	unsigned int level = sub_resource_idx % texture->level_count;
	const struct wined3d_gl_info *gl_info = context->gl_info;
	unsigned int width, height, depth;
	const void *mem = data->addr;
	void *converted_mem = NULL;

	TRACE("texture %p, sub_resource_idx %u, context %p, format %s (%#x).\n",
	texture, level, context, debug_d3dformat(format->id), format->id);

	width = wined3d_texture_get_level_width(texture, level);
	height = wined3d_texture_get_level_height(texture, level);
	depth = wined3d_texture_get_level_depth(texture, level);

	if (format->convert)
	{
	UINT dst_row_pitch, dst_slice_pitch;
	UINT src_row_pitch, src_slice_pitch;

	if (data->buffer_object)
	ERR("Loading a converted texture from a PBO.\n");
	if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS)
	ERR("Converting a block-based format.\n");

	dst_row_pitch = width * format->conv_byte_count;
	dst_slice_pitch = dst_row_pitch * height;

	wined3d_texture_get_pitch(texture, level, &src_row_pitch, &src_slice_pitch);

	converted_mem = HeapAlloc(GetProcessHeap(), 0, dst_slice_pitch * depth);
	format->convert(data->addr, converted_mem, src_row_pitch, src_slice_pitch,
	dst_row_pitch, dst_slice_pitch, width, height, depth);
	mem = converted_mem;
	}

	if (data->buffer_object)
	{
	GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, data->buffer_object));
	checkGLcall("glBindBuffer");
	}

	GL_EXTCALL(glTexSubImage3D(GL_TEXTURE_3D, level, 0, 0, 0,
	width, height, depth, format->glFormat, format->glType, mem));
	checkGLcall("glTexSubImage3D");

	if (data->buffer_object)
	{
	GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
	checkGLcall("glBindBuffer");
	}

	HeapFree(GetProcessHeap(), 0, converted_mem);
	}

	/* Context activation is done by the caller. */
	static void wined3d_volume_download_data(struct wined3d_volume *volume,
	const struct wined3d_context context, const struct wined3d_bo_address data)
	{
	const struct wined3d_format *format = volume->container->resource.format;
	const struct wined3d_gl_info *gl_info = context->gl_info;

	if (format->convert)
	{
	FIXME("Attempting to download a converted volume, format %s.\n",
	debug_d3dformat(format->id));
	return;
	}

	if (data->buffer_object)
	{
	GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object));
	checkGLcall("glBindBuffer");
	}

	gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, volume->texture_level,
	format->glFormat, format->glType, data->addr);
	checkGLcall("glGetTexImage");

	if (data->buffer_object)
	{
	GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
	checkGLcall("glBindBuffer");
	}

	}

	static DWORD volume_access_from_location(DWORD location)
	{
	switch (location)
	{
	case WINED3D_LOCATION_DISCARDED:
	return 0;

	case WINED3D_LOCATION_SYSMEM:
	return WINED3D_RESOURCE_ACCESS_CPU;

	case WINED3D_LOCATION_BUFFER:
	case WINED3D_LOCATION_TEXTURE_RGB:
	case WINED3D_LOCATION_TEXTURE_SRGB:
	return WINED3D_RESOURCE_ACCESS_GPU;

	default:
	FIXME("Unhandled location %#x.\n", location);
	return 0;
	}
	}

	/* Context activation is done by the caller. */
	static void wined3d_volume_srgb_transfer(struct wined3d_volume *volume,
	struct wined3d_context *context, BOOL dest_is_srgb)
	{
	struct wined3d_texture *texture = volume->container;
	struct wined3d_bo_address data;
	/* Optimizations are possible, but the effort should be put into either
	* implementing EXT_SRGB_DECODE in the driver or finding out why we
	* picked the wrong copy for the original upload and fixing that.
	*
	* Also keep in mind that we want to avoid using resource.heap_memory
	* for DEFAULT pool surfaces. */

	WARN_(d3d_perf)("Performing slow rgb/srgb volume transfer.\n");
	data.buffer_object = 0;
	if (!(data.addr = HeapAlloc(GetProcessHeap(), 0, texture->sub_resources[volume->texture_level].size)))
	return;

	wined3d_texture_bind_and_dirtify(texture, context, !dest_is_srgb);
	wined3d_volume_download_data(volume, context, &data);
	wined3d_texture_bind_and_dirtify(texture, context, dest_is_srgb);
	wined3d_volume_upload_data(texture, volume->texture_level, context, wined3d_const_bo_address(&data));

	HeapFree(GetProcessHeap(), 0, data.addr);
	}

	/* Context activation is done by the caller. */
	BOOL wined3d_volume_load_location(struct wined3d_volume *volume,
	struct wined3d_context *context, DWORD location)
	{
	DWORD required_access = volume_access_from_location(location);
	unsigned int sub_resource_idx = volume->texture_level;
	struct wined3d_texture *texture = volume->container;
	struct wined3d_texture_sub_resource *sub_resource;

	sub_resource = &texture->sub_resources[sub_resource_idx];
	TRACE("Volume %p, loading %s, have %s.\n", volume, wined3d_debug_location(location),
	wined3d_debug_location(sub_resource->locations));

	if ((sub_resource->locations & location) == location)
	{
	TRACE("Location(s) already up to date.\n");
	return TRUE;
	}

	if ((texture->resource.access_flags & required_access) != required_access)
	{
	ERR("Operation requires %#x access, but volume only has %#x.\n",
	required_access, texture->resource.access_flags);
	return FALSE;
	}

	if (!wined3d_texture_prepare_location(texture, sub_resource_idx, context, location))
	return FALSE;

	if (sub_resource->locations & WINED3D_LOCATION_DISCARDED)
	{
	TRACE("Volume previously discarded, nothing to do.\n");
	wined3d_texture_validate_location(texture, sub_resource_idx, location);
	wined3d_texture_invalidate_location(texture, sub_resource_idx, WINED3D_LOCATION_DISCARDED);
	goto done;
	}

	switch (location)
	{
	case WINED3D_LOCATION_TEXTURE_RGB:
	case WINED3D_LOCATION_TEXTURE_SRGB:
	if (sub_resource->locations & WINED3D_LOCATION_SYSMEM)
	{
	struct wined3d_const_bo_address data = {0, texture->resource.heap_memory};
	data.addr += sub_resource->offset;
	wined3d_texture_bind_and_dirtify(texture, context,
	location == WINED3D_LOCATION_TEXTURE_SRGB);
	wined3d_volume_upload_data(texture, sub_resource_idx, context, &data);
	}
	else if (sub_resource->locations & WINED3D_LOCATION_BUFFER)
	{
	struct wined3d_const_bo_address data = {sub_resource->buffer_object, NULL};
	wined3d_texture_bind_and_dirtify(texture, context,
	location == WINED3D_LOCATION_TEXTURE_SRGB);
	wined3d_volume_upload_data(texture, sub_resource_idx, context, &data);
	}
	else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
	{
	wined3d_volume_srgb_transfer(volume, context, TRUE);
	}
	else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_SRGB)
	{
	wined3d_volume_srgb_transfer(volume, context, FALSE);
	}
	else
	{
	FIXME("Implement texture loading from %s.\n", wined3d_debug_location(sub_resource->locations));
	return FALSE;
	}
	break;

	case WINED3D_LOCATION_SYSMEM:
	if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB \| WINED3D_LOCATION_TEXTURE_SRGB))
	{
	struct wined3d_bo_address data = {0, texture->resource.heap_memory};

	data.addr += sub_resource->offset;
	if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
	wined3d_texture_bind_and_dirtify(texture, context, FALSE);
	else
	wined3d_texture_bind_and_dirtify(texture, context, TRUE);

	wined3d_volume_download_data(volume, context, &data);
	++texture->download_count;
	}
	else
	{
	FIXME("Implement WINED3D_LOCATION_SYSMEM loading from %s.\n",
	wined3d_debug_location(sub_resource->locations));
	return FALSE;
	}
	break;

	case WINED3D_LOCATION_BUFFER:
	if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB \| WINED3D_LOCATION_TEXTURE_SRGB))
	{
	struct wined3d_bo_address data = {sub_resource->buffer_object, NULL};

	if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
	wined3d_texture_bind_and_dirtify(texture, context, FALSE);
	else
	wined3d_texture_bind_and_dirtify(texture, context, TRUE);

	wined3d_volume_download_data(volume, context, &data);
	}
	else
	{
	FIXME("Implement WINED3D_LOCATION_BUFFER loading from %s.\n",
	wined3d_debug_location(sub_resource->locations));
	return FALSE;
	}
	break;

	default:
	FIXME("Implement %s loading from %s.\n", wined3d_debug_location(location),
	wined3d_debug_location(sub_resource->locations));
	return FALSE;
	}

	done:
	wined3d_texture_validate_location(texture, sub_resource_idx, location);

	return TRUE;
	}