fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-07 07:08:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Add printf handlers, pass pci id and move texlayout code to driver.

Browse source
This commit is contained in:
Keith Whitwell 2007-08-10 10:02:34 +01:00
parent c12b71ef93
commit 938c307e45
9 changed files with 37 additions and 525 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/mesa/drivers/dri/intel_winsys/Makefile
View file

@ -14,7 +14,6 @@ DRIVER_SOURCES = \
intel_pipe_i915simple.c \
intel_pipe_softpipe.c \
intel_batchbuffer.c \
intel_tex_layout.c \
intel_buffers.c \
intel_blit.c \
intel_context.c \

26
src/mesa/drivers/dri/intel_winsys/intel_context.c
View file

@ -243,6 +243,8 @@ intelFlush(GLcontext * ctx)
{
struct intel_context *intel = intel_context(ctx);
/* Hmm:
*/
intel->pipe->flush( intel->pipe, 0 );
}
@ -421,8 +423,6 @@ intelCreateContext(const __GLcontextModes * mesaVis,
*/
if (!getenv("INTEL_HW")) {
intel->pipe = intel_create_softpipe( intel );
/* use default softpipe function for surface_alloc() */
intel->pipe->supported_formats = intel_supported_formats;
}
else {
switch (intel->intelScreen->deviceID) {
@ -447,28 +447,6 @@ intelCreateContext(const __GLcontextModes * mesaVis,
st_create_context( &intel->ctx, intel->pipe );
/* TODO: Push this down into the pipe driver:
*/
switch (intel->intelScreen->deviceID) {
case PCI_CHIP_I945_G:
case PCI_CHIP_I945_GM:
case PCI_CHIP_I945_GME:
case PCI_CHIP_G33_G:
case PCI_CHIP_Q33_G:
case PCI_CHIP_Q35_G:
intel->pipe->mipmap_tree_layout = i945_miptree_layout;
break;
case PCI_CHIP_I915_G:
case PCI_CHIP_I915_GM:
case PCI_CHIP_I830_M:
case PCI_CHIP_I855_GM:
case PCI_CHIP_I865_G:
intel->pipe->mipmap_tree_layout = i915_miptree_layout;
default:
assert(0); /*FIX*/
}
return GL_TRUE;
}

17
src/mesa/drivers/dri/intel_winsys/intel_pipe_i915simple.c
View file

@ -227,10 +227,18 @@ static void intel_i915_batch_flush( struct i915_winsys *sws )
{
struct intel_context *intel = intel_i915_winsys(sws)->intel;
_mesa_printf("%s: start\n");
intel_batchbuffer_flush( intel->batch );
intel_i915_batch_wait_idle( sws );
_mesa_printf("%s: done\n");
if (0) intel_i915_batch_wait_idle( sws );
}
static void intel_i915_printf( struct i915_winsys *sws,
const char *fmtString, ... )
{
va_list args;
va_start( args, fmtString );
vfprintf(stderr, fmtString, args);
va_end( args );
}
@ -242,6 +250,7 @@ intel_create_i915simple( struct intel_context *intel )
/* Fill in this struct with callbacks that i915simple will need to
* communicate with the window system, buffer manager, etc.
*/
iws->winsys.printf = intel_i915_printf;
iws->winsys.buffer_create = intel_i915_buffer_create;
iws->winsys.buffer_map = intel_i915_buffer_map;
iws->winsys.buffer_unmap = intel_i915_buffer_unmap;
@ -259,5 +268,5 @@ intel_create_i915simple( struct intel_context *intel )
/* Create the i915simple context:
*/
return i915_create( &iws->winsys );
return i915_create( &iws->winsys, intel->intelScreen->deviceID );
}

14
src/mesa/drivers/dri/intel_winsys/intel_pipe_softpipe.c
View file

@ -36,9 +36,14 @@
#include "intel_context.h"
#include "intel_pipe.h"
#include "intel_surface.h"
#include "pipe/softpipe/sp_winsys.h"
/* Shouldn't really need this:
*/
#include "pipe/p_context.h"
struct intel_softpipe_winsys {
struct softpipe_winsys sws;
@ -157,6 +162,7 @@ struct pipe_context *
intel_create_softpipe( struct intel_context *intel )
{
struct intel_softpipe_winsys *isws = CALLOC_STRUCT( intel_softpipe_winsys );
struct pipe_context *pipe;
/* Fill in this struct with callbacks that softpipe will need to
* communicate with the window system, buffer manager, etc.
@ -177,5 +183,11 @@ intel_create_softpipe( struct intel_context *intel )
/* Create the softpipe context:
*/
return softpipe_create( &isws->sws );
pipe = softpipe_create( &isws->sws );
/* XXX: This should probably be a parameter to softpipe_create()
*/
pipe->supported_formats = intel_supported_formats;
return pipe;
}

476
src/mesa/drivers/dri/intel_winsys/intel_tex_layout.c
View file

@ -1,476 +0,0 @@
/**************************************************************************
*
* Copyright 2006 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.
*
**************************************************************************/
/*
* Authors:
* Keith Whitwell <keith@tungstengraphics.com>
* Michel Dänzer <michel@tungstengraphics.com>
*/
#include "macros.h"
#include "pipe/p_state.h"
#include "pipe/p_context.h"
#include "intel_tex_layout.h"
#include "state_tracker/st_mipmap_tree.h"
static GLuint minify( GLuint d )
{
return MAX2(1, d>>1);
}
static int align(int value, int alignment)
{
return (value + alignment - 1) & ~(alignment - 1);
}
static void
intel_miptree_set_level_info(struct pipe_mipmap_tree *mt,
GLuint level,
GLuint nr_images,
GLuint x, GLuint y, GLuint w, GLuint h, GLuint d)
{
assert(level < MAX_TEXTURE_LEVELS);
mt->level[level].width = w;
mt->level[level].height = h;
mt->level[level].depth = d;
mt->level[level].level_offset = (x + y * mt->pitch) * mt->cpp;
mt->level[level].nr_images = nr_images;
/*
DBG("%s level %d size: %d,%d,%d offset %d,%d (0x%x)\n", __FUNCTION__,
level, w, h, d, x, y, mt->level[level].level_offset);
*/
/* Not sure when this would happen, but anyway:
*/
if (mt->level[level].image_offset) {
free(mt->level[level].image_offset);
mt->level[level].image_offset = NULL;
}
assert(nr_images);
assert(!mt->level[level].image_offset);
mt->level[level].image_offset = (GLuint *) malloc(nr_images * sizeof(GLuint));
mt->level[level].image_offset[0] = 0;
}
static void
intel_miptree_set_image_offset(struct pipe_mipmap_tree *mt,
GLuint level, GLuint img, GLuint x, GLuint y)
{
if (img == 0 && level == 0)
assert(x == 0 && y == 0);
assert(img < mt->level[level].nr_images);
mt->level[level].image_offset[img] = (x + y * mt->pitch);
/*
DBG("%s level %d img %d pos %d,%d image_offset %x\n",
__FUNCTION__, level, img, x, y, mt->level[level].image_offset[img]);
*/
}
static void
i945_miptree_layout_2d( struct pipe_mipmap_tree *mt )
{
GLint align_h = 2, align_w = 4;
GLuint level;
GLuint x = 0;
GLuint y = 0;
GLuint width = mt->width0;
GLuint height = mt->height0;
mt->pitch = mt->width0;
/* May need to adjust pitch to accomodate the placement of
* the 2nd mipmap. This occurs when the alignment
* constraints of mipmap placement push the right edge of the
* 2nd mipmap out past the width of its parent.
*/
if (mt->first_level != mt->last_level) {
GLuint mip1_width = align(minify(mt->width0), align_w)
+ minify(minify(mt->width0));
if (mip1_width > mt->width0)
mt->pitch = mip1_width;
}
/* Pitch must be a whole number of dwords, even though we
* express it in texels.
*/
mt->pitch = align(mt->pitch * mt->cpp, 4) / mt->cpp;
mt->total_height = 0;
for ( level = mt->first_level ; level <= mt->last_level ; level++ ) {
GLuint img_height;
intel_miptree_set_level_info(mt, level, 1, x, y, width, height, 1);
if (mt->compressed)
img_height = MAX2(1, height/4);
else
img_height = align(height, align_h);
/* Because the images are packed better, the final offset
* might not be the maximal one:
*/
mt->total_height = MAX2(mt->total_height, y + img_height);
/* Layout_below: step right after second mipmap.
*/
if (level == mt->first_level + 1) {
x += align(width, align_w);
}
else {
y += img_height;
}
width = minify(width);
height = minify(height);
}
}
static const GLint initial_offsets[6][2] = {
{0, 0},
{0, 2},
{1, 0},
{1, 2},
{1, 1},
{1, 3}
};
static const GLint step_offsets[6][2] = {
{0, 2},
{0, 2},
{-1, 2},
{-1, 2},
{-1, 1},
{-1, 1}
};
GLboolean
i915_miptree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree * mt)
{
GLint level;
switch (mt->target) {
case GL_TEXTURE_CUBE_MAP:{
const GLuint dim = mt->width0;
GLuint face;
GLuint lvlWidth = mt->width0, lvlHeight = mt->height0;
assert(lvlWidth == lvlHeight); /* cubemap images are square */
/* double pitch for cube layouts */
mt->pitch = ((dim * mt->cpp * 2 + 3) & ~3) / mt->cpp;
mt->total_height = dim * 4;
for (level = mt->first_level; level <= mt->last_level; level++) {
intel_miptree_set_level_info(mt, level, 6,
0, 0,
/*OLD: mt->pitch, mt->total_height,*/
lvlWidth, lvlHeight,
1);
lvlWidth /= 2;
lvlHeight /= 2;
}
for (face = 0; face < 6; face++) {
GLuint x = initial_offsets[face][0] * dim;
GLuint y = initial_offsets[face][1] * dim;
GLuint d = dim;
for (level = mt->first_level; level <= mt->last_level; level++) {
intel_miptree_set_image_offset(mt, level, face, x, y);
if (d == 0)
_mesa_printf("cube mipmap %d/%d (%d..%d) is 0x0\n",
face, level, mt->first_level, mt->last_level);
d >>= 1;
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
}
}
break;
}
case GL_TEXTURE_3D:{
GLuint width = mt->width0;
GLuint height = mt->height0;
GLuint depth = mt->depth0;
GLuint stack_height = 0;
/* Calculate the size of a single slice.
*/
mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
/* XXX: hardware expects/requires 9 levels at minimum.
*/
for (level = mt->first_level; level <= MAX2(8, mt->last_level);
level++) {
intel_miptree_set_level_info(mt, level, depth, 0, mt->total_height,
width, height, depth);
stack_height += MAX2(2, height);
width = minify(width);
height = minify(height);
depth = minify(depth);
}
/* Fixup depth image_offsets:
*/
depth = mt->depth0;
for (level = mt->first_level; level <= mt->last_level; level++) {
GLuint i;
for (i = 0; i < depth; i++)
intel_miptree_set_image_offset(mt, level, i,
0, i * stack_height);
depth = minify(depth);
}
/* Multiply slice size by texture depth for total size. It's
* remarkable how wasteful of memory the i915 texture layouts
* are. They are largely fixed in the i945.
*/
mt->total_height = stack_height * mt->depth0;
break;
}
default:{
GLuint width = mt->width0;
GLuint height = mt->height0;
GLuint img_height;
mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
mt->total_height = 0;
for (level = mt->first_level; level <= mt->last_level; level++) {
intel_miptree_set_level_info(mt, level, 1,
0, mt->total_height,
width, height, 1);
if (mt->compressed)
img_height = MAX2(1, height / 4);
else
img_height = (MAX2(2, height) + 1) & ~1;
mt->total_height += img_height;
width = minify(width);
height = minify(height);
}
break;
}
}
/*
DBG("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
mt->pitch,
mt->total_height, mt->cpp, mt->pitch * mt->total_height * mt->cpp);
*/
return GL_TRUE;
}
GLboolean
i945_miptree_layout(struct pipe_context *pipe, struct pipe_mipmap_tree * mt)
{
GLint level;
switch (mt->target) {
case GL_TEXTURE_CUBE_MAP:{
const GLuint dim = mt->width0;
GLuint face;
GLuint lvlWidth = mt->width0, lvlHeight = mt->height0;
assert(lvlWidth == lvlHeight); /* cubemap images are square */
/* Depending on the size of the largest images, pitch can be
* determined either by the old-style packing of cubemap faces,
* or the final row of 4x4, 2x2 and 1x1 faces below this.
*/
if (dim > 32)
mt->pitch = ((dim * mt->cpp * 2 + 3) & ~3) / mt->cpp;
else
mt->pitch = 14 * 8;
mt->total_height = dim * 4 + 4;
/* Set all the levels to effectively occupy the whole rectangular region.
*/
for (level = mt->first_level; level <= mt->last_level; level++) {
intel_miptree_set_level_info(mt, level, 6,
0, 0,
lvlWidth, lvlHeight, 1);
lvlWidth /= 2;
lvlHeight /= 2;
}
for (face = 0; face < 6; face++) {
GLuint x = initial_offsets[face][0] * dim;
GLuint y = initial_offsets[face][1] * dim;
GLuint d = dim;
if (dim == 4 && face >= 4) {
y = mt->total_height - 4;
x = (face - 4) * 8;
}
else if (dim < 4 && (face > 0 || mt->first_level > 0)) {
y = mt->total_height - 4;
x = face * 8;
}
for (level = mt->first_level; level <= mt->last_level; level++) {
intel_miptree_set_image_offset(mt, level, face, x, y);
d >>= 1;
switch (d) {
case 4:
switch (face) {
case FACE_POS_X:
case FACE_NEG_X:
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
break;
case FACE_POS_Y:
case FACE_NEG_Y:
y += 12;
x -= 8;
break;
case FACE_POS_Z:
case FACE_NEG_Z:
y = mt->total_height - 4;
x = (face - 4) * 8;
break;
}
case 2:
y = mt->total_height - 4;
x = 16 + face * 8;
break;
case 1:
x += 48;
break;
default:
x += step_offsets[face][0] * d;
y += step_offsets[face][1] * d;
break;
}
}
}
break;
}
case GL_TEXTURE_3D:{
GLuint width = mt->width0;
GLuint height = mt->height0;
GLuint depth = mt->depth0;
GLuint pack_x_pitch, pack_x_nr;
GLuint pack_y_pitch;
GLuint level;
mt->pitch = ((mt->width0 * mt->cpp + 3) & ~3) / mt->cpp;
mt->total_height = 0;
pack_y_pitch = MAX2(mt->height0, 2);
pack_x_pitch = mt->pitch;
pack_x_nr = 1;
for (level = mt->first_level; level <= mt->last_level; level++) {
GLuint nr_images = mt->target == GL_TEXTURE_3D ? depth : 6;
GLint x = 0;
GLint y = 0;
GLint q, j;
intel_miptree_set_level_info(mt, level, nr_images,
0, mt->total_height,
width, height, depth);
for (q = 0; q < nr_images;) {
for (j = 0; j < pack_x_nr && q < nr_images; j++, q++) {
intel_miptree_set_image_offset(mt, level, q, x, y);
x += pack_x_pitch;
}
x = 0;
y += pack_y_pitch;
}
mt->total_height += y;
if (pack_x_pitch > 4) {
pack_x_pitch >>= 1;
pack_x_nr <<= 1;
assert(pack_x_pitch * pack_x_nr <= mt->pitch);
}
if (pack_y_pitch > 2) {
pack_y_pitch >>= 1;
}
width = minify(width);
height = minify(height);
depth = minify(depth);
}
break;
}
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE_ARB:
i945_miptree_layout_2d(mt);
break;
default:
_mesa_problem(NULL, "Unexpected tex target in i945_miptree_layout()");
}
/*
DBG("%s: %dx%dx%d - sz 0x%x\n", __FUNCTION__,
mt->pitch,
mt->total_height, mt->cpp, mt->pitch * mt->total_height * mt->cpp);
*/
return GL_TRUE;
}

16
src/mesa/drivers/dri/intel_winsys/intel_tex_layout.h
View file

@ -1,16 +0,0 @@
#ifndef INTEL_TEX_LAYOUT_H
#define INTEL_TEX_LAYOUT_H
struct pipe_context;
struct pipe_mipmap_tree;
extern GLboolean
i915_miptree_layout(struct pipe_context *, struct pipe_mipmap_tree *);
extern GLboolean
i945_miptree_layout(struct pipe_context *, struct pipe_mipmap_tree *);
#endif /* INTEL_TEX_LAYOUT_H */

4
src/mesa/main/imports.c
View file

@ -902,12 +902,10 @@ _mesa_sprintf( char *str, const char *fmt, ... )
void
_mesa_printf( const char *fmtString, ... )
{
char s[MAXSTRING];
va_list args;
va_start( args, fmtString );
vsnprintf(s, MAXSTRING, fmtString, args);
vfprintf(stderr, fmtString, args);
va_end( args );
fprintf(stderr,"%s", s);
}
/** Wrapper around vsprintf() */

1
src/mesa/pipe/i915simple/Makefile
View file

@ -21,6 +21,7 @@ DRIVER_SOURCES = \
i915_state_emit.c \
i915_state_fragprog.c \
i915_prim_emit.c \
i915_tex_layout.c \
i915_surface.c
C_SOURCES = \

7
src/mesa/pipe/i915simple/i915_context.c
View file

@ -29,6 +29,7 @@
#include "i915_context.h"
#include "i915_winsys.h"
#include "i915_state.h"
#include "i915_tex_layout.h"
#include "pipe/draw/draw_context.h"
#include "pipe/p_defines.h"
@ -207,6 +208,12 @@ struct pipe_context *i915_create( struct i915_winsys *winsys,
i915_init_flush_functions(i915);
if (i915->flags.is_i945)
i915->pipe.mipmap_tree_layout = i945_miptree_layout;
else
i915->pipe.mipmap_tree_layout = i945_miptree_layout;
i915->dirty = ~0;
i915->hardware_dirty = ~0;