/** * Find the live intervals for each temporary register in the program. * For register R, the interval [A,B] indicates that R is referenced * from instruction A through instruction B. * Special consideration is needed for loops and subroutines. * \return GL_TRUE if success, GL_FALSE if we cannot proceed for some reason */ static GLboolean find_live_intervals(struct gl_program *prog, struct interval_list *liveIntervals) { GLint intBegin[MAX_PROGRAM_TEMPS], intEnd[MAX_PROGRAM_TEMPS]; GLuint i; /* * Note: we'll return GL_FALSE below if we find relative indexing * into the TEMP register file. We can't handle that yet. * We also give up on subroutines for now. */ if (dbg) { _mesa_printf("Optimize: Begin find intervals\n"); } /* build intermediate arrays */ if (!_mesa_find_temp_intervals(prog->Instructions, prog->NumInstructions, intBegin, intEnd)) return GL_FALSE; /* Build live intervals list from intermediate arrays */ liveIntervals->Num = 0; for (i = 0; i < MAX_PROGRAM_TEMPS; i++) { if (intBegin[i] >= 0) { struct interval inv; inv.Reg = i; inv.Start = intBegin[i]; inv.End = intEnd[i]; append_interval(liveIntervals, &inv); } } /* Sort the list according to interval starts */ sort_interval_list_by_start(liveIntervals); if (dbg) { /* print interval info */ for (i = 0; i < liveIntervals->Num; i++) { const struct interval *inv = liveIntervals->Intervals + i; _mesa_printf("Reg[%d] live [%d, %d]:", inv->Reg, inv->Start, inv->End); if (1) { int j; for (j = 0; j < inv->Start; j++) _mesa_printf(" "); for (j = inv->Start; j <= inv->End; j++) _mesa_printf("x"); } _mesa_printf("\n"); } } return GL_TRUE; }
static void PrintDstReg(const struct prog_dst_register *dst) { if (dst->File == PROGRAM_OUTPUT) { _mesa_printf("o[%s]", OutputRegisters[dst->Index]); } else if (dst->File == PROGRAM_INPUT) { _mesa_printf("v[%s]", InputRegisters[dst->Index]); } else if (dst->File == PROGRAM_ENV_PARAM) { _mesa_printf("c[%d]", dst->Index); } else { ASSERT(dst->File == PROGRAM_TEMPORARY); _mesa_printf("R%d", dst->Index); } if (dst->WriteMask != 0 && dst->WriteMask != WRITEMASK_XYZW) { _mesa_printf("."); if (dst->WriteMask & WRITEMASK_X) _mesa_printf("x"); if (dst->WriteMask & WRITEMASK_Y) _mesa_printf("y"); if (dst->WriteMask & WRITEMASK_Z) _mesa_printf("z"); if (dst->WriteMask & WRITEMASK_W) _mesa_printf("w"); } }
static void PrintDstReg(const struct vp_dst_register *dst) { GLint w = dst->WriteMask[0] + dst->WriteMask[1] + dst->WriteMask[2] + dst->WriteMask[3]; if (dst->File == PROGRAM_OUTPUT) { _mesa_printf("o[%s]", OutputRegisters[dst->Index]); } else if (dst->File == PROGRAM_INPUT) { _mesa_printf("v[%s]", InputRegisters[dst->Index]); } else if (dst->File == PROGRAM_ENV_PARAM) { _mesa_printf("c[%d]", dst->Index); } else { ASSERT(dst->File == PROGRAM_TEMPORARY); _mesa_printf("R%d", dst->Index); } if (w != 0 && w != 4) { _mesa_printf("."); if (dst->WriteMask[0]) _mesa_printf("x"); if (dst->WriteMask[1]) _mesa_printf("y"); if (dst->WriteMask[2]) _mesa_printf("z"); if (dst->WriteMask[3]) _mesa_printf("w"); } }
void _mesa_print_swizzle(GLuint swizzle) { if (swizzle == SWIZZLE_XYZW) { _mesa_printf(".xyzw\n"); } else { const char *s = _mesa_swizzle_string(swizzle, 0, 0); _mesa_printf("%s\n", s); } }
/* Use a hashtable to attempt to identify recently-emitted vertices * and avoid re-emitting them. */ static GLuint elt(struct copy_context *copy, GLuint elt_idx) { GLuint elt = copy->srcelt[elt_idx]; GLuint slot = elt & (ELT_TABLE_SIZE-1); /* _mesa_printf("elt %d\n", elt); */ /* Look up the incoming element in the vertex cache. Re-emit if * necessary. */ if (copy->vert_cache[slot].in != elt) { GLubyte *csr = copy->dstptr; GLuint i; /* _mesa_printf(" --> emit to dstelt %d\n", copy->dstbuf_nr); */ for (i = 0; i < copy->nr_varying; i++) { const struct gl_client_array *srcarray = copy->varying[i].array; const GLubyte *srcptr = copy->varying[i].src_ptr + elt * srcarray->StrideB; memcpy(csr, srcptr, copy->varying[i].size); csr += copy->varying[i].size; if (0) { const GLuint *f = (const GLuint *)srcptr; GLuint j; _mesa_printf(" varying %d: ", i); for(j = 0; j < copy->varying[i].size / 4; j++) _mesa_printf("%x ", f[j]); _mesa_printf("\n"); } } copy->vert_cache[slot].in = elt; copy->vert_cache[slot].out = copy->dstbuf_nr++; copy->dstptr += copy->vertex_size; assert(csr == copy->dstptr); assert(copy->dstptr == (copy->dstbuf + copy->dstbuf_nr * copy->vertex_size)); } /* else */ /* _mesa_printf(" --> reuse vertex\n"); */ /* _mesa_printf(" --> emit %d\n", copy->vert_cache[slot].out); */ copy->dstelt[copy->dstelt_nr++] = copy->vert_cache[slot].out; return check_flush(copy); }
GLuint vf_set_vertex_attributes( struct vertex_fetch *vf, const struct vf_attr_map *map, GLuint nr, GLuint vertex_stride ) { GLuint offset = 0; GLuint i, j; assert(nr < VF_ATTRIB_MAX); memset(vf->lookup, 0, sizeof(vf->lookup)); for (j = 0, i = 0; i < nr; i++) { const GLuint format = map[i].format; if (format == EMIT_PAD) { if (DBG) _mesa_printf("%d: pad %d, offset %d\n", i, map[i].offset, offset); offset += map[i].offset; } else { assert(vf->lookup[map[i].attrib] == 0); vf->lookup[map[i].attrib] = &vf->attr[j]; vf->attr[j].attrib = map[i].attrib; vf->attr[j].format = format; vf->attr[j].insert = vf_format_info[format].insert; vf->attr[j].extract = vf_format_info[format].extract; vf->attr[j].vertattrsize = vf_format_info[format].attrsize; vf->attr[j].vertoffset = offset; if (DBG) _mesa_printf("%d: %s, offset %d\n", i, vf_format_info[format].name, vf->attr[j].vertoffset); offset += vf_format_info[format].attrsize; j++; } } vf->attr_count = j; vf->vertex_stride = vertex_stride ? vertex_stride : offset; vf->emit = choose_emit_func; assert(vf->vertex_stride >= offset); return vf->vertex_stride; }
static void debug_insn( struct prog_instruction *inst, const char *fn, GLuint line ) { if (DISASSEM) { static const char *last_fn; if (fn != last_fn) { last_fn = fn; _mesa_printf("%s:\n", fn); } _mesa_printf("%d:\t", line); _mesa_print_instruction(inst); } }
static GLuint get_surface_type( GLenum type, GLuint size, GLboolean normalized ) { if (INTEL_DEBUG & DEBUG_VERTS) _mesa_printf("type %s size %d normalized %d\n", _mesa_lookup_enum_by_nr(type), size, normalized); if (normalized) { switch (type) { case GL_DOUBLE: return double_types[size]; case GL_FLOAT: return float_types[size]; case GL_INT: return int_types_norm[size]; case GL_SHORT: return short_types_norm[size]; case GL_BYTE: return byte_types_norm[size]; case GL_UNSIGNED_INT: return uint_types_norm[size]; case GL_UNSIGNED_SHORT: return ushort_types_norm[size]; case GL_UNSIGNED_BYTE: return ubyte_types_norm[size]; default: assert(0); return 0; } } else { switch (type) { case GL_DOUBLE: return double_types[size]; case GL_FLOAT: return float_types[size]; case GL_INT: return int_types_scale[size]; case GL_SHORT: return short_types_scale[size]; case GL_BYTE: return byte_types_scale[size]; case GL_UNSIGNED_INT: return uint_types_scale[size]; case GL_UNSIGNED_SHORT: return ushort_types_scale[size]; case GL_UNSIGNED_BYTE: return ubyte_types_scale[size]; default: assert(0); return 0; } } }
void * _mesa_exec_malloc(GLuint size) { struct mem_block *block = NULL; void *addr = NULL; _glthread_LOCK_MUTEX(exec_mutex); if (!init_heap()) goto bail; if (exec_heap) { size = (size + 31) & ~31; block = mmAllocMem( exec_heap, size, 32, 0 ); } if (block) addr = exec_mem + block->ofs; else _mesa_printf("_mesa_exec_malloc failed\n"); bail: _glthread_UNLOCK_MUTEX(exec_mutex); return addr; }
static const struct brw_wm_ref *get_param_ref( struct brw_wm_compile *c, const GLfloat *param_ptr ) { GLuint i = c->prog_data.nr_params++; if (i >= BRW_WM_MAX_PARAM) { _mesa_printf("%s: out of params\n", __FUNCTION__); c->prog_data.error = 1; return NULL; } else { struct brw_wm_ref *ref = get_ref(c); c->prog_data.param[i] = param_ptr; c->nr_creg = (i+16)/16; /* Push the offsets into hw_reg. These will be added to the * real register numbers once one is allocated in pass2. */ ref->hw_reg = brw_vec1_grf((i&8)?1:0, i%8); ref->value = &c->creg[i/16]; ref->insn = 0; ref->prevuse = NULL; return ref; } }
/* When the primitive changes, set a state bit and re-validate. Not * the nicest and would rather deal with this by having all the * programs be immune to the active primitive (ie. cope with all * possibilities). That may not be realistic however. */ static GLuint brw_set_prim(struct brw_context *brw, GLenum prim) { if (INTEL_DEBUG & DEBUG_PRIMS) _mesa_printf("PRIM: %s\n", _mesa_lookup_enum_by_nr(prim)); /* Slight optimization to avoid the GS program when not needed: */ if (prim == GL_QUAD_STRIP && brw->attribs.Light->ShadeModel != GL_FLAT && brw->attribs.Polygon->FrontMode == GL_FILL && brw->attribs.Polygon->BackMode == GL_FILL) prim = GL_TRIANGLE_STRIP; if (prim != brw->primitive) { brw->primitive = prim; brw->state.dirty.brw |= BRW_NEW_PRIMITIVE; if (reduced_prim[prim] != brw->intel.reduced_primitive) { brw->intel.reduced_primitive = reduced_prim[prim]; brw->state.dirty.brw |= BRW_NEW_REDUCED_PRIMITIVE; } brw_validate_state(brw); } return hw_prim[prim]; }
static const struct brw_wm_ref *get_const_ref( struct brw_wm_compile *c, const GLfloat *constval ) { GLuint i; /* Search for an existing const value matching the request: */ for (i = 0; i < c->nr_constrefs; i++) { if (c->constref[i].constval == *constval) return c->constref[i].ref; } /* Else try to add a new one: */ if (c->nr_constrefs < BRW_WM_MAX_CONST) { GLuint i = c->nr_constrefs++; /* A constant is a special type of parameter: */ c->constref[i].constval = *constval; c->constref[i].ref = get_param_ref(c, constval); return c->constref[i].ref; } else { _mesa_printf("%s: out of constrefs\n", __FUNCTION__); c->prog_data.error = 1; return NULL; } }
static void brw_emit_prim( struct brw_context *brw, const struct _mesa_prim *prim ) { struct brw_3d_primitive prim_packet; if (INTEL_DEBUG & DEBUG_PRIMS) _mesa_printf("PRIM: %s %d %d\n", _mesa_lookup_enum_by_nr(prim->mode), prim->start, prim->count); prim_packet.header.opcode = CMD_3D_PRIM; prim_packet.header.length = sizeof(prim_packet)/4 - 2; prim_packet.header.pad = 0; prim_packet.header.topology = brw_set_prim(brw, prim->mode); prim_packet.header.indexed = prim->indexed; prim_packet.verts_per_instance = trim(prim->mode, prim->count); prim_packet.start_vert_location = prim->start; prim_packet.instance_count = 1; prim_packet.start_instance_location = 0; prim_packet.base_vert_location = 0; if (prim_packet.verts_per_instance) { intel_batchbuffer_data( brw->intel.batch, &prim_packet, sizeof(prim_packet), INTEL_BATCH_NO_CLIPRECTS); } }
void _math_test_all_transform_functions( char *description ) { int psize, mtype; unsigned long benchmark_tab[4][7]; static int first_time = 1; if ( first_time ) { first_time = 0; mesa_profile = _mesa_getenv( "MESA_PROFILE" ); } #ifdef RUN_DEBUG_BENCHMARK if ( mesa_profile ) { if ( !counter_overhead ) { INIT_COUNTER(); _mesa_printf("counter overhead: %lu cycles\n\n", counter_overhead ); } _mesa_printf("transform results after hooking in %s functions:\n", description ); } #endif #ifdef RUN_DEBUG_BENCHMARK if ( mesa_profile ) { _mesa_printf("\n" ); for ( psize = 1 ; psize <= 4 ; psize++ ) { _mesa_printf(" p%d\t", psize ); } _mesa_printf("\n--------------------------------------------------------\n" ); } #endif for ( mtype = 0 ; mtype < 7 ; mtype++ ) { for ( psize = 1 ; psize <= 4 ; psize++ ) { transform_func func = _mesa_transform_tab[psize][mtypes[mtype]]; unsigned long *cycles = &(benchmark_tab[psize-1][mtype]); if ( test_transform_function( func, psize, mtype, cycles ) == 0 ) { char buf[100]; _mesa_sprintf(buf, "_mesa_transform_tab[0][%d][%s] failed test (%s)", psize, mstrings[mtype], description ); _mesa_problem( NULL, buf ); } #ifdef RUN_DEBUG_BENCHMARK if ( mesa_profile ) _mesa_printf(" %li\t", benchmark_tab[psize-1][mtype] ); #endif } #ifdef RUN_DEBUG_BENCHMARK if ( mesa_profile ) _mesa_printf(" | [%s]\n", mstrings[mtype] ); #endif } #ifdef RUN_DEBUG_BENCHMARK if ( mesa_profile ) _mesa_printf( "\n" ); #endif }
void vbo_exec_vtx_map( struct vbo_exec_context *exec ) { GLcontext *ctx = exec->ctx; const GLenum target = GL_ARRAY_BUFFER_ARB; const GLenum access = GL_READ_WRITE_ARB; /* for MapBuffer */ const GLenum accessRange = GL_MAP_WRITE_BIT | /* for MapBufferRange */ GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | MESA_MAP_NOWAIT_BIT; const GLenum usage = GL_STREAM_DRAW_ARB; if (exec->vtx.bufferobj->Name == 0) return; if (exec->vtx.buffer_map != NULL) { assert(0); exec->vtx.buffer_map = NULL; exec->vtx.buffer_ptr = NULL; } if (VBO_VERT_BUFFER_SIZE > exec->vtx.buffer_used + 1024 && ctx->Driver.MapBufferRange) { exec->vtx.buffer_map = (GLfloat *)ctx->Driver.MapBufferRange(ctx, target, exec->vtx.buffer_used, (VBO_VERT_BUFFER_SIZE - exec->vtx.buffer_used), accessRange, exec->vtx.bufferobj); exec->vtx.buffer_ptr = exec->vtx.buffer_map; } if (!exec->vtx.buffer_map) { exec->vtx.buffer_used = 0; ctx->Driver.BufferData(ctx, target, VBO_VERT_BUFFER_SIZE, NULL, usage, exec->vtx.bufferobj); if (ctx->Driver.MapBufferRange) exec->vtx.buffer_map = (GLfloat *)ctx->Driver.MapBufferRange(ctx, target, 0, VBO_VERT_BUFFER_SIZE, accessRange, exec->vtx.bufferobj); else exec->vtx.buffer_map = (GLfloat *)ctx->Driver.MapBuffer(ctx, target, access, exec->vtx.bufferobj); exec->vtx.buffer_ptr = exec->vtx.buffer_map; } if (0) _mesa_printf("map %d..\n", exec->vtx.buffer_used); }
void vbo_exec_BeginVertices( GLcontext *ctx ) { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; if (0) _mesa_printf("%s\n", __FUNCTION__); vbo_exec_vtx_map( exec ); assert((exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) == 0); exec->ctx->Driver.NeedFlush |= FLUSH_UPDATE_CURRENT; }
/** * Emit all ready texture instructions in a single block. * * Emit as a single block to (hopefully) sample many textures in parallel, * and to avoid hardware indirections on R300. * * In R500, we don't really know when the result of a texture instruction * arrives. So allocate all destinations first, to make sure they do not * arrive early and overwrite a texture coordinate we're going to use later * in the block. */ static void emit_all_tex(struct pair_state *s) { struct pair_state_instruction *readytex; struct pair_state_instruction *pairinst; ASSERT(s->ReadyTEX); // Don't let the ready list change under us! readytex = s->ReadyTEX; s->ReadyTEX = 0; // Allocate destination hardware registers in one block to avoid conflicts. for(pairinst = readytex; pairinst; pairinst = pairinst->NextReady) { int ip = pairinst - s->Instructions; struct prog_instruction *inst = s->Program->Instructions + ip; if (inst->Opcode != OPCODE_KIL) get_hw_reg(s, inst->DstReg.File, inst->DstReg.Index); } if (s->Debug) _mesa_printf(" BEGIN_TEX\n"); if (s->Handler->BeginTexBlock) s->Error = s->Error || !s->Handler->BeginTexBlock(s->UserData); for(pairinst = readytex; pairinst; pairinst = pairinst->NextReady) { int ip = pairinst - s->Instructions; struct prog_instruction *inst = s->Program->Instructions + ip; commit_instruction(s, ip); if (inst->Opcode != OPCODE_KIL) inst->DstReg.Index = get_hw_reg(s, inst->DstReg.File, inst->DstReg.Index); inst->SrcReg[0].Index = get_hw_reg(s, inst->SrcReg[0].File, inst->SrcReg[0].Index); if (s->Debug) { _mesa_printf(" "); _mesa_print_instruction(inst); } s->Error = s->Error || !s->Handler->EmitTex(s->UserData, inst); } if (s->Debug) _mesa_printf(" END_TEX\n"); }
static void PrintSrcReg(const struct vp_src_register *src) { static const char comps[5] = "xyzw"; if (src->Negate) _mesa_printf("-"); if (src->RelAddr) { if (src->Index > 0) _mesa_printf("c[A0.x + %d]", src->Index); else if (src->Index < 0) _mesa_printf("c[A0.x - %d]", -src->Index); else _mesa_printf("c[A0.x]"); } else if (src->File == PROGRAM_OUTPUT) { _mesa_printf("o[%s]", OutputRegisters[src->Index]); } else if (src->File == PROGRAM_INPUT) { _mesa_printf("v[%s]", InputRegisters[src->Index]); } else if (src->File == PROGRAM_ENV_PARAM) { _mesa_printf("c[%d]", src->Index); } else { ASSERT(src->File == PROGRAM_TEMPORARY); _mesa_printf("R%d", src->Index); } if (src->Swizzle[0] == src->Swizzle[1] && src->Swizzle[0] == src->Swizzle[2] && src->Swizzle[0] == src->Swizzle[3]) { _mesa_printf(".%c", comps[src->Swizzle[0]]); } else if (src->Swizzle[0] != 0 || src->Swizzle[1] != 1 || src->Swizzle[2] != 2 || src->Swizzle[3] != 3) { _mesa_printf(".%c%c%c%c", comps[src->Swizzle[0]], comps[src->Swizzle[1]], comps[src->Swizzle[2]], comps[src->Swizzle[3]]); } }
GLboolean radeonPairProgram(GLcontext *ctx, struct gl_program *program, const struct radeon_pair_handler* handler, void *userdata) { struct pair_state s; _mesa_bzero(&s, sizeof(s)); s.Ctx = ctx; s.Program = program; s.Handler = handler; s.UserData = userdata; s.Debug = (RADEON_DEBUG & DEBUG_PIXEL) ? GL_TRUE : GL_FALSE; s.Verbose = GL_FALSE && s.Debug; s.Instructions = (struct pair_state_instruction*)_mesa_calloc( sizeof(struct pair_state_instruction)*s.Program->NumInstructions); s.ValuePool = (struct reg_value*)_mesa_calloc(sizeof(struct reg_value)*s.Program->NumInstructions*4); s.ReaderPool = (struct reg_value_reader*)_mesa_calloc( sizeof(struct reg_value_reader)*s.Program->NumInstructions*12); if (s.Debug) _mesa_printf("Emit paired program\n"); scan_instructions(&s); allocate_input_registers(&s); while(!s.Error && (s.ReadyTEX || s.ReadyRGB || s.ReadyAlpha || s.ReadyFullALU)) { if (s.ReadyTEX) emit_all_tex(&s); while(s.ReadyFullALU || s.ReadyRGB || s.ReadyAlpha) emit_alu(&s); } if (s.Debug) _mesa_printf(" END\n"); _mesa_free(s.Instructions); _mesa_free(s.ValuePool); _mesa_free(s.ReaderPool); return !s.Error; }
static void * timed_memcpy(void *dest, const void *src, size_t n) { void *ret; unsigned t1, t2; double rate; if ((((unsigned) src) & 63) || (((unsigned) dest) & 63)) _mesa_printf("Warning - non-aligned texture copy!\n"); t1 = fastrdtsc(); ret = do_memcpy(dest, src, n); t2 = fastrdtsc(); rate = time_diff(t1, t2); rate /= (double) n; _mesa_printf("timed_memcpy: %u %u --> %f clocks/byte\n", t1, t2, rate); return ret; }
void _tnl_UpdateFixedFunctionProgram( GLcontext *ctx ) { TNLcontext *tnl = TNL_CONTEXT(ctx); struct state_key *key; GLuint hash; const struct gl_vertex_program *prev = ctx->VertexProgram._Current; if (!ctx->VertexProgram._Current || ctx->VertexProgram._Current == ctx->VertexProgram._TnlProgram) { struct gl_vertex_program *newProg; /* Grab all the relevent state and put it in a single structure: */ key = make_state_key(ctx); hash = hash_key(key); /* Look for an already-prepared program for this state: */ newProg = search_cache( tnl->vp_cache, hash, key, sizeof(*key)); /* OK, we'll have to build a new one: */ if (!newProg) { if (0) _mesa_printf("Build new TNL program\n"); newProg = (struct gl_vertex_program *) ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0); create_new_program( key, newProg, ctx->Const.VertexProgram.MaxTemps ); if (ctx->Driver.ProgramStringNotify) ctx->Driver.ProgramStringNotify( ctx, GL_VERTEX_PROGRAM_ARB, &newProg->Base ); /* Our ownership of newProg is transferred to the cache */ cache_item(ctx, tnl->vp_cache, hash, key, newProg); } else { FREE(key); } _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, newProg); _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, newProg); } /* Tell the driver about the change. Could define a new target for * this? */ if (ctx->VertexProgram._Current != prev && ctx->Driver.BindProgram) { ctx->Driver.BindProgram(ctx, GL_VERTEX_PROGRAM_ARB, (struct gl_program *) ctx->VertexProgram._Current); } }
/* XXX: Do this for TexSubImage also: */ static GLboolean try_pbo_upload(struct intel_context *intel, struct intel_texture_image *intelImage, const struct gl_pixelstore_attrib *unpack, GLint internalFormat, GLint width, GLint height, GLenum format, GLenum type, const void *pixels) { struct intel_buffer_object *pbo = intel_buffer_object(unpack->BufferObj); GLuint src_offset, src_stride; GLuint dst_offset, dst_stride; if (!pbo || intel->ctx._ImageTransferState || unpack->SkipPixels || unpack->SkipRows) { _mesa_printf("%s: failure 1\n", __FUNCTION__); return GL_FALSE; } src_offset = (GLuint) pixels; if (unpack->RowLength > 0) src_stride = unpack->RowLength; else src_stride = width; dst_offset = intel_miptree_image_offset(intelImage->mt, intelImage->face, intelImage->level); dst_stride = intelImage->mt->pitch; intelFlush(&intel->ctx); LOCK_HARDWARE(intel); { struct _DriBufferObject *src_buffer = intel_bufferobj_buffer(intel, pbo, INTEL_READ); struct _DriBufferObject *dst_buffer = intel_region_buffer(intel->intelScreen, intelImage->mt->region, INTEL_WRITE_FULL); intelEmitCopyBlit(intel, intelImage->mt->cpp, src_stride, src_buffer, src_offset, dst_stride, dst_buffer, dst_offset, 0, 0, 0, 0, width, height, GL_COPY); intel_batchbuffer_flush(intel->batch); } UNLOCK_HARDWARE(intel); return GL_TRUE; }
/** * Execute the buffer and save copied verts. */ void vbo_save_playback_vertex_list( GLcontext *ctx, void *data ) { const struct vbo_save_vertex_list *node = (const struct vbo_save_vertex_list *) data; struct vbo_save_context *save = &vbo_context(ctx)->save; FLUSH_CURRENT(ctx, 0); if (node->prim_count > 0 && node->count > 0) { if (ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END && node->prim[0].begin) { /* Degenerate case: list is called inside begin/end pair and * includes operations such as glBegin or glDrawArrays. */ if (0) _mesa_printf("displaylist recursive begin"); vbo_save_loopback_vertex_list( ctx, node ); return; } else if (save->replay_flags) { /* Various degnerate cases: translate into immediate mode * calls rather than trying to execute in place. */ vbo_save_loopback_vertex_list( ctx, node ); return; } if (ctx->NewState) _mesa_update_state( ctx ); /* XXX also need to check if shader enabled, but invalid */ if ((ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) || (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled)) { _mesa_error(ctx, GL_INVALID_OPERATION, "glBegin (invalid vertex/fragment program)"); return; } vbo_bind_vertex_list( ctx, node ); vbo_context(ctx)->draw_prims( ctx, save->inputs, node->prim, node->prim_count, NULL, 0, /* Node is a VBO, so this is ok */ node->count - 1); } /* Copy to current? */ _playback_copy_to_current( ctx, node ); }
static void print_insns( const struct prog_instruction *insn, GLuint nr ) { GLuint i; for (i = 0; i < nr; i++, insn++) { _mesa_printf("%3d: ", i); if (insn->Opcode < MAX_OPCODE) _mesa_print_instruction(insn); else if (insn->Opcode < MAX_WM_OPCODE) { GLuint idx = insn->Opcode - MAX_OPCODE; _mesa_print_alu_instruction(insn, wm_opcode_strings[idx], 3); } else _mesa_printf("UNKNOWN\n"); } }
static void PrintSrcReg(const struct prog_src_register *src) { static const char comps[5] = "xyzw"; if (src->NegateBase) _mesa_printf("-"); if (src->RelAddr) { if (src->Index > 0) _mesa_printf("c[A0.x + %d]", src->Index); else if (src->Index < 0) _mesa_printf("c[A0.x - %d]", -src->Index); else _mesa_printf("c[A0.x]"); } else if (src->File == PROGRAM_OUTPUT) { _mesa_printf("o[%s]", OutputRegisters[src->Index]); } else if (src->File == PROGRAM_INPUT) { _mesa_printf("v[%s]", InputRegisters[src->Index]); } else if (src->File == PROGRAM_ENV_PARAM) { _mesa_printf("c[%d]", src->Index); } else { ASSERT(src->File == PROGRAM_TEMPORARY); _mesa_printf("R%d", src->Index); } if (GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 1) && GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 2) && GET_SWZ(src->Swizzle, 0) == GET_SWZ(src->Swizzle, 3)) { _mesa_printf(".%c", comps[GET_SWZ(src->Swizzle, 0)]); } else if (src->Swizzle != SWIZZLE_NOOP) { _mesa_printf(".%c%c%c%c", comps[GET_SWZ(src->Swizzle, 0)], comps[GET_SWZ(src->Swizzle, 1)], comps[GET_SWZ(src->Swizzle, 2)], comps[GET_SWZ(src->Swizzle, 3)]); } }
static GLboolean try_pbo_zcopy(struct intel_context *intel, struct intel_texture_image *intelImage, const struct gl_pixelstore_attrib *unpack, GLint internalFormat, GLint width, GLint height, GLenum format, GLenum type, const void *pixels) { struct intel_buffer_object *pbo = intel_buffer_object(unpack->BufferObj); GLuint src_offset, src_stride; GLuint dst_offset, dst_stride; if (!pbo || intel->ctx._ImageTransferState || unpack->SkipPixels || unpack->SkipRows) { _mesa_printf("%s: failure 1\n", __FUNCTION__); return GL_FALSE; } src_offset = (GLuint) pixels; if (unpack->RowLength > 0) src_stride = unpack->RowLength; else src_stride = width; dst_offset = intel_miptree_image_offset(intelImage->mt, intelImage->face, intelImage->level); dst_stride = intelImage->mt->pitch; if (src_stride != dst_stride || dst_offset != 0 || src_offset != 0) { _mesa_printf("%s: failure 2\n", __FUNCTION__); return GL_FALSE; } intel_region_attach_pbo(intel->intelScreen, intelImage->mt->region, pbo); return GL_TRUE; }
static struct prog_dst_register get_temp( struct brw_wm_compile *c ) { int bit = ffs( ~c->fp_temp ); if (!bit) { _mesa_printf("%s: out of temporaries\n", __FILE__); exit(1); } c->fp_temp |= 1<<(bit-1); return dst_reg(PROGRAM_TEMPORARY, FIRST_INTERNAL_TEMP+(bit-1)); }
/* Extract a rectangle's worth of data from the bitmap. Called * per-cliprect. */ static GLuint get_bitmap_rect(GLsizei width, GLsizei height, const struct gl_pixelstore_attrib *unpack, const GLubyte *bitmap, GLuint x, GLuint y, GLuint w, GLuint h, GLubyte *dest, GLuint row_align, GLboolean invert) { GLuint src_offset = (x + unpack->SkipPixels) & 0x7; GLuint mask = unpack->LsbFirst ? 0 : 7; GLuint bit = 0; GLint row, col; GLint first, last; GLint incr; GLuint count = 0; if (INTEL_DEBUG & DEBUG_PIXEL) _mesa_printf("%s %d,%d %dx%d bitmap %dx%d skip %d src_offset %d mask %d\n", __FUNCTION__, x,y,w,h,width,height,unpack->SkipPixels, src_offset, mask); if (invert) { first = h-1; last = 0; incr = -1; } else { first = 0; last = h-1; incr = 1; } /* Require that dest be pre-zero'd. */ for (row = first; row != (last+incr); row += incr) { const GLubyte *rowsrc = _mesa_image_address2d(unpack, bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, y + row, x); for (col = 0; col < w; col++, bit++) { if (test_bit(rowsrc, (col + src_offset) ^ mask)) { set_bit(dest, bit ^ 7); count++; } } if (row_align) bit = ALIGN(bit, row_align); } return count; }
void vbo_exec_FlushVertices( GLcontext *ctx, GLuint flags ) { struct vbo_exec_context *exec = &vbo_context(ctx)->exec; if (0) _mesa_printf("%s\n", __FUNCTION__); if (exec->ctx->Driver.CurrentExecPrimitive != PRIM_OUTSIDE_BEGIN_END) { if (0) _mesa_printf("%s - inside begin/end\n", __FUNCTION__); return; } vbo_exec_FlushVertices_internal( ctx, GL_TRUE ); /* Need to do this to ensure BeginVertices gets called again: */ if (exec->ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) { _mesa_restore_exec_vtxfmt( ctx ); exec->ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT; } exec->ctx->Driver.NeedFlush &= ~flags; }
int main(int argc, char *argv[]) { int a, b, c; struct HashTable *t; _mesa_printf("&a = %p\n", &a); _mesa_printf("&b = %p\n", &b); t = _mesa_NewHashTable(); _mesa_HashInsert(t, 501, &a); _mesa_HashInsert(t, 10, &c); _mesa_HashInsert(t, 0xfffffff8, &b); _mesa_HashPrint(t); _mesa_printf("Find 501: %p\n", _mesa_HashLookup(t,501)); _mesa_printf("Find 1313: %p\n", _mesa_HashLookup(t,1313)); _mesa_printf("Find block of 100: %d\n", _mesa_HashFindFreeKeyBlock(t, 100)); _mesa_DeleteHashTable(t); return 0; }