Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/3dfx/fxtexman.c

    r2938 r3598  
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    5555#include "fxdrv.h"
    5656
     57int texSwaps=0;
     58
    5759#define FX_2MB_SPLIT 0x200000
    5860
    5961static struct gl_texture_object *fxTMFindOldestObject(fxMesaContext fxMesa,
    60                                                       int tmu);
     62                                                      int tmu);
    6163
    6264
    … …  
    8284      fubar();
    8385    }
    84     if (prev && (prev->startAddr>=tmp->startAddr || 
    85         prev->endAddr>tmp->startAddr)) {
     86    if (prev && (prev->startAddr>=tmp->startAddr ||
     87        prev->endAddr>tmp->startAddr)) {
    8688      fprintf(stderr, "Sorting fubar\n");
    8789      fubar();
    … …  
    101103      fubar();
    102104    }
    103     if (prev && (prev->startAddr>=tmp->startAddr || 
    104         prev->endAddr>tmp->startAddr)) {
     105    if (prev && (prev->startAddr>=tmp->startAddr ||
     106        prev->endAddr>tmp->startAddr)) {
    105107      fprintf(stderr, "Sorting fubar\n");
    106108      fubar();
    … …  
    122124      fprintf(stderr, "fxDriver: out of memory!\n");
    123125      fxCloseHardware();
    124       exit(-1);
     126      EXIT(-1);
    125127    }
    126128  }
    … …  
    162164    if(fxMesa->verbose)
    163165      fprintf(stderr,"    %07u-%07u\n",
    164               (unsigned int)blockstart,(unsigned int)blockend);
     166              (unsigned int)blockstart,(unsigned int)blockend);
    165167
    166168    tmn=fxTMNewRangeNode(fxMesa, blockstart, blockend);
    … …  
    186188    while (tmp) {
    187189      if (tmp->endAddr-tmp->startAddr>=size) { /* Fits here */
    188         result=tmp->startAddr;
    189         tmp->startAddr+=size;
    190         if (tmp->startAddr==tmp->endAddr) { /* Empty */
    191           if (prev) {
    192             prev->next=tmp->next;
    193           } else {
    194             fxMesa->tmFree[tmu]=tmp->next;
    195           }
    196           fxTMDeleteRangeNode(fxMesa, tmp);
    197         }
    198         fxMesa->freeTexMem[tmu]-=size;
    199         return result;
     190        result=tmp->startAddr;
     191        tmp->startAddr+=size;
     192        if (tmp->startAddr==tmp->endAddr) { /* Empty */
     193          if (prev) {
     194            prev->next=tmp->next;
     195          } else {
     196            fxMesa->tmFree[tmu]=tmp->next;
     197          }
     198          fxTMDeleteRangeNode(fxMesa, tmp);
     199        }
     200        fxMesa->freeTexMem[tmu]-=size;
     201        return result;
    200202      }
    201203      prev=tmp;
    … …  
    209211    }
    210212    fxTMMoveOutTM(fxMesa, obj);
     213    texSwaps++;
    211214  }
    212215}
    … …  
    234237  range->next=tmp;
    235238  if (tmp) {
    236     if (range->endAddr==tmp->startAddr && tmp->startAddr&(FX_2MB_SPLIT-1)) { 
     239    if (range->endAddr==tmp->startAddr && tmp->startAddr&(FX_2MB_SPLIT-1)) {
    237240      /* Combine */
    238241      tmp->startAddr=range->startAddr;
    … …  
    242245  }
    243246  if (prev) {
    244     if (prev->endAddr==range->startAddr && range->startAddr&(FX_2MB_SPLIT-1)) { 
     247    if (prev->endAddr==range->startAddr && range->startAddr&(FX_2MB_SPLIT-1)) {
    245248      /* Combine */
    246249      prev->endAddr=range->endAddr;
    … …  
    254257
    255258static struct gl_texture_object *fxTMFindOldestObject(fxMesaContext fxMesa,
    256                                                       int tmu)
     259                                                      int tmu)
    257260{
    258261  GLuint age, old, lasttime, bindnumber;
    … …  
    270273
    271274    if (info && info->isInTM &&
    272         (info->whichTMU==tmu || info->whichTMU==FX_TMU_BOTH ||
    273         info->whichTMU==FX_TMU_SPLIT)) {
     275        ((info->whichTMU==tmu) || (info->whichTMU==FX_TMU_BOTH) ||
     276        (info->whichTMU==FX_TMU_SPLIT))) {
    274277      lasttime=info->lastTimeUsed;
    275278
    276279      if (lasttime>bindnumber)
    277         age=bindnumber+(UINT_MAX-lasttime+1); /* TO DO: check wrap around */
     280        age=bindnumber+(UINT_MAX-lasttime+1); /* TO DO: check wrap around */
    278281      else
    279         age=bindnumber-lasttime;
     282        age=bindnumber-lasttime;
    280283
    281284      if (age>=old) {
    282         old=age;
    283         obj=tmp;
     285        old=age;
     286        obj=tmp;
    284287      }
    285288    }
    … …  
    289292}
    290293
    291 static MemRange *fxTMAddObj(fxMesaContext fxMesa, 
    292                             struct gl_texture_object *tObj,
    293                             GLint tmu, int texmemsize)
     294static MemRange *fxTMAddObj(fxMesaContext fxMesa,
     295                            struct gl_texture_object *tObj,
     296                            GLint tmu, int texmemsize)
    294297{
    295298  FxU32 startAddr;
    … …  
    319322    fprintf(stderr,"fx Driver: internal error in fxTMMoveInTM() -> not validated\n");
    320323    fxCloseHardware();
    321     exit(-1);
    322   }
    323 
    324   if (ti->isInTM) return;
     324    EXIT(-1);
     325  }
     326
     327  if (ti->isInTM) {
     328    if (ti->whichTMU==where) return;
     329    if (where==FX_TMU_SPLIT || ti->whichTMU==FX_TMU_SPLIT)
     330      fxTMMoveOutTM_NoLock(fxMesa, tObj);
     331    else {
     332      if (ti->whichTMU==FX_TMU_BOTH) return;
     333      where=FX_TMU_BOTH;
     334    }
     335  }
    325336
    326337  if (MESA_VERBOSE&(VERBOSE_DRIVER|VERBOSE_TEXTURE)) {
    … …  
    334345  case FX_TMU1:
    335346    texmemsize=(int)FX_grTexTextureMemRequired_NoLock(GR_MIPMAPLEVELMASK_BOTH,
    336                                                       &(ti->info));
     347                                                      &(ti->info));
    337348    ti->tm[where]=fxTMAddObj(fxMesa, tObj, where, texmemsize);
    338349    fxMesa->stats.memTexUpload+=texmemsize;
    339350
    340351    for (i=FX_largeLodValue(ti->info), l=ti->minLevel;
    341         i<=FX_smallLodValue(ti->info);
    342         i++,l++)
     352        i<=FX_smallLodValue(ti->info);
     353        i++,l++)
    343354      FX_grTexDownloadMipMapLevel_NoLock(where,
    344                                         ti->tm[where]->startAddr,
    345                                         FX_valueToLod(i),
    346                                         FX_largeLodLog2(ti->info),
    347                                         FX_aspectRatioLog2(ti->info),
    348                                         ti->info.format,
    349                                         GR_MIPMAPLEVELMASK_BOTH,
    350                                         ti->mipmapLevel[l].data);
    351     break;
    352   case FX_TMU_SPLIT: /* TO DO: alternate even/odd TMU0/TMU1 */
     355                                        ti->tm[where]->startAddr,
     356                                        FX_valueToLod(i),
     357                                        FX_largeLodLog2(ti->info),
     358                                        FX_aspectRatioLog2(ti->info),
     359                                        ti->info.format,
     360                                        GR_MIPMAPLEVELMASK_BOTH,
     361                                        ti->mipmapLevel[l].data);
     362    break;
     363  case FX_TMU_SPLIT:
    353364    texmemsize=(int)FX_grTexTextureMemRequired_NoLock(GR_MIPMAPLEVELMASK_ODD,
    354                                                       &(ti->info));
     365                                                      &(ti->info));
    355366    ti->tm[FX_TMU0]=fxTMAddObj(fxMesa, tObj, FX_TMU0, texmemsize);
    356367    fxMesa->stats.memTexUpload+=texmemsize;
    357368
    358369    texmemsize=(int)FX_grTexTextureMemRequired_NoLock(GR_MIPMAPLEVELMASK_EVEN,
    359                                                       &(ti->info));
     370                                                      &(ti->info));
    360371    ti->tm[FX_TMU1]=fxTMAddObj(fxMesa, tObj, FX_TMU1, texmemsize);
    361372    fxMesa->stats.memTexUpload+=texmemsize;
    362373
    363374    for (i=FX_largeLodValue(ti->info),l=ti->minLevel;
    364         i<=FX_smallLodValue(ti->info);
    365         i++,l++) {
     375        i<=FX_smallLodValue(ti->info);
     376        i++,l++) {
    366377      FX_grTexDownloadMipMapLevel_NoLock(GR_TMU0,
    367                                         ti->tm[FX_TMU0]->startAddr,
    368                                         FX_valueToLod(i),
    369                                         FX_largeLodLog2(ti->info),
    370                                         FX_aspectRatioLog2(ti->info),
    371                                         ti->info.format,
    372                                         GR_MIPMAPLEVELMASK_ODD,
    373                                         ti->mipmapLevel[l].data);
     378                                        ti->tm[FX_TMU0]->startAddr,
     379                                        FX_valueToLod(i),
     380                                        FX_largeLodLog2(ti->info),
     381                                        FX_aspectRatioLog2(ti->info),
     382                                        ti->info.format,
     383                                        GR_MIPMAPLEVELMASK_ODD,
     384                                        ti->mipmapLevel[l].data);
    374385
    375386      FX_grTexDownloadMipMapLevel_NoLock(GR_TMU1,
    376                                          ti->tm[FX_TMU1]->startAddr,
    377                                          FX_valueToLod(i),
    378                                          FX_largeLodLog2(ti->info),
    379                                          FX_aspectRatioLog2(ti->info),
    380                                          ti->info.format,
    381                                          GR_MIPMAPLEVELMASK_EVEN,
    382                                          ti->mipmapLevel[l].data);
     387                                         ti->tm[FX_TMU1]->startAddr,
     388                                         FX_valueToLod(i),
     389                                         FX_largeLodLog2(ti->info),
     390                                         FX_aspectRatioLog2(ti->info),
     391                                         ti->info.format,
     392                                         GR_MIPMAPLEVELMASK_EVEN,
     393                                         ti->mipmapLevel[l].data);
     394    }
     395    break;
     396  case FX_TMU_BOTH:
     397    texmemsize=(int)FX_grTexTextureMemRequired_NoLock(GR_MIPMAPLEVELMASK_BOTH,
     398                                                      &(ti->info));
     399    ti->tm[FX_TMU0]=fxTMAddObj(fxMesa, tObj, FX_TMU0, texmemsize);
     400    fxMesa->stats.memTexUpload+=texmemsize;
     401
     402    texmemsize=(int)FX_grTexTextureMemRequired_NoLock(GR_MIPMAPLEVELMASK_BOTH,
     403                                                      &(ti->info));
     404    ti->tm[FX_TMU1]=fxTMAddObj(fxMesa, tObj, FX_TMU1, texmemsize);
     405    fxMesa->stats.memTexUpload+=texmemsize;
     406
     407    for (i=FX_largeLodValue(ti->info),l=ti->minLevel;
     408         i<=FX_smallLodValue(ti->info);
     409         i++,l++) {
     410      FX_grTexDownloadMipMapLevel_NoLock(GR_TMU0,
     411                                         ti->tm[FX_TMU0]->startAddr,
     412                                         FX_valueToLod(i),
     413                                         FX_largeLodLog2(ti->info),
     414                                         FX_aspectRatioLog2(ti->info),
     415                                         ti->info.format,
     416                                         GR_MIPMAPLEVELMASK_BOTH,
     417                                         ti->mipmapLevel[l].data);
     418
     419      FX_grTexDownloadMipMapLevel_NoLock(GR_TMU1,
     420                                         ti->tm[FX_TMU1]->startAddr,
     421                                         FX_valueToLod(i),
     422                                         FX_largeLodLog2(ti->info),
     423                                         FX_aspectRatioLog2(ti->info),
     424                                         ti->info.format,
     425                                         GR_MIPMAPLEVELMASK_BOTH,
     426                                         ti->mipmapLevel[l].data);
    383427    }
    384428    break;
    … …  
    386430    fprintf(stderr,"fx Driver: internal error in fxTMMoveInTM() -> wrong tmu (%d)\n",where);
    387431    fxCloseHardware();
    388     exit(-1);
     432    EXIT(-1);
    389433  }
    390434
    … …  
    409453    fprintf(stderr,"fx Driver: internal error in fxTMReloadMipMapLevel() -> not validated\n");
    410454    fxCloseHardware();
    411     exit(-1);
     455    EXIT(-1);
    412456  }
    413457
    … …  
    416460
    417461  fxTexGetInfo(ti->mipmapLevel[0].width,ti->mipmapLevel[0].height,
    418                &lodlevel, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    419 
     462               &lodlevel, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
     463
     464#ifdef FX_GLIDE3
     465  lodlevel-=level;
     466#else
     467  lodlevel+=level;
     468#endif
    420469  switch(tmu) {
    421470  case FX_TMU0:
    422471  case FX_TMU1:
    423472    FX_grTexDownloadMipMapLevel(tmu,
    424                                 ti->tm[tmu]->startAddr,
    425                                 FX_valueToLod(FX_lodToValue(lodlevel)+level),
    426                                 FX_largeLodLog2(ti->info),
    427                                 FX_aspectRatioLog2(ti->info),
    428                                 ti->info.format,
    429                                 GR_MIPMAPLEVELMASK_BOTH,
    430                                 ti->mipmapLevel[level].data);
    431     break;
    432   case FX_TMU_SPLIT: /* TO DO: alternate even/odd TMU0/TMU1 */
     473                                ti->tm[tmu]->startAddr,
     474                                FX_valueToLod(FX_lodToValue(lodlevel)),
     475                                FX_largeLodLog2(ti->info),
     476                                FX_aspectRatioLog2(ti->info),
     477                                ti->info.format,
     478                                GR_MIPMAPLEVELMASK_BOTH,
     479                                ti->mipmapLevel[level].data);
     480    break;
     481  case FX_TMU_SPLIT:
    433482    FX_grTexDownloadMipMapLevel(GR_TMU0,
    434                                 ti->tm[GR_TMU0]->startAddr,
    435                                 FX_valueToLod(FX_lodToValue(lodlevel)+level),
    436                                 FX_largeLodLog2(ti->info),
    437                                 FX_aspectRatioLog2(ti->info),
    438                                 ti->info.format,
    439                                 GR_MIPMAPLEVELMASK_ODD,
    440                                 ti->mipmapLevel[level].data);
    441    
     483                                ti->tm[GR_TMU0]->startAddr,
     484                                FX_valueToLod(FX_lodToValue(lodlevel)),
     485                                FX_largeLodLog2(ti->info),
     486                                FX_aspectRatioLog2(ti->info),
     487                                ti->info.format,
     488                                GR_MIPMAPLEVELMASK_ODD,
     489                                ti->mipmapLevel[level].data);
     490
    442491    FX_grTexDownloadMipMapLevel(GR_TMU1,
    443                                 ti->tm[GR_TMU1]->startAddr,
    444                                 FX_valueToLod(FX_lodToValue(lodlevel)+level),
    445                                 FX_largeLodLog2(ti->info),
    446                                 FX_aspectRatioLog2(ti->info),
    447                                 ti->info.format,
    448                                 GR_MIPMAPLEVELMASK_EVEN,
    449                                 ti->mipmapLevel[level].data);
    450     break;
     492                                ti->tm[GR_TMU1]->startAddr,
     493                                FX_valueToLod(FX_lodToValue(lodlevel)),
     494                                FX_largeLodLog2(ti->info),
     495                                FX_aspectRatioLog2(ti->info),
     496                                ti->info.format,
     497                                GR_MIPMAPLEVELMASK_EVEN,
     498                                ti->mipmapLevel[level].data);
     499    break;
     500  case FX_TMU_BOTH:
     501    FX_grTexDownloadMipMapLevel(GR_TMU0,
     502                                ti->tm[GR_TMU0]->startAddr,
     503                                FX_valueToLod(FX_lodToValue(lodlevel)),
     504                                FX_largeLodLog2(ti->info),
     505                                FX_aspectRatioLog2(ti->info),
     506                                ti->info.format,
     507                                GR_MIPMAPLEVELMASK_BOTH,
     508                                ti->mipmapLevel[level].data);
     509
     510    FX_grTexDownloadMipMapLevel(GR_TMU1,
     511                                ti->tm[GR_TMU1]->startAddr,
     512                                FX_valueToLod(FX_lodToValue(lodlevel)),
     513                                FX_largeLodLog2(ti->info),
     514                                FX_aspectRatioLog2(ti->info),
     515                                ti->info.format,
     516                                GR_MIPMAPLEVELMASK_BOTH,
     517                                ti->mipmapLevel[level].data);
     518    break;
     519
    451520  default:
    452521    fprintf(stderr,"fx Driver: internal error in fxTMReloadMipMapLevel() -> wrong tmu (%d)\n",tmu);
    453522    fxCloseHardware();
    454     exit(-1);
    455   }
    456 }
    457 
    458 void fxTMReloadSubMipMapLevel(fxMesaContext fxMesa, 
    459                               struct gl_texture_object *tObj,
    460                               GLint level, GLint yoffset, GLint height)
     523    EXIT(-1);
     524  }
     525}
     526
     527void fxTMReloadSubMipMapLevel(fxMesaContext fxMesa,
     528                              struct gl_texture_object *tObj,
     529                              GLint level, GLint yoffset, GLint height)
    461530{
    462531  tfxTexInfo *ti=fxTMGetTexInfo(tObj);
    … …  
    468537    fprintf(stderr,"fx Driver: internal error in fxTMReloadSubMipMapLevel() -> not validated\n");
    469538    fxCloseHardware();
    470     exit(-1);
     539    EXIT(-1);
    471540  }
    472541
    … …  
    475544
    476545  fxTexGetInfo(ti->mipmapLevel[0].width, ti->mipmapLevel[0].height,
    477                &lodlevel, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
     546               &lodlevel, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    478547
    479548  if((ti->info.format==GR_TEXFMT_INTENSITY_8) ||
    … …  
    488557  case FX_TMU1:
    489558    FX_grTexDownloadMipMapLevelPartial(tmu,
    490                                        ti->tm[tmu]->startAddr,
    491                                        FX_valueToLod(FX_lodToValue(lodlevel)+level),
    492                                        FX_largeLodLog2(ti->info),
    493                                        FX_aspectRatioLog2(ti->info),
    494                                        ti->info.format,
    495                                        GR_MIPMAPLEVELMASK_BOTH,
    496                                        data,
    497                                        yoffset,yoffset+height-1);
    498     break;
    499   case FX_TMU_SPLIT: /* TO DO: alternate even/odd TMU0/TMU1 */
     559                                       ti->tm[tmu]->startAddr,
     560                                       FX_valueToLod(FX_lodToValue(lodlevel)+level),
     561                                       FX_largeLodLog2(ti->info),
     562                                       FX_aspectRatioLog2(ti->info),
     563                                       ti->info.format,
     564                                       GR_MIPMAPLEVELMASK_BOTH,
     565                                       data,
     566                                       yoffset,yoffset+height-1);
     567    break;
     568  case FX_TMU_SPLIT:
    500569    FX_grTexDownloadMipMapLevelPartial(GR_TMU0,
    501                                        ti->tm[FX_TMU0]->startAddr,
    502                                        FX_valueToLod(FX_lodToValue(lodlevel)+level),
    503                                        FX_largeLodLog2(ti->info),
    504                                        FX_aspectRatioLog2(ti->info),
    505                                        ti->info.format,
    506                                        GR_MIPMAPLEVELMASK_ODD,
    507                                        data,
    508                                        yoffset,yoffset+height-1);
     570                                       ti->tm[FX_TMU0]->startAddr,
     571                                       FX_valueToLod(FX_lodToValue(lodlevel)+level),
     572                                       FX_largeLodLog2(ti->info),
     573                                       FX_aspectRatioLog2(ti->info),
     574                                       ti->info.format,
     575                                       GR_MIPMAPLEVELMASK_ODD,
     576                                       data,
     577                                       yoffset,yoffset+height-1);
    509578
    510579    FX_grTexDownloadMipMapLevelPartial(GR_TMU1,
    511                                        ti->tm[FX_TMU1]->startAddr,
    512                                        FX_valueToLod(FX_lodToValue(lodlevel)+level),
    513                                        FX_largeLodLog2(ti->info),
    514                                        FX_aspectRatioLog2(ti->info),
    515                                        ti->info.format,
    516                                        GR_MIPMAPLEVELMASK_EVEN,
    517                                        data,
    518                                        yoffset,yoffset+height-1);
     580                                       ti->tm[FX_TMU1]->startAddr,
     581                                       FX_valueToLod(FX_lodToValue(lodlevel)+level),
     582                                       FX_largeLodLog2(ti->info),
     583                                       FX_aspectRatioLog2(ti->info),
     584                                       ti->info.format,
     585                                       GR_MIPMAPLEVELMASK_EVEN,
     586                                       data,
     587                                       yoffset,yoffset+height-1);
     588    break;
     589  case FX_TMU_BOTH:
     590    FX_grTexDownloadMipMapLevelPartial(GR_TMU0,
     591                                       ti->tm[FX_TMU0]->startAddr,
     592                                       FX_valueToLod(FX_lodToValue(lodlevel)+level),
     593                                       FX_largeLodLog2(ti->info),
     594                                       FX_aspectRatioLog2(ti->info),
     595                                       ti->info.format,
     596                                       GR_MIPMAPLEVELMASK_BOTH,
     597                                       data,
     598                                       yoffset,yoffset+height-1);
     599
     600    FX_grTexDownloadMipMapLevelPartial(GR_TMU1,
     601                                       ti->tm[FX_TMU1]->startAddr,
     602                                       FX_valueToLod(FX_lodToValue(lodlevel)+level),
     603                                       FX_largeLodLog2(ti->info),
     604                                       FX_aspectRatioLog2(ti->info),
     605                                       ti->info.format,
     606                                       GR_MIPMAPLEVELMASK_BOTH,
     607                                       data,
     608                                       yoffset,yoffset+height-1);
    519609    break;
    520610  default:
    521611    fprintf(stderr,"fx Driver: internal error in fxTMReloadSubMipMapLevel() -> wrong tmu (%d)\n",tmu);
    522612    fxCloseHardware();
    523     exit(-1);
     613    EXIT(-1);
    524614  }
    525615}
    … …  
    541631    break;
    542632  case FX_TMU_SPLIT:
     633  case FX_TMU_BOTH:
    543634    fxTMRemoveRange(fxMesa, FX_TMU0, ti->tm[FX_TMU0]);
    544635    fxTMRemoveRange(fxMesa, FX_TMU1, ti->tm[FX_TMU1]);
    … …  
    547638    fprintf(stderr,"fx Driver: internal error in fxTMMoveOutTM()\n");
    548639    fxCloseHardware();
    549     exit(-1);
     640    EXIT(-1);
    550641  }
    551642
    … …  
    563654  for(i=0; i<MAX_TEXTURE_LEVELS; i++) {
    564655    if (ti->mipmapLevel[i].used &&
    565         ti->mipmapLevel[i].translated)
     656        ti->mipmapLevel[i].translated)
    566657      FREE(ti->mipmapLevel[i].data);
    567658
    … …  
    618709}
    619710
    620 void fxTMRestore_NoLock(fxMesaContext fxMesa, struct gl_texture_object *tObj)
    621 {
    622   tfxTexInfo *ti=fxTMGetTexInfo(tObj);
    623   int i,l, where;
    624 
    625   if (MESA_VERBOSE&VERBOSE_DRIVER) {
    626      fprintf(stderr,"fxmesa: fxRestore(%d)\n",tObj->Name);
    627   }
    628 
    629   if (!ti->validated) {
    630     fprintf(stderr,"fxDriver: internal error in fxRestore -> not validated\n");
    631     fxCloseHardware();
    632     exit(-1);
    633   }
    634 
    635   where=ti->whichTMU;
    636   if (MESA_VERBOSE&(VERBOSE_DRIVER|VERBOSE_TEXTURE)) {
    637     fprintf(stderr,"fxmesa: reloading %x (%d) in texture memory in %d\n",
    638             (GLuint)tObj, tObj->Name, where);
    639   }
    640 
    641   switch(where) {
    642   case FX_TMU0:
    643   case FX_TMU1:
    644     for (i=FX_largeLodValue_NoLock(ti->info), l=ti->minLevel;
    645          i<=FX_smallLodValue_NoLock(ti->info);
    646          i++,l++)
    647       if (ti->mipmapLevel[l].data)
    648         FX_grTexDownloadMipMapLevel_NoLock(where,
    649                                            ti->tm[where]->startAddr,
    650                                            FX_valueToLod(i),
    651                                            FX_largeLodLog2(ti->info),
    652                                            FX_aspectRatioLog2(ti->info),
    653                                            ti->info.format,
    654                                            GR_MIPMAPLEVELMASK_BOTH,
    655                                            ti->mipmapLevel[l].data);
    656     break;
    657   case FX_TMU_SPLIT: /* TO DO: alternate even/odd TMU0/TMU1 */
    658     for (i=FX_largeLodValue_NoLock(ti->info),l=ti->minLevel;
    659          i<=FX_smallLodValue_NoLock(ti->info);
    660          i++,l++) {
    661       if (ti->mipmapLevel[l].data) {
    662         FX_grTexDownloadMipMapLevel_NoLock(GR_TMU0,
    663                                            ti->tm[FX_TMU0]->startAddr,
    664                                            FX_valueToLod(i),
    665                                            FX_largeLodLog2(ti->info),
    666                                            FX_aspectRatioLog2(ti->info),
    667                                            ti->info.format,
    668                                            GR_MIPMAPLEVELMASK_ODD,
    669                                            ti->mipmapLevel[l].data);
    670         FX_grTexDownloadMipMapLevel_NoLock(GR_TMU1,
    671                                            ti->tm[FX_TMU1]->startAddr,
    672                                            FX_valueToLod(i),
    673                                            FX_largeLodLog2(ti->info),
    674                                            FX_aspectRatioLog2(ti->info),
    675                                            ti->info.format,
    676                                            GR_MIPMAPLEVELMASK_EVEN,
    677                                            ti->mipmapLevel[l].data);
    678       }
    679     }
    680     break;
    681   default:
    682     fprintf(stderr,"fxDriver: internal error in fxRestore -> bad tmu (%d)\n",
    683             where);
    684     fxCloseHardware();
    685     exit(-1);
    686   }
    687 }
    688 
    689711void
    690 fxTMRestoreTextures(fxMesaContext ctx) {
     712fxTMRestoreTextures_NoLock(fxMesaContext ctx) {
    691713  tfxTexInfo *ti;
    692714  struct gl_texture_object *tObj;
    693   int i;
     715  int i, where;
    694716
    695717  tObj=ctx->glCtx->Shared->TexObjectList;
    … …  
    698720    if (ti && ti->isInTM) {
    699721      for (i=0; i<MAX_TEXTURE_UNITS; i++)
    700         if (ctx->glCtx->Texture.Unit[i].Current==tObj) {
    701           /* Force the texture onto the board, as it could be in use */
    702           fxTMRestore_NoLock(ctx, tObj);
    703           break;
    704         }
     722        if (ctx->glCtx->Texture.Unit[i].Current==tObj) {
     723          /* Force the texture onto the board, as it could be in use */
     724          where=ti->whichTMU;
     725          fxTMMoveOutTM_NoLock(ctx, tObj);
     726          fxTMMoveInTM_NoLock(ctx, tObj, where);
     727          break;
     728        }
    705729      if (i==MAX_TEXTURE_UNITS) /* Mark the texture as off the board */
    706         fxTMMoveOutTM(ctx, tObj);
     730        fxTMMoveOutTM_NoLock(ctx, tObj);
    707731    }
    708732    tObj=tObj->Next;
Note: See TracChangeset for help on using the changeset viewer.