Ignore:
Timestamp:
Mar 16, 2008, 10:51:54 PM (11 years ago)
Author:
Sam Hocevar
Message:
  • Add lock() and unlock() methods to jimage objects. They're no-ops, but the Win32/DirectX version uses them all over the place because it uses DirectDraw? surfaces. One day we may wish to merge Abuse Win32's video output, or to use the SDL blending functions. You never know.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • abuse/trunk/src/imlib/timage.cpp

    r56 r115  
    2323      x+=*(dp++);
    2424      if (x<w)
    25       {     
    26         int run=*(dp++);
    27         memset(dp,c,run);
    28         x+=run;
    29         dp+=run;
     25      {
     26    int run=*(dp++);
     27    memset(dp,c,run);
     28    x+=run;
     29    dp+=run;
    3030      }
    3131    }
     
    3636{
    3737  image *im=new image(w,h);
     38
     39  im->lock();
    3840  uint8_t *d=im->scan_line(0),*dp=data,*dline;
    3941  int y,x;
     
    4951      x+=skip;
    5052      if (x<w)
    51       {     
    52         int run=*(dp++);
    53         memcpy(dline,dp,run);
    54         x+=run;
    55         dline+=run;
    56         dp+=run;
     53      {
     54    int run=*(dp++);
     55    memcpy(dline,dp,run);
     56    x+=run;
     57    dline+=run;
     58    dp+=run;
    5759      }
    5860    }
    5961    d=im->next_line(y,d);
    6062  }
     63  im->unlock();
    6164  return im;
    6265}
     
    6568{
    6669  int size=0,x,y;
    67   uint8_t *sl,*datap,*marker; 
     70  uint8_t *sl,*datap,*marker;
    6871  w=im->width();
    6972  h=im->height();
    70  
     73
     74  im->lock();
     75
    7176  // first we must find out how much data to allocate
    7277  for (y=0;y<im->height();y++)
    7378  {
    7479    sl=im->scan_line(y);
    75     x=0;   
     80    x=0;
    7681    while (x<w)
    77     {     
    78       size++;     
    79       while (x<w && *sl==0) { sl++; x++; }     
    80                                                                
     82    {
     83      size++;
     84      while (x<w && *sl==0) { sl++; x++; }
     85
    8186      if (x<w)
    8287      {
    83         size++;  // byte for the size of the run       
     88        size++;  // byte for the size of the run
    8489        while (x<w && (*sl)!=0)
    8590        {
    86           size++;
    87           x++;
    88           sl++;   
    89         }       
    90       }
    91     }       
    92   } 
     91      size++;
     92      x++;
     93      sl++;
     94    }
     95      }
     96    }
     97  }
    9398
    9499#ifdef MEM_CHECK
     
    104109  { printf("size = %d %d (%d)\n",im->width(),im->height(),size);  }
    105110  CONDITION(datap,"malloc error for trans_image::data");
    106  
     111
    107112  for (y=0;y<hh;y++)  // now actually make the runs
    108113  {
    109114    sl=im->scan_line(y);
    110     x=0;   
     115    x=0;
    111116    while (x<ww)
    112     {     
    113       *datap=0;  // start the skip at 0       
    114       while (x<im->width() && (*sl)==0) 
    115       { sl++; x++; (*datap)++; }     
    116       datap++;     
    117                                                                
     117    {
     118      *datap=0;  // start the skip at 0
     119      while (x<im->width() && (*sl)==0)
     120      { sl++; x++; (*datap)++; }
     121      datap++;
     122
    118123      if (x<ww)
    119124      {
    120125        marker=datap;   // let marker be the run size
    121         *marker=0;
    122         datap++;    // skip over this spot             
     126    *marker=0;
     127    datap++;    // skip over this spot
    123128        while (x<im->width() && (*sl)!=0)
    124         {       
    125           (*marker)++;   
    126           (*datap)=*sl;
    127           datap++;       
    128           x++;
    129           sl++;           
    130         }       
    131       }
    132     }       
    133   } 
    134 }
    135 
    136 void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent   
     129        {
     130          (*marker)++;
     131      (*datap)=*sl;
     132          datap++;
     133      x++;
     134      sl++;
     135    }
     136      }
     137    }
     138  }
     139  im->unlock();
     140}
     141
     142void trans_image::put_scan_line(image *screen, int x, int y, int line)   // always transparent
    137143{
    138144  int16_t x1,y1,x2,y2;
     
    142148
    143149  uint8_t *datap=data;
    144   int ix; 
     150  int ix;
    145151  while (line)            // skip scan line data until we get to the line of interest
    146152  {
    147     for (ix=0;ix<w;)     
    148     {     
     153    for (ix=0;ix<w;)
     154    {
    149155      ix+=*datap;        // skip blank space
    150156      datap++;
    151       if (ix<w)         
    152       { 
    153         int run_length=*datap;     // skip run
    154         ix+=run_length;
    155         datap+=run_length+1;
    156       }     
    157     }
    158     line--;   
    159     y++;   
    160   }
    161  
    162  
     157      if (ix<w)
     158      {
     159    int run_length=*datap;     // skip run
     160    ix+=run_length;
     161    datap+=run_length+1;
     162      }
     163    }
     164    line--;
     165    y++;
     166  }
     167
     168
    163169  // now slam this list of runs to the screen
     170  screen->lock();
    164171  uint8_t *screen_line=screen->scan_line(y)+x;
    165    
    166   for (ix=0;ix<w;)             
    167   {     
     172
     173  for (ix=0;ix<w;)
     174  {
    168175    int skip=*datap;              // how much space to skip?
    169176    datap++;
    170177    screen_line+=skip;
    171     ix+=skip;   
    172    
     178    ix+=skip;
     179
    173180    if (ix<w)
    174     {     
     181    {
    175182      int run_length=*datap;
    176183      datap++;
     
    178185      if (x+ix+run_length-1<x1)      // is this run clipped out totally?
    179186      {
    180         datap+=run_length;
    181         ix+=run_length;
    182         screen_line+=run_length;
     187    datap+=run_length;
     188    ix+=run_length;
     189    screen_line+=run_length;
    183190      }
    184191      else
    185       {     
    186         if (x+ix<x1)                 // is the run clipped partially?
    187         {       
    188           int clip=(x1-(x+ix));
    189           datap+=clip; 
    190           run_length-=clip;
    191           screen_line+=clip;
    192           ix+=clip;     
    193         }
    194 
    195         if (x+ix>x2)                      // clipped totally on the right? 
     192      {
     193    if (x+ix<x1)                 // is the run clipped partially?
     194    {
     195      int clip=(x1-(x+ix));
     196      datap+=clip;
     197      run_length-=clip;
     198      screen_line+=clip;
     199      ix+=clip;
     200    }
     201
     202    if (x+ix>x2)                      // clipped totally on the right?
     203        {
     204          screen->unlock();
    196205          return ;                        // we are done, return!
    197         else if (x+ix+run_length-1>x2)    // partially clipped?
    198         {
    199           memcpy(screen_line,datap,(x+ix+run_length-1)-x2);   // slam what we can
    200           return ;    // and return 'cause we are done with the line
     206        }
     207    else if (x+ix+run_length-1>x2)    // partially clipped?
     208    {
     209      memcpy(screen_line,datap,(x+ix+run_length-1)-x2);   // slam what we can
     210          screen->unlock();
     211      return ;    // and return 'cause we are done with the line
    201212        } else
    202213        {
    203           memcpy(screen_line,datap,run_length);
    204           screen_line+=run_length;
    205           datap+=run_length;
    206           ix+=run_length;           
    207         }     
    208       }   
    209     }
    210   }
    211 
    212 }
    213 
    214 
    215 inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2, 
    216                                    int x, int &y, int &ysteps)
     214      memcpy(screen_line,datap,run_length);
     215      screen_line+=run_length;
     216        datap+=run_length;
     217        ix+=run_length;
     218        }
     219      }
     220    }
     221  }
     222  screen->unlock();
     223}
     224
     225
     226inline uint8_t *trans_image::clip_y(image *screen, int x1, int y1, int x2, int y2,
     227                   int x, int &y, int &ysteps)
    217228{
    218229  // check to see if it is total clipped out first
     
    220231    return NULL;
    221232
    222   register uint8_t *datap=data; 
     233  uint8_t *datap=data;
    223234
    224235
    225236  ysteps=height();
    226  
     237
    227238  if (y<y1)  // check to see if the image gets clipped at the top
    228239  {
     
    230241
    231242    // because data is stored in runs, we need to skip over the top clipped portion
    232     int skips=(y1-y);     // how many lines do we need to skip?   
     243    int skips=(y1-y);     // how many lines do we need to skip?
    233244    ysteps-=skips;        // reduce h (number of lines to draw)
    234245    y=y1;                // start drawing here now
    235246    while (skips--)
    236     {     
    237       register int ix=0;
     247    {
     248      int ix=0;
    238249      while (ix<w)
    239       { 
     250      {
    240251        ix+=(*datap);       // skip over empty space
    241         datap++; 
    242         if (ix<w)                 
    243         { ix+=*datap;         
    244           datap+=(*datap)+1;   // skip over data
    245         }       
    246       }     
    247     }
    248   }
    249  
     252        datap++;
     253        if (ix<w)
     254        { ix+=*datap;
     255        datap+=(*datap)+1;   // skip over data
     256        }
     257      }
     258    }
     259  }
     260
    250261  if (y+ysteps>y2)  // check to see if it gets clipped at the bottom
    251262    ysteps-=(y+ysteps-y2-1);
    252263
    253   screen->add_dirty(max(x,x1),y,min(x+width()-1,x2),y+h-1); 
     264  screen->add_dirty(max(x,x1),y,min(x+width()-1,x2),y+h-1);
    254265  return datap;
    255 } 
    256 
    257 void trans_image::put_image_filled(image *screen, int x, int y, 
    258                                    uint8_t fill_color)
     266}
     267
     268void trans_image::put_image_filled(image *screen, int x, int y,
     269                   uint8_t fill_color)
    259270{
    260271 int16_t x1,y1,x2,y2;
     
    262273
    263274  screen->get_clip(x1,y1,x2,y2);
    264   register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
     275  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
    265276  if (!datap) return ;     // if clip_y says nothing to draw, return
    266  
    267   screen_line=screen->scan_line(y)+x; 
     277
     278  screen->lock();
     279
     280  screen_line=screen->scan_line(y)+x;
    268281  int sw=screen->width()-w;
    269282  x1-=x; x2-=x;
    270283  for (;ysteps>0;ysteps--)
    271   {         
    272     register int ix,slam_length;
     284  {
     285    int ix,slam_length;
    273286    for (ix=0;ix<w;)
    274287    {
     
    277290      ix+=blank;       // skip over empty space
    278291      screen_line+=blank;
    279      
    280       datap++; 
    281       if (ix<w)           
    282       { 
    283         slam_length=*datap;     // find the length of this run   
    284         datap++;         
    285         if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
    286         {
    287           datap+=slam_length;
    288           ix+=slam_length;
    289           screen_line+=slam_length;
    290         }
    291         else
    292         {                   
    293           if (ix<x1)                // the left side needs to be chopped ?
    294           {                   
    295             chop_length=(x1-ix);
    296            
    297             if (chop_length>=slam_length)  // see if we chopped it all off
    298             {                              // yes, we did
    299               ix+=slam_length;             // advance everything to the end of run
    300               screen_line+=slam_length;
    301               datap+=slam_length;             
    302               slam_length=0;           
    303             } else
    304             {       
    305               slam_length-=chop_length;   // else advance everything to begining of slam 
    306               ix+=chop_length;
    307               screen_line+=chop_length;
    308               datap+=chop_length;           
    309             }       
    310           }               
    311 
    312           if (slam_length)   // see if there is anything left to slam
    313           {
    314             if (ix+slam_length>x2) // see if right side needs to be chopped off
    315               memcpy(screen_line,datap,x2-ix+1);
    316             else
    317               memcpy(screen_line,datap,slam_length);
    318             datap+=slam_length;
    319             ix+=slam_length;       
    320             screen_line+=slam_length;
    321           }                   
    322         }
    323       }     
     292
     293      datap++;
     294      if (ix<w)
     295      {
     296    slam_length=*datap;     // find the length of this run
     297    datap++;
     298    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
     299    {
     300      datap+=slam_length;
     301      ix+=slam_length;
     302      screen_line+=slam_length;
     303    }
     304    else
     305    {
     306      if (ix<x1)                // the left side needs to be chopped ?
     307      {
     308        chop_length=(x1-ix);
     309
     310        if (chop_length>=slam_length)  // see if we chopped it all off
     311        {                              // yes, we did
     312          ix+=slam_length;             // advance everything to the end of run
     313          screen_line+=slam_length;
     314          datap+=slam_length;
     315          slam_length=0;
     316        } else
     317        {
     318          slam_length-=chop_length;   // else advance everything to begining of slam
     319          ix+=chop_length;
     320          screen_line+=chop_length;
     321          datap+=chop_length;
     322        }
     323      }
     324
     325      if (slam_length)   // see if there is anything left to slam
     326      {
     327        if (ix+slam_length>x2) // see if right side needs to be chopped off
     328          memcpy(screen_line,datap,x2-ix+1);
     329        else
     330          memcpy(screen_line,datap,slam_length);
     331        datap+=slam_length;
     332        ix+=slam_length;
     333        screen_line+=slam_length;
     334      }
     335    }
     336      }
    324337    }
    325338    screen_line+=sw;
    326   }   
     339  }
     340  screen->unlock();
    327341}
    328342
     
    330344{
    331345  int ix,ysteps=height();
    332   int screen_skip=screen->width()-w;
     346  int screen_skip;
    333347  uint8_t skip,*datap=data;
     348
     349  screen->lock();
     350  screen_skip = screen->width() - w;
    334351  for (;ysteps;ysteps--)
    335352  {
     
    342359
    343360      if (s_off<screen->scan_line(0))
    344         printf("bad write");
     361          printf("bad write in trans_image::put_image_offseted");
    345362
    346363
    347364      if (ix<w)
    348365      {
    349         skip=*datap;
    350         datap++;
    351         memcpy(s_off,datap,skip);
    352         datap+=skip;
    353         s_off+=skip;
    354         ix+=skip;
    355 
    356         if (s_off>=screen->scan_line(screen->height()+1))
    357           printf("bad write");
     366    skip=*datap;
     367    datap++;
     368    memcpy(s_off,datap,skip);
     369    datap+=skip;
     370    s_off+=skip;
     371    ix+=skip;
     372
     373    if (s_off>=screen->scan_line(screen->height()+1))
     374            printf("bad write in trans_image::put_image_offseted");
    358375      }
    359376    }
    360377    s_off+=screen_skip;
    361378  }
    362 }
    363 
    364 void trans_image::put_image(image *screen, int x, int y)
     379  screen->unlock();
     380}
     381
     382void trans_image::put_image(image *screen, int x, int y)
    365383{
    366384  int16_t x1,y1,x2,y2;
     
    368386
    369387  screen->get_clip(x1,y1,x2,y2);
    370   register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
     388  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
    371389  if (!datap) return ;     // if clip_y says nothing to draw, return
    372  
    373   screen_line=screen->scan_line(y)+x; 
     390
     391  screen->lock();
     392  screen_line=screen->scan_line(y)+x;
    374393  int sw=screen->width();
    375394  x1-=x; x2-=x;
    376395  for (;ysteps>0;ysteps--)
    377   {         
    378     register int ix,slam_length;
     396  {
     397    int ix,slam_length;
    379398    for (ix=0;ix<w;)
    380399    {
    381400      ix+=(*datap);       // skip over empty space
    382       datap++; 
    383       if (ix<w)           
    384       { 
    385         slam_length=*datap;     // find the length of this run   
    386         datap++;         
    387         if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
    388         {
    389           datap+=slam_length;
    390           ix+=slam_length;         
    391         }
    392         else
    393         {                   
    394           if (ix<x1)                // the left side needs to be chopped ?
    395           {                   
    396             chop_length=(x1-ix);
    397            
    398             if (chop_length>=slam_length)  // see if we chopped it all off
    399             {                              // yes, we did
    400               ix+=slam_length;             // advance everything to the end of run
    401               datap+=slam_length;             
    402               slam_length=0;           
    403             } else
    404             {       
    405               slam_length-=chop_length;   // else advance everything to begining of slam 
    406               ix+=chop_length;
    407               datap+=chop_length;           
    408             }       
    409           }               
    410 
    411           if (slam_length)   // see if there is anything left to slam
    412           {
    413             if (ix+slam_length>x2) // see if right side needs to be chopped off
    414               memcpy(screen_line+ix,datap,x2-ix+1);
    415             else
    416               memcpy(screen_line+ix,datap,slam_length);
    417             datap+=slam_length;
    418             ix+=slam_length;       
    419           }                   
    420         }
    421       }     
     401      datap++;
     402      if (ix<w)
     403      {
     404    slam_length=*datap;     // find the length of this run
     405    datap++;
     406    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
     407    {
     408      datap+=slam_length;
     409      ix+=slam_length;
     410    }
     411    else
     412    {
     413      if (ix<x1)                // the left side needs to be chopped ?
     414      {
     415        chop_length=(x1-ix);
     416
     417        if (chop_length>=slam_length)  // see if we chopped it all off
     418        {                              // yes, we did
     419          ix+=slam_length;             // advance everything to the end of run
     420          datap+=slam_length;
     421          slam_length=0;
     422        } else
     423        {
     424          slam_length-=chop_length;   // else advance everything to begining of slam
     425          ix+=chop_length;
     426          datap+=chop_length;
     427        }
     428      }
     429
     430      if (slam_length)   // see if there is anything left to slam
     431      {
     432        if (ix+slam_length>x2) // see if right side needs to be chopped off
     433          memcpy(screen_line+ix,datap,x2-ix+1);
     434        else
     435          memcpy(screen_line+ix,datap,slam_length);
     436        datap+=slam_length;
     437        ix+=slam_length;
     438      }
     439    }
     440      }
    422441    }
    423442    screen_line+=sw;
    424   }   
    425 }
    426 
    427 void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap)
     443  }
     444  screen->unlock();
     445}
     446
     447void trans_image::put_remaped(image *screen, int x, int y, uint8_t *remap)
    428448{
    429449  int16_t x1,y1,x2,y2;
     
    431451
    432452  screen->get_clip(x1,y1,x2,y2);
    433   register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
     453  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
    434454  if (!datap) return ;     // if clip_y says nothing to draw, return
    435  
    436   screen_line=screen->scan_line(y)+x; 
     455
     456  screen->lock();
     457  screen_line=screen->scan_line(y)+x;
    437458  int sw=screen->width();
    438459  x1-=x; x2-=x;
    439460  for (;ysteps>0;ysteps--)
    440   {         
    441     register int ix,slam_length;
     461  {
     462    int ix,slam_length;
    442463    for (ix=0;ix<w;)
    443464    {
    444465      ix+=(*datap);       // skip over empty space
    445       datap++; 
    446       if (ix<w)           
    447       { 
    448         slam_length=*datap;     // find the length of this run   
    449         datap++;         
    450         if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
    451         {
    452           datap+=slam_length;
    453           ix+=slam_length;         
    454         }
    455         else
    456         {                   
    457           if (ix<x1)                // the left side needs to be chopped ?
    458           {                   
    459             chop_length=(x1-ix);
    460            
    461             if (chop_length>=slam_length)  // see if we chopped it all off
    462             {                              // yes, we did
    463               ix+=slam_length;             // advance everything to the end of run
    464               datap+=slam_length;             
    465               slam_length=0;           
    466             } else
    467             {       
    468               slam_length-=chop_length;   // else advance everything to begining of slam 
    469               ix+=chop_length;
    470               datap+=chop_length;           
    471             }       
    472           }               
    473 
    474 
    475           if (slam_length)   // see if there is anything left to slam
    476           {
    477             register int counter;
    478             if (ix+slam_length>x2) // see if right side needs to be chopped off     
    479               counter=x2-ix+1;
    480             else
    481               counter=slam_length;
    482 
    483             register uint8_t *sl=screen_line+ix,*sl2=datap;
    484             ix+=slam_length;       
    485             datap+=slam_length;
    486             while (counter)
    487             {
    488               counter--;
    489               *(sl)=remap[*(sl2)];
    490               sl++;
    491               sl2++;
    492             }
    493           }                   
    494         }
    495       }     
     466      datap++;
     467      if (ix<w)
     468      {
     469    slam_length=*datap;     // find the length of this run
     470    datap++;
     471    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
     472    {
     473      datap+=slam_length;
     474      ix+=slam_length;
     475    }
     476    else
     477    {
     478      if (ix<x1)                // the left side needs to be chopped ?
     479      {
     480        chop_length=(x1-ix);
     481
     482        if (chop_length>=slam_length)  // see if we chopped it all off
     483        {                              // yes, we did
     484          ix+=slam_length;             // advance everything to the end of run
     485          datap+=slam_length;
     486          slam_length=0;
     487        } else
     488        {
     489          slam_length-=chop_length;   // else advance everything to begining of slam
     490          ix+=chop_length;
     491          datap+=chop_length;
     492        }
     493      }
     494
     495
     496      if (slam_length)   // see if there is anything left to slam
     497      {
     498        int counter;
     499        if (ix+slam_length>x2) // see if right side needs to be chopped off
     500          counter=x2-ix+1;
     501        else
     502          counter=slam_length;
     503
     504        uint8_t *sl=screen_line+ix,*sl2=datap;
     505        ix+=slam_length;
     506        datap+=slam_length;
     507        while (counter)
     508        {
     509          counter--;
     510          *(sl)=remap[*(sl2)];
     511          sl++;
     512          sl2++;
     513        }
     514      }
     515    }
     516      }
    496517    }
    497518    screen_line+=sw;
    498   }   
    499 }
    500 
    501 
    502 
    503 void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2)
     519  }
     520  screen->unlock();
     521}
     522
     523
     524
     525void trans_image::put_double_remaped(image *screen, int x, int y, uint8_t *remap, uint8_t *remap2)
    504526{
    505527  int16_t x1,y1,x2,y2;
     
    507529
    508530  screen->get_clip(x1,y1,x2,y2);
    509   register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
     531  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
    510532  if (!datap) return ;     // if clip_y says nothing to draw, return
    511  
    512   screen_line=screen->scan_line(y)+x; 
     533
     534  screen->lock();
     535  screen_line=screen->scan_line(y)+x;
    513536  int sw=screen->width();
    514537  x1-=x; x2-=x;
    515538  for (;ysteps>0;ysteps--)
    516   {         
    517     register int ix,slam_length;
     539  {
     540    int ix,slam_length;
    518541    for (ix=0;ix<w;)
    519542    {
    520543      ix+=(*datap);       // skip over empty space
    521       datap++; 
    522       if (ix<w)           
    523       { 
    524         slam_length=*datap;     // find the length of this run   
    525         datap++;         
    526         if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
    527         {
    528           datap+=slam_length;
    529           ix+=slam_length;         
    530         }
    531         else
    532         {                   
    533           if (ix<x1)                // the left side needs to be chopped ?
    534           {                   
    535             chop_length=(x1-ix);
    536            
    537             if (chop_length>=slam_length)  // see if we chopped it all off
    538             {                              // yes, we did
    539               ix+=slam_length;             // advance everything to the end of run
    540               datap+=slam_length;             
    541               slam_length=0;           
    542             } else
    543             {       
    544               slam_length-=chop_length;   // else advance everything to begining of slam 
    545               ix+=chop_length;
    546               datap+=chop_length;           
    547             }       
    548           }               
    549 
    550 
    551           if (slam_length)   // see if there is anything left to slam
    552           {
    553             register int counter;
    554             if (ix+slam_length>x2) // see if right side needs to be chopped off     
    555               counter=x2-ix+1;
    556             else
    557               counter=slam_length;
    558 
    559             register uint8_t *sl=screen_line+ix,*sl2=datap;
    560             ix+=slam_length;       
    561             datap+=slam_length;
    562             while (counter)
    563             {
    564               counter--;
    565               *(sl)=remap2[remap[*(sl2)]];
    566               sl++;
    567               sl2++;
    568             }
    569           }                   
    570         }
    571       }     
     544      datap++;
     545      if (ix<w)
     546      {
     547    slam_length=*datap;     // find the length of this run
     548    datap++;
     549    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
     550    {
     551      datap+=slam_length;
     552      ix+=slam_length;
     553    }
     554    else
     555    {
     556      if (ix<x1)                // the left side needs to be chopped ?
     557      {
     558        chop_length=(x1-ix);
     559
     560        if (chop_length>=slam_length)  // see if we chopped it all off
     561        {                              // yes, we did
     562          ix+=slam_length;             // advance everything to the end of run
     563          datap+=slam_length;
     564          slam_length=0;
     565        } else
     566        {
     567          slam_length-=chop_length;   // else advance everything to begining of slam
     568          ix+=chop_length;
     569          datap+=chop_length;
     570        }
     571      }
     572
     573
     574      if (slam_length)   // see if there is anything left to slam
     575      {
     576        int counter;
     577        if (ix+slam_length>x2) // see if right side needs to be chopped off
     578          counter=x2-ix+1;
     579        else
     580          counter=slam_length;
     581
     582        uint8_t *sl=screen_line+ix,*sl2=datap;
     583        ix+=slam_length;
     584        datap+=slam_length;
     585        while (counter)
     586        {
     587          counter--;
     588          *(sl)=remap2[remap[*(sl2)]];
     589          sl++;
     590          sl2++;
     591        }
     592      }
     593    }
     594      }
    572595    }
    573596    screen_line+=sw;
    574   }   
     597  }
     598  screen->unlock();
    575599}
    576600
     
    578602
    579603void trans_image::put_fade(image *screen, int x, int y,
    580                            int frame_on, int total_frames,
    581                            color_filter *f, palette *pal)
     604               int frame_on, int total_frames,
     605               color_filter *f, palette *pal)
    582606{
    583607  int16_t x1,y1,x2,y2;
     
    593617
    594618  long fixmul=(frame_on<<16)/total_frames;
     619  screen->lock();
    595620  for (;ysteps>0;ysteps--,y++)
    596   {         
     621  {
    597622    screen_line=screen->scan_line(y);
    598      
     623
    599624    for (ix=0;ix<w;)
    600625    {
    601626      ix+=(*datap);       // skip over empty space
    602       datap++;
    603       if (ix<w)           
    604       {
    605         slam_length=*datap;     // find the length of this run   
    606         datap++;         
    607         if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
    608         {
    609           datap+=slam_length;
    610           ix+=slam_length;         
    611         }
    612         else
    613         {                   
    614           if (x+ix<x1)                // the left side needs to be chopped ?
    615           {                   
    616             chop_length=(x1-x-ix);
    617            
    618             if (chop_length>=slam_length)  // see if we chopped it all off
    619             {                              // yes, we did
    620               ix+=slam_length;             // advance everything to the end of run
    621               datap+=slam_length;             
    622               slam_length=0;           
    623             } else
    624             {       
    625               slam_length-=chop_length;   // else advance everything to begining of slam 
    626               ix+=chop_length;
    627               datap+=chop_length;           
    628             }       
    629           }               
    630 
    631           if (slam_length)   // see if there is anything left to slam
    632           {
    633             if (x+ix+slam_length>x2) // see if right side needs to be chopped off
    634               chop_length=x2-x-ix;
    635             else chop_length=slam_length;
    636             screen_run=screen_line+x+ix;
    637              
    638             slam_length-=chop_length;
    639             ix+=chop_length;
    640              
    641             while (chop_length--)
    642             {
    643               caddr1=paddr+(int)(*screen_run)*3;
    644               caddr2=paddr+(int)(*datap)*3;
    645              
    646               r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    647               caddr1++; caddr2++;
    648 
    649               g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    650               caddr1++; caddr2++;
    651 
    652               b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    653               *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
    654 
    655               screen_run++;
    656               datap++;         
    657             }
    658             datap+=slam_length;
    659             ix+=slam_length;       
    660           }                   
    661         }
    662       }     
    663     }     
    664   }   
     627      datap++;
     628      if (ix<w)
     629      {
     630    slam_length=*datap;     // find the length of this run
     631    datap++;
     632    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
     633    {
     634      datap+=slam_length;
     635      ix+=slam_length;
     636    }
     637    else
     638    {
     639      if (x+ix<x1)                // the left side needs to be chopped ?
     640      {
     641        chop_length=(x1-x-ix);
     642
     643        if (chop_length>=slam_length)  // see if we chopped it all off
     644        {                              // yes, we did
     645          ix+=slam_length;             // advance everything to the end of run
     646          datap+=slam_length;
     647          slam_length=0;
     648        } else
     649        {
     650          slam_length-=chop_length;   // else advance everything to begining of slam
     651          ix+=chop_length;
     652          datap+=chop_length;
     653        }
     654      }
     655
     656      if (slam_length)   // see if there is anything left to slam
     657      {
     658        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
     659          chop_length=x2-x-ix;
     660        else chop_length=slam_length;
     661        screen_run=screen_line+x+ix;
     662
     663        slam_length-=chop_length;
     664        ix+=chop_length;
     665
     666        while (chop_length--)
     667        {
     668          caddr1=paddr+(int)(*screen_run)*3;
     669          caddr2=paddr+(int)(*datap)*3;
     670
     671          r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     672          caddr1++; caddr2++;
     673
     674          g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     675          caddr1++; caddr2++;
     676
     677          b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     678          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
     679
     680          screen_run++;
     681          datap++;
     682        }
     683        datap+=slam_length;
     684        ix+=slam_length;
     685      }
     686    }
     687      }
     688    }
     689  }
     690  screen->unlock();
    665691}
    666692
     
    669695
    670696void trans_image::put_fade_tint(image *screen, int x, int y,
    671                                 int frame_on, int total_frames,
    672                                 uint8_t *tint,
    673                                 color_filter *f, palette *pal)
     697                int frame_on, int total_frames,
     698                uint8_t *tint,
     699                color_filter *f, palette *pal)
    674700{
    675701  int16_t x1,y1,x2,y2;
     
    681707  if (!datap) return ;
    682708
     709  screen->lock();
    683710  uint8_t *screen_run,*paddr=(uint8_t *)pal->addr(),
    684711                *caddr1,*caddr2,r_dest,g_dest,b_dest;
     
    686713  long fixmul=(frame_on<<16)/total_frames;
    687714  for (;ysteps>0;ysteps--,y++)
    688   {         
     715  {
    689716    screen_line=screen->scan_line(y);
    690      
     717
    691718    for (ix=0;ix<w;)
    692719    {
    693720      ix+=(*datap);       // skip over empty space
    694       datap++;
    695       if (ix<w)           
    696       {
    697         slam_length=*datap;     // find the length of this run   
    698         datap++;         
    699         if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
    700         {
    701           datap+=slam_length;
    702           ix+=slam_length;         
    703         }
    704         else
    705         {                   
    706           if (x+ix<x1)                // the left side needs to be chopped ?
    707           {                   
    708             chop_length=(x1-x-ix);
    709            
    710             if (chop_length>=slam_length)  // see if we chopped it all off
    711             {                              // yes, we did
    712               ix+=slam_length;             // advance everything to the end of run
    713               datap+=slam_length;             
    714               slam_length=0;           
    715             } else
    716             {       
    717               slam_length-=chop_length;   // else advance everything to begining of slam 
    718               ix+=chop_length;
    719               datap+=chop_length;           
    720             }       
    721           }               
    722 
    723           if (slam_length)   // see if there is anything left to slam
    724           {
    725             if (x+ix+slam_length>x2) // see if right side needs to be chopped off
    726               chop_length=x2-x-ix;
    727             else chop_length=slam_length;
    728             screen_run=screen_line+x+ix;
    729              
    730             slam_length-=chop_length;
    731             ix+=chop_length;
    732              
    733             while (chop_length--)
    734             {
    735               caddr1=paddr+(int)(*screen_run)*3;
    736               caddr2=paddr+(int)(tint[*datap])*3;
    737              
    738               r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    739               caddr1++; caddr2++;
    740 
    741               g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    742               caddr1++; caddr2++;
    743 
    744               b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
    745               *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
    746 
    747               screen_run++;
    748               datap++;         
    749             }
    750             datap+=slam_length;
    751             ix+=slam_length;       
    752           }                   
    753         }
    754       }     
    755     }     
    756   }   
    757 }
    758 
    759 
    760 
    761 
    762 
    763 
    764 void trans_image::put_color(image *screen, int x, int y, int color)
     721      datap++;
     722      if (ix<w)
     723      {
     724    slam_length=*datap;     // find the length of this run
     725    datap++;
     726    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
     727    {
     728      datap+=slam_length;
     729      ix+=slam_length;
     730    }
     731    else
     732    {
     733      if (x+ix<x1)                // the left side needs to be chopped ?
     734      {
     735        chop_length=(x1-x-ix);
     736
     737        if (chop_length>=slam_length)  // see if we chopped it all off
     738        {                              // yes, we did
     739          ix+=slam_length;             // advance everything to the end of run
     740          datap+=slam_length;
     741          slam_length=0;
     742        } else
     743        {
     744          slam_length-=chop_length;   // else advance everything to begining of slam
     745          ix+=chop_length;
     746          datap+=chop_length;
     747        }
     748      }
     749
     750      if (slam_length)   // see if there is anything left to slam
     751      {
     752        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
     753          chop_length=x2-x-ix;
     754        else chop_length=slam_length;
     755        screen_run=screen_line+x+ix;
     756
     757        slam_length-=chop_length;
     758        ix+=chop_length;
     759
     760        while (chop_length--)
     761        {
     762          caddr1=paddr+(int)(*screen_run)*3;
     763          caddr2=paddr+(int)(tint[*datap])*3;
     764
     765          r_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     766          caddr1++; caddr2++;
     767
     768          g_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     769          caddr1++; caddr2++;
     770
     771          b_dest=((((int)(*caddr1)-(int)(*caddr2))*fixmul)>>16)+(int)(*caddr2);
     772          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
     773
     774          screen_run++;
     775          datap++;
     776        }
     777        datap+=slam_length;
     778        ix+=slam_length;
     779      }
     780    }
     781      }
     782    }
     783  }
     784  screen->unlock();
     785}
     786
     787void trans_image::put_color(image *screen, int x, int y, int color)
    765788{
    766789  int16_t x1,y1,x2,y2;
    767790  int ix,slam_length,chop_length,ysteps;
    768  
     791
    769792  screen->get_clip(x1,y1,x2,y2);
    770793  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
    771794                *screen_line;
    772795  if (!datap) return ;
    773  
    774  
     796
     797  screen->lock();
    775798  for (;ysteps>0;ysteps--,y++)
    776   {         
     799  {
    777800    screen_line=screen->scan_line(y);
    778      
     801
    779802    for (ix=0;ix<w;)
    780803    {
    781804      ix+=(*datap);       // skip over empty space
    782       datap++;
    783       if (ix<w)           
    784       {
    785         slam_length=*datap;     // find the length of this run   
    786         datap++;         
    787         if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
    788         {
    789           datap+=slam_length;
    790           ix+=slam_length;         
    791         }
    792         else
    793         {                   
    794           if (x+ix<x1)                // the left side needs to be chopped ?
    795           {                   
    796             chop_length=(x1-x-ix);
    797            
    798             if (chop_length>=slam_length)  // see if we chopped it all off
    799             {                              // yes, we did
    800               ix+=slam_length;             // advance everything to the end of run
    801               datap+=slam_length;             
    802               slam_length=0;           
    803             } else
    804             {       
    805               slam_length-=chop_length;   // else advance everything to begining of slam 
    806               ix+=chop_length;
    807               datap+=chop_length;           
    808             }       
    809           }               
    810 
    811           if (slam_length)   // see if there is anything left to slam
    812           {
    813             if (x+ix+slam_length>x2) // see if right side needs to be chopped off
    814               memset(screen_line+x+ix,color,x2-x-ix+1);
    815             else
    816               memset(screen_line+x+ix,color,slam_length);
    817             datap+=slam_length;
    818             ix+=slam_length;       
    819           }     
    820         }
    821       }     
    822     }     
    823   }   
     805      datap++;
     806      if (ix<w)
     807      {
     808    slam_length=*datap;     // find the length of this run
     809    datap++;
     810    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
     811    {
     812      datap+=slam_length;
     813      ix+=slam_length;
     814    }
     815    else
     816    {
     817      if (x+ix<x1)                // the left side needs to be chopped ?
     818      {
     819        chop_length=(x1-x-ix);
     820
     821        if (chop_length>=slam_length)  // see if we chopped it all off
     822        {                              // yes, we did
     823          ix+=slam_length;             // advance everything to the end of run
     824          datap+=slam_length;
     825          slam_length=0;
     826        } else
     827        {
     828          slam_length-=chop_length;   // else advance everything to begining of slam
     829          ix+=chop_length;
     830          datap+=chop_length;
     831        }
     832      }
     833
     834      if (slam_length)   // see if there is anything left to slam
     835      {
     836        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
     837          memset(screen_line+x+ix,color,x2-x-ix+1);
     838        else
     839          memset(screen_line+x+ix,color,slam_length);
     840        datap+=slam_length;
     841        ix+=slam_length;
     842      }
     843    }
     844      }
     845    }
     846  }
     847  screen->unlock();
    824848}
    825849
    826850
    827851// ASSUMES that the blend image completly covers this image
    828 void trans_image::put_blend16(image *screen, image *blend, int x, int y, 
    829                    int blendx, int blendy, int blend_amount, color_filter *f, palette *pal)
     852void trans_image::put_blend16(image *screen, image *blend, int x, int y,
     853                  int blendx, int blendy, int blend_amount, color_filter *f, palette *pal)
    830854
    831855{
    832856  int16_t x1,y1,x2,y2;
    833857  int ix,slam_length,chop_length,ysteps;
    834   uint8_t *paddr=(uint8_t *)pal->addr(); 
    835  
     858  uint8_t *paddr=(uint8_t *)pal->addr();
     859
    836860  screen->get_clip(x1,y1,x2,y2);
    837861  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),
     
    839863  if (!datap) return ;
    840864  CONDITION(y>=blendy && y+ysteps<blendy+blend->height()+1,"Blend doesn't fit on trans_image");
    841  
     865
    842866  blend_amount=16-blend_amount;
    843  
     867
     868  screen->lock();
    844869  for (;ysteps>0;ysteps--,y++)
    845   {         
     870  {
    846871    screen_line=screen->scan_line(y);
    847872    blend_line=blend->scan_line(y-blendy);
    848    
    849      
     873
     874
    850875    for (ix=0;ix<w;)
    851876    {
    852877      ix+=(*datap);       // skip over empty space
    853       datap++; 
    854       if (ix<w)           
    855       { 
    856         slam_length=*datap;     // find the length of this run   
    857         datap++;         
    858         if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
    859         {
    860           datap+=slam_length;
    861           ix+=slam_length;         
    862         }
    863         else
    864         {                   
    865           if (x+ix<x1)                // the left side needs to be chopped ?
    866           {                   
    867             chop_length=(x1-x-ix);
    868            
    869             if (chop_length>=slam_length)  // see if we chopped it all off
    870             {                              // yes, we did
    871               ix+=slam_length;             // advance everything to the end of run
    872               datap+=slam_length;             
    873               slam_length=0;           
    874             } else
    875             {       
    876               slam_length-=chop_length;   // else advance everything to begining of slam 
    877               ix+=chop_length;
    878               datap+=chop_length;           
    879             }       
    880           }               
    881 
    882           if (slam_length)   // see if there is anything left to slam
    883           {
    884 
    885             if (x+ix+slam_length>x2) // see if right side needs to be chopped off
    886               chop_length=x2-x-ix;
    887             else chop_length=slam_length;
    888 
    889             uint8_t *screen_run=screen_line+x+ix,
    890                           *blend_run=blend_line+x+ix-blendx,
    891                           *caddr1,*caddr2,r_dest,g_dest,b_dest;     
    892              
    893             slam_length-=chop_length;
    894             ix+=chop_length;   
    895 
    896 
    897             while (chop_length--)
    898             {
    899               caddr1=paddr+(int)(*blend_run)*3;
    900               caddr2=paddr+(int)(*datap)*3;
    901              
    902               r_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
    903               caddr1++; caddr2++;
    904 
    905               g_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
    906               caddr1++; caddr2++;
    907 
    908               b_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
    909 
    910               *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
    911 
    912              
    913               screen_run++;
    914               blend_run++;
    915               datap++;         
    916             }
    917             datap+=slam_length;
    918             ix+=slam_length;       
    919           }                 
    920 
    921         }
    922       }     
    923     }     
    924   }   
    925 
    926 
    927 }
    928 
    929 void trans_image::put_predator(image *screen, int x, int y) 
     878      datap++;
     879      if (ix<w)
     880      {
     881    slam_length=*datap;     // find the length of this run
     882    datap++;
     883    if (x+ix+slam_length<x1 || x+ix>x2)  // see if this run is totally clipped
     884    {
     885      datap+=slam_length;
     886      ix+=slam_length;
     887    }
     888    else
     889    {
     890      if (x+ix<x1)                // the left side needs to be chopped ?
     891      {
     892        chop_length=(x1-x-ix);
     893
     894        if (chop_length>=slam_length)  // see if we chopped it all off
     895        {                              // yes, we did
     896          ix+=slam_length;             // advance everything to the end of run
     897          datap+=slam_length;
     898          slam_length=0;
     899        } else
     900        {
     901          slam_length-=chop_length;   // else advance everything to begining of slam
     902          ix+=chop_length;
     903          datap+=chop_length;
     904        }
     905      }
     906
     907      if (slam_length)   // see if there is anything left to slam
     908      {
     909
     910        if (x+ix+slam_length>x2) // see if right side needs to be chopped off
     911          chop_length=x2-x-ix;
     912        else chop_length=slam_length;
     913
     914        uint8_t *screen_run=screen_line+x+ix,
     915                      *blend_run=blend_line+x+ix-blendx,
     916                      *caddr1,*caddr2,r_dest,g_dest,b_dest;
     917
     918        slam_length-=chop_length;
     919        ix+=chop_length;
     920
     921
     922        while (chop_length--)
     923        {
     924          caddr1=paddr+(int)(*blend_run)*3;
     925          caddr2=paddr+(int)(*datap)*3;
     926
     927          r_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
     928          caddr1++; caddr2++;
     929
     930          g_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
     931          caddr1++; caddr2++;
     932
     933          b_dest=((int)(*caddr1)-(int)(*caddr2))*blend_amount/16+(int)(*caddr2);
     934
     935          *screen_run=f->lookup_color(r_dest>>3,g_dest>>3,b_dest>>3);
     936
     937
     938          screen_run++;
     939          blend_run++;
     940          datap++;
     941        }
     942        datap+=slam_length;
     943        ix+=slam_length;
     944      }
     945
     946    }
     947      }
     948    }
     949  }
     950
     951  screen->unlock();
     952}
     953
     954void trans_image::put_predator(image *screen, int x, int y)
    930955{
    931956  int16_t x1,y1,x2,y2;
     
    933958
    934959  screen->get_clip(x1,y1,x2,y2);
    935   register uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
     960  uint8_t *datap=clip_y(screen,x1,y1,x2,y2,x,y,ysteps),*screen_line;
    936961  if (!datap) return ;     // if clip_y says nothing to draw, return
    937962
     
    946971      if (x<w)
    947972      {
    948         int run_size=*datap;
    949         datap+=run_size+1;
    950         x+=run_size;
    951       }
    952     }
    953     if (y==y2) 
     973    int run_size=*datap;
     974    datap+=run_size+1;
     975    x+=run_size;
     976      }
     977    }
     978    if (y==y2)
    954979      return;
    955980    else
    956       y++;   
     981      y++;
    957982  }*/
    958  
    959   screen_line=screen->scan_line(y)+x; 
     983
     984  screen->lock();
     985  screen_line=screen->scan_line(y)+x;
    960986  int sw=screen->width();
    961987  x1-=x; x2-=x;
    962988  for (;ysteps>0;ysteps--)
    963   {         
    964     register int ix,slam_length;
     989  {
     990    int ix,slam_length;
    965991    for (ix=0;ix<w;)
    966992    {
    967993      ix+=(*datap);       // skip over empty space
    968       datap++; 
    969       if (ix<w)           
    970       { 
    971         slam_length=*datap;     // find the length of this run   
    972         datap++;         
    973         if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
    974         {
    975           datap+=slam_length;
    976           ix+=slam_length;         
    977         }
    978         else
    979         {                   
    980           if (ix<x1)                // the left side needs to be chopped ?
    981           {                   
    982             chop_length=(x1-ix);
    983            
    984             if (chop_length>=slam_length)  // see if we chopped it all off
    985             {                              // yes, we did
    986               ix+=slam_length;             // advance everything to the end of run
    987               datap+=slam_length;             
    988               slam_length=0;           
    989             } else
    990             {       
    991               slam_length-=chop_length;   // else advance everything to begining of slam 
    992               ix+=chop_length;
    993               datap+=chop_length;           
    994             }       
    995           }               
    996 
    997           if (slam_length)   // see if there is anything left to slam
    998           {
    999             if (ix+slam_length>x2) // see if right side needs to be chopped off
    1000               memcpy(screen_line+ix,screen_line+sw+sw+ix,x2-ix+1);
    1001             else
    1002               memcpy(screen_line+ix,screen_line+sw+sw+ix,slam_length);
    1003             datap+=slam_length;
    1004             ix+=slam_length;       
    1005           }                   
    1006         }
    1007       }     
     994      datap++;
     995      if (ix<w)
     996      {
     997    slam_length=*datap;     // find the length of this run
     998    datap++;
     999    if (ix+slam_length<x1 || ix>x2)  // see if this run is totally clipped
     1000    {
     1001      datap+=slam_length;
     1002      ix+=slam_length;
     1003    }
     1004    else
     1005    {
     1006      if (ix<x1)                // the left side needs to be chopped ?
     1007      {
     1008        chop_length=(x1-ix);
     1009
     1010        if (chop_length>=slam_length)  // see if we chopped it all off
     1011        {                              // yes, we did
     1012          ix+=slam_length;             // advance everything to the end of run
     1013          datap+=slam_length;
     1014          slam_length=0;
     1015        } else
     1016        {
     1017          slam_length-=chop_length;   // else advance everything to begining of slam
     1018          ix+=chop_length;
     1019          datap+=chop_length;
     1020        }
     1021      }
     1022
     1023      if (slam_length)   // see if there is anything left to slam
     1024      {
     1025        if (ix+slam_length>x2) // see if right side needs to be chopped off
     1026          memcpy(screen_line+ix,screen_line+sw+sw+ix,x2-ix+1);
     1027        else
     1028          memcpy(screen_line+ix,screen_line+sw+sw+ix,slam_length);
     1029        datap+=slam_length;
     1030        ix+=slam_length;
     1031      }
     1032    }
     1033      }
    10081034    }
    10091035    screen_line+=sw;
    1010   }   
     1036  }
     1037  screen->unlock();
    10111038}
    10121039
     
    10231050      if (x<w)
    10241051      {
    1025         int s=*d; d++; t+=s+1;
    1026         d+=s;
    1027         x+=s;
    1028       }     
     1052    int s=*d; d++; t+=s+1;
     1053    d+=s;
     1054    x+=s;
     1055      }
    10291056    }
    10301057  }
Note: See TracChangeset for help on using the changeset viewer.