int main(int argc,char *argv[]){
char *basename;
codebook **b=_ogg_calloc(1,sizeof(codebook *));
int *addmul=_ogg_calloc(1,sizeof(int));
int books=0;
int input=0;
int interleave=0;
int j;
int start=0;
int num=-1;
argv++;
if(*argv==NULL){
process_usage();
exit(1);
}
/* yes, this is evil. However, it's very convenient to parse file
extentions */
while(*argv){
if(*argv[0]=='-'){
/* option */
if(argv[0][1]=='s'){
/* subvector */
if(sscanf(argv[1],"%d,%d",&start,&num)!=2){
num= -1;
if(sscanf(argv[1],"%d",&start)!=1){
fprintf(stderr,"Syntax error using -s\n");
exit(1);
}
}
argv+=2;
}
if(argv[0][1]=='i'){
/* interleave */
interleave=1;
argv+=1;
}
}else{
/* input file. What kind? */
char *dot;
char *ext=NULL;
char *name=strdup(*argv++);
dot=strrchr(name,'.');
if(dot)
ext=dot+1;
else
ext="";
/* codebook */
if(!strcmp(ext,"vqh")){
int multp=0;
if(input){
fprintf(stderr,"specify all input data (.vqd) files following\n"
"codebook header (.vqh) files\n");
exit(1);
}
/* is it additive or multiplicative? */
if(name[0]=='*'){
multp=1;
name++;
}
if(name[0]=='+')name++;
basename=strrchr(name,'/');
if(basename)
basename=strdup(basename)+1;
else
basename=strdup(name);
dot=strrchr(basename,'.');
if(dot)*dot='\0';
b=_ogg_realloc(b,sizeof(codebook *)*(books+2));
b[books]=codebook_load(name);
addmul=_ogg_realloc(addmul,sizeof(int)*(books+1));
addmul[books++]=multp;
b[books]=NULL;
}
/* data file */
if(!strcmp(ext,"vqd")){
int cols;
long lines=0;
char *line;
float *vec;
FILE *in=fopen(name,"r");
if(!in){
fprintf(stderr,"Could not open input file %s\n",name);
exit(1);
}
if(!input){
process_preprocess(b,basename);
input++;
}
reset_next_value();
line=setup_line(in);
/* count cols before we start reading */
{
char *temp=line;
while(*temp==' ')temp++;
for(cols=0;*temp;cols++){
while(*temp>32)temp++;
while(*temp==' ')temp++;
}
}
vec=alloca(cols*sizeof(float));
while(line){
lines++;
for(j=0;j<cols;j++)
if(get_line_value(in,vec+j)){
fprintf(stderr,"Too few columns on line %ld in data file\n",lines);
exit(1);
}
/* ignores -s for now */
process_vector(b,addmul,interleave,vec,cols);
line=setup_line(in);
}
fclose(in);
}
}
}
/* take any data from stdin */
{
struct stat st;
if(fstat(STDIN_FILENO,&st)==-1){
fprintf(stderr,"Could not stat STDIN\n");
exit(1);
}
if((S_IFIFO|S_IFREG|S_IFSOCK)&st.st_mode){
int cols;
char *line;
long lines=0;
float *vec;
if(!input){
process_preprocess(b,basename);
input++;
}
line=setup_line(stdin);
/* count cols before we start reading */
{
char *temp=line;
while(*temp==' ')temp++;
for(cols=0;*temp;cols++){
while(*temp>32)temp++;
while(*temp==' ')temp++;
}
}
vec=alloca(cols*sizeof(float));
while(line){
lines++;
for(j=0;j<cols;j++)
if(get_line_value(stdin,vec+j)){
fprintf(stderr,"Too few columns on line %ld in data file\n",lines);
exit(1);
}
/* ignores -s for now */
process_vector(b,addmul,interleave,vec,cols);
line=setup_line(stdin);
}
}
}
process_postprocess(b,basename);
return 0;
}
int main(int argc,char *argv[]){
codebook *b;
static_codebook *c;
long *lengths;
long *hits;
int entries=-1,dim=-1,guard=1;
FILE *in=NULL;
char *line,*name;
long j;
if(argv[1]==NULL){
fprintf(stderr,"Need a lattice codebook on the command line.\n");
exit(1);
}
if(argv[2]==NULL){
fprintf(stderr,"Need a codeword data file on the command line.\n");
exit(1);
}
if(argv[3]!=NULL)guard=0;
{
char *ptr;
char *filename=strdup(argv[1]);
b=codebook_load(filename);
c=(static_codebook *)(b->c);
ptr=strrchr(filename,'.');
if(ptr){
*ptr='\0';
name=strdup(filename);
}else{
name=strdup(filename);
}
}
if(c->maptype!=1){
fprintf(stderr,"Provided book is not a latticebook.\n");
exit(1);
}
entries=b->entries;
dim=b->dim;
hits=_ogg_malloc(entries*sizeof(long));
lengths=_ogg_calloc(entries,sizeof(long));
for(j=0;j<entries;j++)hits[j]=guard;
in=fopen(argv[2],"r");
if(!in){
fprintf(stderr,"Could not open input file %s\n",argv[2]);
exit(1);
}
if(!strrcmp_i(argv[0],"latticetune")){
long lines=0;
line=setup_line(in);
while(line){
long code;
lines++;
if(!(lines&0xfff))spinnit("codewords so far...",lines);
if(sscanf(line,"%ld",&code)==1)
hits[code]++;
line=setup_line(in);
}
}
/* now we simply count already collated by-entry data */
if(!strrcmp_i(argv[0],"res0tune") || !strrcmp_i(argv[0],"res1tune")){
line=setup_line(in);
while(line){
/* code:hits\n */
/* likely to have multiple listing for each code entry; must
accumulate */
char *pos=strchr(line,':');
if(pos){
long code=atol(line);
long val=atol(pos+1);
hits[code]+=val;
}
line=setup_line(in);
}
}
fclose(in);
/* build the codeword lengths */
build_tree_from_lengths0(entries,hits,lengths);
c->lengthlist=lengths;
write_codebook(stdout,name,c);
{
long bins=_book_maptype1_quantvals(c);
long i,k,base=c->lengthlist[0];
for(i=0;i<entries;i++)
if(c->lengthlist[i]>base)base=c->lengthlist[i];
for(j=0;j<entries;j++){
if(c->lengthlist[j]){
int indexdiv=1;
fprintf(stderr,"%4ld: ",j);
for(k=0;k<c->dim;k++){
int index= (j/indexdiv)%bins;
fprintf(stderr,"%+3.1f,", c->quantlist[index]*_float32_unpack(c->q_delta)+
_float32_unpack(c->q_min));
indexdiv*=bins;
}
fprintf(stderr,"\t|");
for(k=0;k<base-c->lengthlist[j];k++)fprintf(stderr,"*");
fprintf(stderr,"\n");
}
}
}
fprintf(stderr,"\r "
"\nDone.\n");
exit(0);
}
int main(int argc,char *argv[]){
FILE *in;
long lines=0;
float min;
float max;
long bins=-1;
int flag=0;
long *countarray;
long total=0;
char *line;
if(argv[1]==NULL){
fprintf(stderr,"Usage: distribution {data.vqd [bins]| book.vqh} \n\n");
exit(1);
}
if(argv[2]!=NULL)
bins=atoi(argv[2])-1;
in=fopen(argv[1],"r");
if(!in){
fprintf(stderr,"Could not open input file %s\n",argv[1]);
exit(1);
}
if(strrchr(argv[1],'.') && strcmp(strrchr(argv[1],'.'),".vqh")==0){
/* load/decode a book */
codebook *b=codebook_load(argv[1]);
static_codebook *c=(static_codebook *)(b->c);
float delta;
int i;
fclose(in);
switch(c->maptype){
case 0:
printf("entropy codebook only; no mappings\n");
exit(0);
break;
case 1:
bins=_book_maptype1_quantvals(c);
break;
case 2:
bins=c->entries*c->dim;
break;
}
max=min=_float32_unpack(c->q_min);
delta=_float32_unpack(c->q_delta);
for(i=0;i<bins;i++){
float val=c->quantlist[i]*delta+min;
if(val>max)max=val;
}
printf("Minimum scalar value: %f\n",min);
printf("Maximum scalar value: %f\n",max);
switch(c->maptype){
case 1:
{
/* lattice codebook. dump it. */
int j,k;
long maxcount=0;
long **sort=calloc(bins,sizeof(long *));
long base=c->lengthlist[0];
countarray=calloc(bins,sizeof(long));
for(i=0;i<bins;i++)sort[i]=c->quantlist+i;
qsort(sort,bins,sizeof(long *),ascend);
for(i=0;i<b->entries;i++)
if(c->lengthlist[i]>base)base=c->lengthlist[i];
/* dump a full, correlated count */
for(j=0;j<b->entries;j++){
if(c->lengthlist[j]){
int indexdiv=1;
printf("%4d: ",j);
for(k=0;k<b->dim;k++){
int index= (j/indexdiv)%bins;
printf("%+3.1f,", c->quantlist[index]*_float32_unpack(c->q_delta)+
_float32_unpack(c->q_min));
indexdiv*=bins;
}
printf("\t|");
for(k=0;k<base-c->lengthlist[j];k++)printf("*");
printf("\n");
}
}
/* do a rough count */
for(j=0;j<b->entries;j++){
int indexdiv=1;
for(k=0;k<b->dim;k++){
if(c->lengthlist[j]){
int index= (j/indexdiv)%bins;
countarray[index]+=(1<<(base-c->lengthlist[j]));
indexdiv*=bins;
}
}
}
/* dump the count */
{
long maxcount=0,i,j;
for(i=0;i<bins;i++)
if(countarray[i]>maxcount)maxcount=countarray[i];
for(i=0;i<bins;i++){
int ptr=sort[i]-c->quantlist;
int stars=rint(50./maxcount*countarray[ptr]);
printf("%+08f (%8ld) |",c->quantlist[ptr]*delta+min,countarray[ptr]);
for(j=0;j<stars;j++)printf("*");
printf("\n");
}
}
}
break;
case 2:
{
/* trained, full mapping codebook. */
printf("Can't do probability dump of a trained [type 2] codebook (yet)\n");
}
break;
}
}else{
/* load/count a data file */
/* do it the simple way; two pass. */
line=setup_line(in);
while(line){
float code;
char buf[80];
lines++;
sprintf(buf,"getting min/max (%.2f::%.2f). lines...",min,max);
if(!(lines&0xff))spinnit(buf,lines);
while(!flag && sscanf(line,"%f",&code)==1){
line=strchr(line,',');
min=max=code;
flag=1;
}
while(line && sscanf(line,"%f",&code)==1){
line=strchr(line,',');
if(line)line++;
if(code<min)min=code;
if(code>max)max=code;
}
line=setup_line(in);
}
if(bins<1){
if((int)(max-min)==min-max){
bins=max-min;
}else{
bins=25;
}
}
printf("\r \r");
printf("Minimum scalar value: %f\n",min);
printf("Maximum scalar value: %f\n",max);
if(argv[2]){
printf("\n counting hits into %ld bins...\n",bins+1);
countarray=calloc(bins+1,sizeof(long));
rewind(in);
line=setup_line(in);
while(line){
float code;
lines--;
if(!(lines&0xff))spinnit("counting distribution. lines so far...",lines);
while(line && sscanf(line,"%f",&code)==1){
line=strchr(line,',');
if(line)line++;
code-=min;
code/=(max-min);
code*=bins;
countarray[(int)rint(code)]++;
total++;
}
line=setup_line(in);
}
/* make a pretty graph */
{
long maxcount=0,i,j;
for(i=0;i<bins+1;i++)
if(countarray[i]>maxcount)maxcount=countarray[i];
printf("\r \r");
printf("Total scalars: %ld\n",total);
for(i=0;i<bins+1;i++){
int stars=rint(50./maxcount*countarray[i]);
printf("%08f (%8ld) |",(max-min)/bins*i+min,countarray[i]);
for(j=0;j<stars;j++)printf("*");
printf("\n");
}
}
}
fclose(in);
}
printf("\nDone.\n");
exit(0);
}
/**
* This function is hit when the draw module is working in pass-through mode.
* It's up to us to convert the vertex array into point/line/tri prims.
*/
static void
sp_vbuf_draw_arrays(struct vbuf_render *vbr, uint start, uint nr)
{
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
struct softpipe_context *softpipe = cvbr->softpipe;
const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
const void *vertex_buffer =
(void *) get_vert(cvbr->vertex_buffer, start, stride);
unsigned i;
/* XXX: break this dependency - make setup_context live under
* softpipe, rename the old "setup" draw stage to something else.
*/
struct draw_stage *setup = softpipe->setup;
struct setup_context *setup_ctx = sp_draw_setup_context(setup);
switch (cvbr->prim) {
case PIPE_PRIM_POINTS:
for (i = 0; i < nr; i++) {
setup_point( setup_ctx,
get_vert(vertex_buffer, i-0, stride) );
}
break;
case PIPE_PRIM_LINES:
for (i = 1; i < nr; i += 2) {
setup_line( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
break;
case PIPE_PRIM_LINE_STRIP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
break;
case PIPE_PRIM_LINE_LOOP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
if (nr) {
setup_line( setup_ctx,
get_vert(vertex_buffer, nr-1, stride),
get_vert(vertex_buffer, 0, stride) );
}
break;
case PIPE_PRIM_TRIANGLES:
for (i = 2; i < nr; i += 3) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, i-2, stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
}
break;
case PIPE_PRIM_TRIANGLE_STRIP:
for (i = 2; i < nr; i++) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i+(i&1)-1, stride),
get_vert(vertex_buffer, i-(i&1), stride),
get_vert(vertex_buffer, i-2, stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i+(i&1)-2, stride),
get_vert(vertex_buffer, i-(i&1)-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
}
break;
case PIPE_PRIM_TRIANGLE_FAN:
for (i = 2; i < nr; i += 1) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, 0, stride),
get_vert(vertex_buffer, i-1, stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, 0, stride),
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
}
break;
case PIPE_PRIM_QUADS:
for (i = 3; i < nr; i += 4) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-3, stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, i-3, stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-3, stride),
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-0, stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride) );
}
}
break;
case PIPE_PRIM_QUAD_STRIP:
for (i = 3; i < nr; i += 2) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-3, stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, i-3, stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-3, stride),
get_vert(vertex_buffer, i-2, stride),
get_vert(vertex_buffer, i-0, stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-3, stride),
get_vert(vertex_buffer, i-0, stride) );
}
}
break;
case PIPE_PRIM_POLYGON:
/* Almost same as tri fan but the _first_ vertex specifies the flat
* shading color. Note that the first polygon vertex is passed as
* the last triangle vertex here.
* flatshade_first state makes no difference.
*/
for (i = 2; i < nr; i += 1) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, i-1, stride),
get_vert(vertex_buffer, i-0, stride),
get_vert(vertex_buffer, 0, stride) );
}
break;
default:
assert(0);
}
}
int main(int argc,char *argv[]){
codebook b;
static_codebook c;
double *quantlist;
long *hits;
int entries=-1,dim=-1,quantvals=-1,addmul=-1,sequencep=0;
FILE *in=NULL;
char *line,*name;
long i,j;
memset(&b,0,sizeof(b));
memset(&c,0,sizeof(c));
if(argv[1]==NULL){
fprintf(stderr,"Need a lattice description file on the command line.\n");
exit(1);
}
{
char *ptr;
char *filename=_ogg_calloc(strlen(argv[1])+4,1);
strcpy(filename,argv[1]);
in=fopen(filename,"r");
if(!in){
fprintf(stderr,"Could not open input file %s\n",filename);
exit(1);
}
ptr=strrchr(filename,'.');
if(ptr){
*ptr='\0';
name=strdup(filename);
}else{
name=strdup(filename);
}
}
/* read the description */
line=get_line(in);
if(sscanf(line,"%d %d %d %d",&quantvals,&dim,&addmul,&sequencep)!=4){
if(sscanf(line,"%d %d %d",&quantvals,&dim,&addmul)!=3){
fprintf(stderr,"Syntax error reading description file (line 1)\n");
exit(1);
}
}
entries=pow(quantvals,dim);
c.dim=dim;
c.entries=entries;
c.lengthlist=_ogg_malloc(entries*sizeof(long));
c.maptype=1;
c.q_sequencep=sequencep;
c.quantlist=_ogg_calloc(quantvals,sizeof(long));
quantlist=_ogg_malloc(sizeof(double)*c.dim*c.entries);
hits=_ogg_malloc(c.entries*sizeof(long));
for(j=0;j<entries;j++)hits[j]=1;
for(j=0;j<entries;j++)c.lengthlist[j]=1;
reset_next_value();
line=setup_line(in);
for(j=0;j<quantvals;j++){
char *temp;
if(!line || sscanf(line,"%lf",quantlist+j)!=1){
fprintf(stderr,"Ran out of data on line 2 of description file\n");
exit(1);
}
temp=strchr(line,',');
if(!temp)temp=strchr(line,' ');
if(temp)temp++;
line=temp;
}
/* gen a real quant list from the more easily human-grokked input */
{
double min=quantlist[0];
double mindel=-1;
int fac=1;
for(j=1;j<quantvals;j++)if(quantlist[j]<min)min=quantlist[j];
for(j=0;j<quantvals;j++)
for(i=j+1;i<quantvals;i++)
if(mindel==-1 || fabs(quantlist[j]-quantlist[i])<mindel)
mindel=fabs(quantlist[j]-quantlist[i]);
j=0;
while(j<quantvals){
for(j=0;j<quantvals;j++){
double test=fac*(quantlist[j]-min)/mindel;
if( fabs(rint(test)-test)>.00001f) break;
}
if(fac>100)break;
if(j<quantvals)fac++;
}
mindel/=fac;
fprintf(stderr,"min=%g mindel=%g\n",min,mindel);
c.q_min=_float32_pack(min);
c.q_delta=_float32_pack(mindel);
c.q_quant=0;
min=_float32_unpack(c.q_min);
mindel=_float32_unpack(c.q_delta);
for(j=0;j<quantvals;j++){
c.quantlist[j]=rint((quantlist[j]-min)/mindel);
if(ilog(c.quantlist[j])>c.q_quant)c.q_quant=ilog(c.quantlist[j]);
}
}
/* build the [default] codeword lengths */
memset(c.lengthlist,0,sizeof(long)*entries);
for(i=0;i<entries;i++)hits[i]=1;
build_tree_from_lengths(entries,hits,c.lengthlist);
/* save the book in C header form */
write_codebook(stdout,name,&c);
fprintf(stderr,"\r "
"\nDone.\n");
exit(0);
}
/**
* draw elements / indexed primitives
*/
static void
sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
{
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
struct softpipe_context *softpipe = cvbr->softpipe;
const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
const void *vertex_buffer = cvbr->vertex_buffer;
unsigned i;
/* XXX: break this dependency - make setup_context live under
* softpipe, rename the old "setup" draw stage to something else.
*/
struct draw_stage *setup = softpipe->setup;
struct setup_context *setup_ctx = sp_draw_setup_context(setup);
switch (cvbr->prim) {
case PIPE_PRIM_POINTS:
for (i = 0; i < nr; i++) {
setup_point( setup_ctx,
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINES:
for (i = 1; i < nr; i += 2) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINE_STRIP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINE_LOOP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
if (nr) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[nr-1], stride),
get_vert(vertex_buffer, indices[0], stride) );
}
break;
case PIPE_PRIM_TRIANGLES:
for (i = 2; i < nr; i += 3) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[i-2], stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
}
break;
case PIPE_PRIM_TRIANGLE_STRIP:
for (i = 2; i < nr; i += 1) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i+(i&1)-1], stride),
get_vert(vertex_buffer, indices[i-(i&1)], stride),
get_vert(vertex_buffer, indices[i-2], stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
}
break;
case PIPE_PRIM_TRIANGLE_FAN:
for (i = 2; i < nr; i += 1) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[0], stride),
get_vert(vertex_buffer, indices[i-1], stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[0], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
}
break;
case PIPE_PRIM_QUADS:
for (i = 3; i < nr; i += 4) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-3], stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[i-3], stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
}
break;
case PIPE_PRIM_QUAD_STRIP:
for (i = 3; i < nr; i += 2) {
if (softpipe->rasterizer->flatshade_first) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-3], stride));
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[i-3], stride) );
}
else {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
}
break;
case PIPE_PRIM_POLYGON:
/* Almost same as tri fan but the _first_ vertex specifies the flat
* shading color. Note that the first polygon vertex is passed as
* the last triangle vertex here.
* flatshade_first state makes no difference.
*/
for (i = 2; i < nr; i += 1) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[0], stride) );
}
break;
default:
assert(0);
}
/* XXX: why are we calling this??? If we had to call something, it
* would be a function in sp_setup.c:
*/
sp_draw_flush( setup );
}
int main(int argc,char *argv[]){
char *basename;
codebook *b=NULL;
int entries=0;
int dim=0;
long i,j,target=-1,protect=-1;
FILE *out=NULL;
int argnum=0;
argv++;
if(*argv==NULL){
usage();
exit(1);
}
while(*argv){
if(*argv[0]=='-'){
argv++;
}else{
switch (argnum++){
case 0:case 1:
{
/* yes, this is evil. However, it's very convenient to parse file
extentions */
/* input file. What kind? */
char *dot;
char *ext=NULL;
char *name=strdup(*argv++);
dot=strrchr(name,'.');
if(dot)
ext=dot+1;
else{
ext="";
}
/* codebook */
if(!strcmp(ext,"vqh")){
basename=strrchr(name,'/');
if(basename)
basename=strdup(basename)+1;
else
basename=strdup(name);
dot=strrchr(basename,'.');
if(dot)*dot='\0';
b=codebook_load(name);
dim=b->dim;
entries=b->entries;
}
/* data file; we do actually need to suck it into memory */
/* we're dealing with just one book, so we can de-interleave */
if(!strcmp(ext,"vqd") && !points){
int cols;
long lines=0;
char *line;
float *vec;
FILE *in=fopen(name,"r");
if(!in){
fprintf(stderr,"Could not open input file %s\n",name);
exit(1);
}
reset_next_value();
line=setup_line(in);
/* count cols before we start reading */
{
char *temp=line;
while(*temp==' ')temp++;
for(cols=0;*temp;cols++){
while(*temp>32)temp++;
while(*temp==' ')temp++;
}
}
vec=alloca(cols*sizeof(float));
/* count, then load, to avoid fragmenting the hell out of
memory */
while(line){
lines++;
for(j=0;j<cols;j++)
if(get_line_value(in,vec+j)){
fprintf(stderr,"Too few columns on line %ld in data file\n",lines);
exit(1);
}
if((lines&0xff)==0)spinnit("counting samples...",lines*cols);
line=setup_line(in);
}
pointlist=_ogg_malloc((cols*lines+entries*dim)*sizeof(float));
rewind(in);
line=setup_line(in);
while(line){
lines--;
for(j=0;j<cols;j++)
if(get_line_value(in,vec+j)){
fprintf(stderr,"Too few columns on line %ld in data file\n",lines);
exit(1);
}
/* deinterleave, add to heap */
add_vector(b,vec,cols);
if((lines&0xff)==0)spinnit("loading samples...",lines*cols);
line=setup_line(in);
}
fclose(in);
}
}
break;
case 2:
target=atol(*argv++);
if(target==0)target=entries;
break;
case 3:
protect=atol(*argv++);
break;
case 4:
{
char *buff=alloca(strlen(*argv)+5);
sprintf(buff,"%s.vqh",*argv);
basename=*argv++;
out=fopen(buff,"w");
if(!out){
fprintf(stderr,"unable ot open %s for output",buff);
exit(1);
}
}
break;
default:
usage();
}
}
}
if(!entries || !points || !out)usage();
if(target==-1)usage();
/* add guard points */
for(i=0;i<entries;i++)
for(j=0;j<dim;j++)
pointlist[points++]=b->valuelist[i*dim+j];
points/=dim;
/* set up auxiliary vectors for error tracking */
{
encode_aux_nearestmatch *nt=NULL;
long pointssofar=0;
long *pointindex;
long indexedpoints=0;
long *entryindex;
long *reventry;
long *membership=_ogg_malloc(points*sizeof(long));
long *firsthead=_ogg_malloc(entries*sizeof(long));
long *secondary=_ogg_malloc(points*sizeof(long));
long *secondhead=_ogg_malloc(entries*sizeof(long));
long *cellcount=_ogg_calloc(entries,sizeof(long));
long *cellcount2=_ogg_calloc(entries,sizeof(long));
float *cellerror=_ogg_calloc(entries,sizeof(float));
float *cellerrormax=_ogg_calloc(entries,sizeof(float));
long cellsleft=entries;
for(i=0;i<points;i++)membership[i]=-1;
for(i=0;i<entries;i++)firsthead[i]=-1;
for(i=0;i<points;i++)secondary[i]=-1;
for(i=0;i<entries;i++)secondhead[i]=-1;
for(i=0;i<points;i++){
/* assign vectors to the nearest cell. Also keep track of second
nearest for error statistics */
float *ppt=pointlist+i*dim;
int firstentry=closest(b,ppt,-1);
int secondentry=closest(b,ppt,firstentry);
float firstmetric=_dist(dim,b->valuelist+dim*firstentry,ppt);
float secondmetric=_dist(dim,b->valuelist+dim*secondentry,ppt);
if(!(i&0xff))spinnit("initializing... ",points-i);
membership[i]=firsthead[firstentry];
firsthead[firstentry]=i;
secondary[i]=secondhead[secondentry];
secondhead[secondentry]=i;
if(i<points-entries){
cellerror[firstentry]+=secondmetric-firstmetric;
cellerrormax[firstentry]=max(cellerrormax[firstentry],
_heuristic(b,ppt,secondentry));
cellcount[firstentry]++;
cellcount2[secondentry]++;
}
}
/* which cells are most heavily populated? Protect as many from
dispersal as the user has requested */
{
long **countindex=_ogg_calloc(entries,sizeof(long *));
for(i=0;i<entries;i++)countindex[i]=cellcount+i;
qsort(countindex,entries,sizeof(long *),longsort);
for(i=0;i<protect;i++){
int ptr=countindex[i]-cellcount;
cellerrormax[ptr]=9e50f;
}
}
{
fprintf(stderr,"\r");
for(i=0;i<entries;i++){
/* decompose index */
int entry=i;
for(j=0;j<dim;j++){
fprintf(stderr,"%d:",entry%b->c->thresh_tree->quantvals);
entry/=b->c->thresh_tree->quantvals;
}
fprintf(stderr,":%ld/%ld, ",cellcount[i],cellcount2[i]);
}
fprintf(stderr,"\n");
}
/* do the automatic cull request */
while(cellsleft>target){
int bestcell=-1;
float besterror=0;
float besterror2=0;
long head=-1;
char spinbuf[80];
sprintf(spinbuf,"cells left to eliminate: %ld : ",cellsleft-target);
/* find the cell with lowest removal impact */
for(i=0;i<entries;i++){
if(b->c->lengthlist[i]>0){
if(bestcell==-1 || cellerrormax[i]<=besterror2){
if(bestcell==-1 || cellerrormax[i]<besterror2 ||
besterror>cellerror[i]){
besterror=cellerror[i];
besterror2=cellerrormax[i];
bestcell=i;
}
}
}
}
fprintf(stderr,"\reliminating cell %d \n"
" dispersal error of %g max/%g total (%ld hits)\n",
bestcell,besterror2,besterror,cellcount[bestcell]);
/* disperse it. move each point out, adding it (properly) to
the second best */
b->c->lengthlist[bestcell]=0;
head=firsthead[bestcell];
firsthead[bestcell]=-1;
while(head!=-1){
/* head is a point number */
float *ppt=pointlist+head*dim;
int firstentry=closest(b,ppt,-1);
int secondentry=closest(b,ppt,firstentry);
float firstmetric=_dist(dim,b->valuelist+dim*firstentry,ppt);
float secondmetric=_dist(dim,b->valuelist+dim*secondentry,ppt);
long next=membership[head];
if(head<points-entries){
cellcount[firstentry]++;
cellcount[bestcell]--;
cellerror[firstentry]+=secondmetric-firstmetric;
cellerrormax[firstentry]=max(cellerrormax[firstentry],
_heuristic(b,ppt,secondentry));
}
membership[head]=firsthead[firstentry];
firsthead[firstentry]=head;
head=next;
if(cellcount[bestcell]%128==0)
spinnit(spinbuf,cellcount[bestcell]+cellcount2[bestcell]);
}
/* now see that all points that had the dispersed cell as second
choice have second choice reassigned */
head=secondhead[bestcell];
secondhead[bestcell]=-1;
while(head!=-1){
float *ppt=pointlist+head*dim;
/* who are we assigned to now? */
int firstentry=closest(b,ppt,-1);
/* what is the new second closest match? */
int secondentry=closest(b,ppt,firstentry);
/* old second closest is the cell being disbanded */
float oldsecondmetric=_dist(dim,b->valuelist+dim*bestcell,ppt);
/* new second closest error */
float secondmetric=_dist(dim,b->valuelist+dim*secondentry,ppt);
long next=secondary[head];
if(head<points-entries){
cellcount2[secondentry]++;
cellcount2[bestcell]--;
cellerror[firstentry]+=secondmetric-oldsecondmetric;
cellerrormax[firstentry]=max(cellerrormax[firstentry],
_heuristic(b,ppt,secondentry));
}
secondary[head]=secondhead[secondentry];
secondhead[secondentry]=head;
head=next;
if(cellcount2[bestcell]%128==0)
spinnit(spinbuf,cellcount2[bestcell]);
}
cellsleft--;
}
/* paring is over. Build decision trees using points that now fall
through the thresh matcher. */
/* we don't free membership; we flatten it in order to use in lp_split */
for(i=0;i<entries;i++){
long head=firsthead[i];
spinnit("rearranging membership cache... ",entries-i);
while(head!=-1){
long next=membership[head];
membership[head]=i;
head=next;
}
}
free(secondhead);
free(firsthead);
free(cellerror);
free(cellerrormax);
free(secondary);
pointindex=_ogg_malloc(points*sizeof(long));
/* make a point index of fall-through points */
for(i=0;i<points;i++){
int best=_best(b,pointlist+i*dim,1);
if(best==-1)
pointindex[indexedpoints++]=i;
spinnit("finding orphaned points... ",points-i);
}
/* make an entry index */
entryindex=_ogg_malloc(entries*sizeof(long));
target=0;
for(i=0;i<entries;i++){
if(b->c->lengthlist[i]>0)
entryindex[target++]=i;
}
/* make working space for a reverse entry index */
reventry=_ogg_malloc(entries*sizeof(long));
/* do the split */
nt=b->c->nearest_tree=
_ogg_calloc(1,sizeof(encode_aux_nearestmatch));
nt->alloc=4096;
nt->ptr0=_ogg_malloc(sizeof(long)*nt->alloc);
nt->ptr1=_ogg_malloc(sizeof(long)*nt->alloc);
nt->p=_ogg_malloc(sizeof(long)*nt->alloc);
nt->q=_ogg_malloc(sizeof(long)*nt->alloc);
nt->aux=0;
fprintf(stderr,"Leaves added: %d \n",
lp_split(pointlist,points,
b,entryindex,target,
pointindex,indexedpoints,
membership,reventry,
0,&pointssofar));
free(membership);
free(reventry);
free(pointindex);
/* hack alert. I should just change the damned splitter and
codebook writer */
for(i=0;i<nt->aux;i++)nt->p[i]*=dim;
for(i=0;i<nt->aux;i++)nt->q[i]*=dim;
/* recount hits. Build new lengthlist. reuse entryindex storage */
for(i=0;i<entries;i++)entryindex[i]=1;
for(i=0;i<points-entries;i++){
int best=_best(b,pointlist+i*dim,1);
float *a=pointlist+i*dim;
if(!(i&0xff))spinnit("counting hits...",i);
if(best==-1){
fprintf(stderr,"\nINTERNAL ERROR; a point count not be matched to a\n"
"codebook entry. The new decision tree is broken.\n");
exit(1);
}
entryindex[best]++;
}
for(i=0;i<nt->aux;i++)nt->p[i]/=dim;
for(i=0;i<nt->aux;i++)nt->q[i]/=dim;
/* the lengthlist builder doesn't actually deal with 0 hit entries.
So, we pack the 'sparse' hit list into a dense list, then unpack
the lengths after the build */
{
int upper=0;
long *lengthlist=_ogg_calloc(entries,sizeof(long));
for(i=0;i<entries;i++){
if(b->c->lengthlist[i]>0)
entryindex[upper++]=entryindex[i];
else{
if(entryindex[i]>1){
fprintf(stderr,"\nINTERNAL ERROR; _best matched to unused entry\n");
exit(1);
}
}
}
/* sanity check */
if(upper != target){
fprintf(stderr,"\nINTERNAL ERROR; packed the wrong number of entries\n");
exit(1);
}
build_tree_from_lengths(upper,entryindex,lengthlist);
upper=0;
for(i=0;i<entries;i++){
if(b->c->lengthlist[i]>0)
b->c->lengthlist[i]=lengthlist[upper++];
}
}
}
/* we're done. write it out. */
write_codebook(out,basename,b->c);
fprintf(stderr,"\r \nDone.\n");
return(0);
}
/* sighup_handler() is invoked when carrier drops, eg. before redial. */
static void
sighup_handler(int signo __unused)
{
if(exiting) return;
if (redial_cmd == NULL) {
syslog(LOG_NOTICE,"SIGHUP on %s (sl%d); exiting", dev, unit);
exit_handler(1);
}
again:
/* invoke a shell for redial_cmd or punt. */
if (*redial_cmd) { /* Non-empty redial command */
syslog(LOG_NOTICE,"SIGHUP on %s (sl%d); running '%s'",
dev, unit, redial_cmd);
acquire_line(); /* reopen dead line */
setup_line(CLOCAL);
if (locked) {
if (uucp_lock)
uu_unlock(dvname); /* for redial */
locked = 0;
}
if (system(redial_cmd))
goto again;
if (uucp_lock) {
int res;
if ((res = uu_lock(dvname)) != UU_LOCK_OK) {
if (res != UU_LOCK_INUSE)
syslog(LOG_ERR, "uu_lock: %s", uu_lockerr(res));
syslog(LOG_ERR, "can't relock %s after %s, aborting",
dev, redial_cmd);
exit_handler(1);
}
locked = 1;
}
/* Now check again for carrier (dial command is done): */
if (!(modem_control & CLOCAL)) {
tty.c_cflag &= ~CLOCAL;
if (tcsetattr(fd, TCSAFLUSH, &tty) < 0) {
syslog(LOG_ERR, "tcsetattr(TCSAFLUSH): %m");
exit_handler(1);
}
ioctl(fd, TIOCMGET, &comstate);
if (!(comstate & TIOCM_CD)) { /* check for carrier */
/* force a redial if no carrier */
goto again;
}
} else
setup_line(0);
} else { /* Empty redial command */
syslog(LOG_NOTICE,"SIGHUP on %s (sl%d); reestablish connection",
dev, unit);
acquire_line(); /* reopen dead line */
setup_line(0); /* restore ospeed from hangup (B0) */
/* If modem control, just wait for carrier before attaching.
If no modem control, just fall through immediately. */
if (!(modem_control & CLOCAL)) {
int carrier = 0;
syslog(LOG_NOTICE, "waiting for carrier on %s (sl%d)",
dev, unit);
/* Now wait for carrier before attaching line. */
/* We must poll since CLOCAL prevents signal. */
while (! carrier) {
sleep(2);
ioctl(fd, TIOCMGET, &comstate);
if (comstate & TIOCM_CD)
carrier = 1;
}
syslog(LOG_NOTICE, "carrier now present on %s (sl%d)",
dev, unit);
}
}
slip_discipline();
configure_network();
}
int
main(int argc, char **argv)
{
int option;
while ((option = getopt(argc, argv, "ace:fhlnr:s:u:zLK:O:S:")) != -1) {
switch (option) {
case 'a':
slflags |= IFF_LINK2;
slflags &= ~IFF_LINK0;
break;
case 'c':
slflags |= IFF_LINK0;
slflags &= ~IFF_LINK2;
break;
case 'e':
exit_cmd = (char*) strdup (optarg);
break;
case 'f':
foreground = 1;
break;
case 'h':
flow_control |= CRTSCTS;
break;
case 'l':
modem_control = CLOCAL; /* clear HUPCL too */
break;
case 'n':
slflags |= IFF_LINK1;
break;
case 'r':
redial_cmd = (char*) strdup (optarg);
break;
case 's':
speed = atoi(optarg);
break;
case 'u':
config_cmd = (char*) strdup (optarg);
break;
case 'z':
redial_on_startup = 1;
break;
case 'L':
uucp_lock = 1;
break;
case 'K':
keepal = atoi(optarg);
break;
case 'O':
outfill = atoi(optarg);
break;
case 'S':
sl_unit = atoi(optarg);
break;
case '?':
default:
usage();
exit_handler(1);
}
}
if (optind == argc - 1)
dev = argv[optind];
if (optind < (argc - 1))
warnx("too many args, first='%s'", argv[optind]);
if (optind > (argc - 1))
warnx("not enough args");
if (dev == NULL) {
usage();
exit_handler(2);
}
if (strncmp(_PATH_DEV, dev, sizeof(_PATH_DEV) - 1)) {
strcpy(tty_path, _PATH_DEV);
strcat(tty_path, "/");
strncat(tty_path, dev, 10);
dev = tty_path;
}
dvname = strrchr(dev, '/'); /* always succeeds */
dvname++; /* trailing tty pathname component */
snprintf(pidfilename, sizeof(pidfilename),
"%sslattach.%s.pid", _PATH_VARRUN, dvname);
printf("%s\n",pidfilename);
if (!foreground)
daemon(0,0); /* fork, setsid, chdir /, and close std*. */
/* daemon() closed stderr, so log errors from here on. */
openlog("slattach",LOG_CONS|LOG_PID,LOG_DAEMON);
acquire_line(); /* get tty device as controlling terminal */
setup_line(0); /* configure for slip line discipline */
slip_discipline(); /* switch to slip line discipline */
/* upon INT log a timestamp and exit. */
if (signal(SIGINT,sigint_handler) == SIG_ERR)
syslog(LOG_NOTICE,"cannot install SIGINT handler: %m");
/* upon TERM log a timestamp and exit. */
if (signal(SIGTERM,sigterm_handler) == SIG_ERR)
syslog(LOG_NOTICE,"cannot install SIGTERM handler: %m");
/* upon HUP redial and reconnect. */
if (signal(SIGHUP,sighup_handler) == SIG_ERR)
syslog(LOG_NOTICE,"cannot install SIGHUP handler: %m");
if (redial_on_startup)
sighup_handler(0);
else if (!(modem_control & CLOCAL)) {
if (ioctl(fd, TIOCMGET, &comstate) < 0)
syslog(LOG_NOTICE,"cannot get carrier state: %m");
if (!(comstate & TIOCM_CD)) { /* check for carrier */
/* force a redial if no carrier */
kill (getpid(), SIGHUP);
} else
configure_network();
} else
configure_network(); /* configure the network if needed. */
for (;;) {
sigset_t mask;
sigemptyset(&mask);
sigsuspend(&mask);
}
}
/**
* draw elements / indexed primitives
*/
static void
sp_vbuf_draw(struct vbuf_render *vbr, const ushort *indices, uint nr)
{
struct softpipe_vbuf_render *cvbr = softpipe_vbuf_render(vbr);
struct softpipe_context *softpipe = cvbr->softpipe;
const unsigned stride = softpipe->vertex_info_vbuf.size * sizeof(float);
const void *vertex_buffer = cvbr->vertex_buffer;
unsigned i;
/* XXX: break this dependency - make setup_context live under
* softpipe, rename the old "setup" draw stage to something else.
*/
struct draw_stage *setup = softpipe->setup;
struct setup_context *setup_ctx = sp_draw_setup_context(setup);
switch (cvbr->prim) {
case PIPE_PRIM_POINTS:
for (i = 0; i < nr; i++) {
setup_point( setup_ctx,
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINES:
for (i = 1; i < nr; i += 2) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINE_STRIP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
break;
case PIPE_PRIM_LINE_LOOP:
for (i = 1; i < nr; i ++) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride) );
}
if (nr) {
setup_line( setup_ctx,
get_vert(vertex_buffer, indices[nr-1], stride),
get_vert(vertex_buffer, indices[0], stride) );
}
break;
case PIPE_PRIM_TRIANGLES:
for (i = 2; i < nr; i += 3) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride));
}
break;
case PIPE_PRIM_TRIANGLE_STRIP:
for (i = 2; i < nr; i += 1) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i+(i&1)-2], stride),
get_vert(vertex_buffer, indices[i-(i&1)-1], stride),
get_vert(vertex_buffer, indices[i-0], stride));
}
break;
case PIPE_PRIM_TRIANGLE_FAN:
for (i = 2; i < nr; i += 1) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[0], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride));
}
break;
case PIPE_PRIM_QUADS:
for (i = 3; i < nr; i += 4) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-0], stride));
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-0], stride));
}
break;
case PIPE_PRIM_QUAD_STRIP:
for (i = 3; i < nr; i += 2) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-2], stride),
get_vert(vertex_buffer, indices[i-0], stride));
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[i-1], stride),
get_vert(vertex_buffer, indices[i-3], stride),
get_vert(vertex_buffer, indices[i-0], stride));
}
break;
case PIPE_PRIM_POLYGON:
for (i = 2; i < nr; i += 1) {
setup_tri( setup_ctx,
get_vert(vertex_buffer, indices[0-1], stride),
get_vert(vertex_buffer, indices[i-0], stride),
get_vert(vertex_buffer, indices[0], stride));
}
break;
default:
assert(0);
}
/* XXX: why are we calling this??? If we had to call something, it
* would be a function in sp_setup.c:
*/
sp_draw_flush( setup );
}
